@tangle-network/agent-eval 0.203.1 → 0.204.0

package/dist/{statistical-heldout-CJYAO-4a.d.ts → statistical-heldout-Dq3pnmxd.d.ts}

@@ -1,7 +1,7 @@
 import { a as RunRecord } from "./run-record-DF-fuu31.js";
 import { a as PairedPromotionDecision, d as PairedBootstrapResult, i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod, u as PairedBootstrapOptions } from "./paired-promotion-decision-DPKz8ZnF.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.js";
-import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-Duc6xOoW.js";
+import { R as Scenario, a as CampaignResult, b as GenerationRecord, h as GateContext, j as MutableSurface, p as Gate, v as GateResult, w as JudgeScore } from "./types-ZUy5HGY5.js";
 import { z } from "zod";
 //#region src/statistics/paired-binary.d.ts
 /** A binomial proportion estimate with a confidence interval. */
@@ -1306,4 +1306,4 @@ declare function dimensionRegressions(candidate: Map<string, Record<string, Judg
 }): DimensionRegression[];
 //#endregion
 export { paretoSignificanceGate as $, PairArmsOptions as A, FinalEvidenceReservation as At, PowerPreflight as B, RiskDifferenceResult as Bt, hashJson as C, verifyAttestation as Ct, ComparePairedArmsOptions as D, FinalEvidenceMeasurement as Dt, verifyManifest as E, FinalEvidenceLedger as Et, PairedCorrectness as F, EProcessStep as Ft, BuildEvidenceVectorOptions as G, pairedRiskDifference as Gt, powerPreflight as H, isBinaryOutcomeVector as Ht, PairedMetricDelta as I, eProcess as It, ParetoSignificanceGateOptions as J, passAtK as Jt, EvidenceVector as K, pairedRiskDifferenceExact as Kt, comparePairedArms as L, ExactRiskDifferenceResult as Lt, PairRunRecordsResult as M, EProcess as Mt, PairedArmRow as N, EProcessOptions as Nt, MatchedPair as O, FinalEvidenceOutcome as Ot, PairedArmsComparison as P, EProcessState as Pt, paretoPolicy as Q, pairArms as R, McNemarResult as Rt, evaluateHypothesis as S, attest as St, signManifest as T, FinalEvidenceError as Tt, AxisEvidence as U, mcnemar as Ut, PowerPreflightOptions as V, ScoreRiskDifferenceResult as Vt, AxisVerdict as W, pairedBinaryScale as Wt, PromotionPolicy as X, PromotionObjective as Y, wilson as Yt, buildEvidenceVector as Z, sequentialPairedGate as _, verifyEvidenceReceipt as _t, detectScale as a, createCampaignEvidenceReceipt as at, SignedManifest as b, AttestationVerification as bt, pairHoldout as c, EVIDENCE_RECEIPT_VERSION as ct, SequentialDecision as d, EvidenceBinding as dt, Objective as et, SequentialObservation as f, EvidenceReceipt as ft, sequentialDecide as g, isIndependentEvidence as gt, SequentialStreamState as h, createEvidenceReceipt as ht, PairedHoldout as i, CampaignEvidenceContext as it, PairArmsResult as j, openFinalEvidenceLedger as jt, MatchedRunRecordPair as k, FinalEvidenceRecord as kt, SequentialDecideFn as l, EvidenceAuthority as lt, SequentialPairedGateOptions as m, INDEPENDENT_EVIDENCE_AUTHORITY_KINDS as mt, HeldoutSignificance as n, dominates as nt, dimensionRegressions as o, CreateEvidenceReceiptInput as ot, SequentialPairedGate as p, EvidenceReceiptVerification as pt, ObjectiveSource as q, pairedRiskDifferenceScore as qt, HeldoutSignificanceOptions as r, paretoFrontier as rt, heldoutSignificance as s, EVIDENCE_AUTHORITY_KINDS as st, DimensionRegression as t, ParetoResult as tt, SequentialDecideOptions as u, EvidenceAuthorityKind as ut, HypothesisManifest as v, ATTESTATION_ALGORITHM as vt, manifestContentDigest as w, FinalEvidenceConflictError as wt, SignedManifestAlgo as x, AttestedReport as xt, HypothesisResult as y, AttestationProvenance as yt, pairRunRecords as z, ProportionInterval as zt };
-//# sourceMappingURL=statistical-heldout-CJYAO-4a.d.ts.map
+//# sourceMappingURL=statistical-heldout-Dq3pnmxd.d.ts.map

package/dist/{statistical-heldout-CJYAO-4a.d.ts.map → statistical-heldout-Dq3pnmxd.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"statistical-heldout-CJYAO-4a.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;;;;UAgBiB;;EAEf;;EAEA;;EAEA;;;;;;;;;iBAUc,OAAO,mBAAmB,WAAW,sBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CzD,sBAAsB,QAAQ;;UAU7B;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;iBAec,QACd,SAAS,6BACT,WAAW,8BACV;;UAmBc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;iBAkBc,qBACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;UAkCc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Bc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;UAyEc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Dc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;;;;;;;;;;;;;;;;;iBAiFa,kBACd,QAAQ,mBACR,OAAO;;;;;;;;;;;iBA0BO,QAAQ,WAAW,WAAW;;;UCrgB7B;;;EAGf;;;;EAIA;;;;EAIA;;;;;;;;EAQA,SAAS;;UAGM;;EAEf;;EAEA;;EAEA;;;;;;;;;;UAWe,sBAAsB;EACrC;EACA;EACA;;EAEA;;EAEA;;EAEA;;;EAGA;;UAGe;;;EAGf,OAAO,YAAY;EACnB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BK,SAAS,OAAM,kBAAuB;;;cCnFhD,mBAAiB,EAAA;;;;;;GAQZ,EAAA,KAAA;;KAGC,2BAA2B,EAAE,aAAa;cAEhD,mBAAiB,EAAA;;;GAKZ,EAAA,KAAA;KAEC,2BAA2B,EAAE,aAAa;UAgCrC;EACf,aAAa;EACb,iBAAiB;EACjB;IAAY,aAAa;IAA0B,WAAW;;;KAGpD,qBAAqB;EAC3B;EAAiB,OAAO;;EACxB;EAAkB;IAAS;IAA8C;;;UAE9D;EACf,QACE,OAAO,2BACN,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,OACE,mBACA,aAAa,2BACZ,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,QAAQ,QAAQ,qBAAqB;;;cAI1B,2BAA2B;WAE3B;EADX,YACW,8CACT;;;cAQS,mCAAmC;EAC9C,YAAY;;;iBA+HE,wBAAwB;EAAW;IAAiB;;;;;;;;;;;;;;;;;;;;;;;cCvMvD;UAEI;;EAEf,eAAe;;EAEf;;;EAGA;;EAEA;;EAEA;;;EAGA;;UAGe;;EAEf;EACA,YAAY;EACZ,kBAAkB;;EAElB;;UAGe;EACf;;EAEA;;;;;;;;iBAiBc,OAAO,iBAAiB,YAAY,wBAAwB;;;;;;;;;;iBAoB5D,kBACd,iBACA,UAAU,iBACT;;;cC1EU;;cAGA;KAQD,gCAAgC;cAE/B;UAOI;WACN,MAAM;;WAEN;;UAGM;WACN,sBAAsB;;WAEtB;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA,WAAW;;WAEX;;WAEA;;UAGM;WACN,SAAS;WACT,aAAa;;UAGP;WACN;WACA;;UAGM,mCAAmC,KAAK;;;;;;;iBAQzC,sBACd,OAAO,4BACP,YAAY,wBACX;;;;;iBA4Ba,sBAAsB,SAAS,kBAAkB;;;;;;iBAkCjD,sBAAsB,SAAS;;;;KCjJnC,0BAA0B,KACpC;EAOI,YAAY,KAAK;;;iBAGP,8BAA8B,UAAU,UAAU,GAAG;EACnE,UAAU,eAAe,GAAG;EAC5B,SAAS;EACT,SAAS;IAAAA;;;;;;;;;;;;;;;;;;KCPC;UAEK,UAAU;;EAEzB;EACA,WAAW;EACX,QAAQ,WAAW;;UAGJ,aAAa;EAC5B,UAAU;EACV,WAAW;;EAEX,cAAc;IAAQ,WAAW;IAAG,WAAW;;;;iBAIjC,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,YAAY,UAAU;;;;;;iBAmB/C,eAAe,GAAG,YAAY,KAAK,YAAY,UAAU,OAAO,aAAa;;;;;KCxBjF;EAAoB;;EAAwB;EAAmB;;UAE1D;;EAEf;EACA,QAAQ;;;EAGR,WAAW;;;;EAIX;;;;EAIA;;;;;EAKA;;;;KAKU;UAEK;EACf;EACA,QAAQ;EACR,WAAW;;;;;;;;EAQX,WAAW;;;;;EAKX;;;EAGA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;;EAGT;;EAEA;EACA;EACA,gBAAgB;EAChB;EACA;EACA,SAAS;;UAGM;;EAEf,MAAM;;;EAGN;;;EAGA;IAAQ;IAAmB;;;;;;KAMjB,mBAAmB,IAAI,mBAAmB;UAErC;;;;EAIf;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;;iBASc,oBAAoB,WAAW,kBAAkB,UAC/D,KAAK,YAAY,WAAW,YAC5B,YAAY,sBACZ,OAAM,6BACL;;;;;;cAkIU,cAAc;UA+EV,sCAAsC;;EAErD,YAAY;;;EAGZ,SAAS;;EAET;;;;;;;iBAQc,uBAAuB,qBAAqB,kBAAkB,WAAW,UACvF,SAAS,gCACR,KAAK,WAAW;;;;;;;;;;;;;;;;;UCzVF;;EAEf;;;EAGA;;EAEA;;EAEA;;;;EAIA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;;;EAGA;EACA;EACA;;EAEA;;EAEA;;;iBAYc,eAAe,MAAM,wBAAwB;;;;;UCzB5C;;;EAGf;;;;;EAKA;;EAEA;;EAEA;;EAEA,UAAU;;UAGK;;EAEf;;EAEA;;;UAIe;EACf;;;;EAIA;EACA,UAAU;EACV,WAAW;;UAGI;;EAEf,OAAO;;;EAGP,kBAAkB;;EAElB,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAqBL,SAAS,eAAe,gBAAgB,MAAM,kBAAkB;;UA8G/D;;EAEf;;EAEA;;EAEA,SAAS;;EAET,gBAAgB;;;UAID;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,aAAa;;EAEb;IAAY;IAAW;;;UAGR,iCAAiC;;;;EAIhD;;EAEA,YAAY;;UAGG;EACf;EACA;EACA;;;EAGA,aAAa;EACb,cAAc;;;;;;;;;;;;;;;iBAgBA,kBACd,eAAe,gBACf,MAAM,2BACL;UAmEc;EACf;EACA;EACA,UAAU;EACV,WAAW;;UAGI;EACf,OAAO;EACP,kBAAkB;EAClB,mBAAmB;;;;;;;;;iBAeL,eACd,uBAAuB,aACvB,wBAAwB,cACvB;;;;;;;;;;;;;;;;UCrWc;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;;KAIU;UAEK,uBAAuB;;EAEtC;;EAEA,MAAM;;UAGS;EACf,UAAU;EACV;EACA;EACA;;;EAGA;;EAEA,kBAAkB;EAGlB;;;;;;;;;;;;;;;;;iBAkBoB,SAAS,GAAG,KAAK,IAAI;;;;;iBAQ3B,sBAAsB,UAAU;;;;;;iBAc1B,aAAa,GAAG,qBAAqB,QAAQ;;;;;iBAS7C,eAAe,GAAG,iBAAiB;;;;;iBAYnC,mBACpB,UAAU,gBACV;EAAY;EAAW;EAAgB;IACtC,QAAQ;;;KCrFC;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;;EAIA,8BAA8B;;;EAG9B,kBAAkB;;EAElB;;;;;;;EAOA,SAAS;;;;;;KAOC,wBAAwB;EAAkB,UAAU;;UAE/C,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;;;EAUxB,QAAQ,gBAAgB;;;EAGxB,SAAS;;;;;;;;;;;;;;;;;iBAuPK,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UA6GlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;;;UC9dxD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBA4Ec,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAkEc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;EAEA,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BhB,oBACd,QAAQ,eACR,OAAM,6BACL;UA2Ec;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;EAIA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;;;;iBAMc,YAAY;;;;;;;;;iBAYZ,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;EACA,8BAA8B;EAC9B;IAED"}
+{"version":3,"file":"statistical-heldout-Dq3pnmxd.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":"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"}

package/dist/{store-otlp-yd9lDziN.js → store-otlp-BA7G1Du-.js}

@@ -1,5 +1,5 @@
 import { n as CaptureIntegrityError } from "./errors-Dngq5h35.js";
-import { A as spanEpochMillis, C as TraceFileTooLargeError, D as extractOtlpAttributes, E as compareSpanTime, S as TraceFileMissingError, _ as SpanNotFoundError, b as TraceAnalysisValidationError, d as compileSearchRegex, f as truncateForBudget, g as TRACE_ANALYSIS_LIMITS, k as projectOtlpFlatLine, l as bindSpanSourceReader, m as DEFAULT_TRACE_ANALYST_BUDGETS, p as validateInteger, v as TraceAnalysisLimitError, w as TraceNotFoundError, x as TraceFileMalformedError } from "./kind-factory-CdPPHtGZ.js";
+import { A as projectOtlpFlatLine, C as TraceFileMissingError, D as compareSpanTime, O as extractOtlpAttributes, S as TraceFileMalformedError, T as TraceNotFoundError, _ as TRACE_ANALYSIS_LIMITS, d as traceSpanSchema, f as compileSearchRegex, h as DEFAULT_TRACE_ANALYST_BUDGETS, j as spanEpochMillis, l as bindSpanSourceReader, m as validateInteger, p as truncateForBudget, v as SpanNotFoundError, w as TraceFileTooLargeError, x as TraceAnalysisValidationError, y as TraceAnalysisLimitError } from "./kind-factory-Cn1lbsAd.js";
 import { readFile, stat } from "node:fs/promises";
 //#region src/trace-analyst/shared-abortable-task.ts
 function createSharedAbortableTask(factory) {
@@ -86,7 +86,7 @@ async function scanCheckpoint(signal, item) {
 }
 /** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */
 const DEFAULT_MAX_TRACE_FILE_BYTES = 268435456;
-var BufferedOtlpTraceStore = class {
+var BufferedTraceStore = class {
 	readSpanSource;
 	perAttributeViewBudget;
 	perAttributeSpanBudget;
@@ -142,7 +142,7 @@ var BufferedOtlpTraceStore = class {
 		for (const t of matched) {
 			await scanCheckpoint(context?.signal, traceIndex++);
 			if (t.service_name) services.add(t.service_name);
-			if (t.agent_name) agents.add(t.agent_name);
+			for (const agent of t.agents) agents.add(agent);
 			for (const m of t.models) models.add(m);
 			for (const tn of t.tools) tools.add(tn);
 			rawBytes += t.raw_jsonl_bytes;
@@ -346,6 +346,9 @@ var BufferedOtlpTraceStore = class {
 		}
 		return waitForSharedTask(this.bufferTask, context?.signal);
 	}
+	projectRecord(raw) {
+		return projectOtlpFlatLine(raw);
+	}
 	async index(context) {
 		context?.signal?.throwIfAborted();
 		if (this.indexValue) return this.indexValue;
@@ -392,7 +395,7 @@ var BufferedOtlpTraceStore = class {
 				throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset, cause);
 			}
 			if (!parsed || typeof parsed !== "object") throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
-			const span = projectOtlpFlatLine(parsed);
+			const span = this.projectRecord(parsed);
 			if (!span) throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset);
 			let entry = byTrace.get(span.trace_id);
 			if (!entry) {
@@ -406,6 +409,7 @@ var BufferedOtlpTraceStore = class {
 					end_time: span.end_time,
 					duration_ms: 0,
 					raw_jsonl_bytes: 0,
+					agents: /* @__PURE__ */ new Set(),
 					models: /* @__PURE__ */ new Set(),
 					tools: /* @__PURE__ */ new Set(),
 					spans: []
@@ -438,6 +442,7 @@ var BufferedOtlpTraceStore = class {
 			if (span.status === "ERROR") entry.has_errors = true;
 			if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time;
 			if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time;
+			if (span.agent_name) entry.agents.add(span.agent_name);
 			if (span.model_name) entry.models.add(span.model_name);
 			if (span.tool_name) entry.tools.add(span.tool_name);
 		}
@@ -476,7 +481,7 @@ var BufferedOtlpTraceStore = class {
 				if (!t.service_name || !filters.service_names.includes(t.service_name)) continue;
 			}
 			if (filters.agent_names && filters.agent_names.length > 0) {
-				if (!t.agent_name || !filters.agent_names.includes(t.agent_name)) continue;
+				if (![...t.agents].some((agent) => filters.agent_names.includes(agent))) continue;
 			}
 			if (filters.model_names && filters.model_names.length > 0) {
 				if (![...t.models].some((m) => filters.model_names.includes(m))) continue;
@@ -610,7 +615,7 @@ var BufferedOtlpTraceStore = class {
 		};
 	}
 };
-var OtlpFileTraceStore = class extends BufferedOtlpTraceStore {
+var OtlpFileTraceStore = class extends BufferedTraceStore {
 	path;
 	maxFileBytes;
 	constructor(opts) {
@@ -637,7 +642,7 @@ var OtlpFileTraceStore = class extends BufferedOtlpTraceStore {
 		return this.path;
 	}
 };
-var OtlpBufferTraceStore = class extends BufferedOtlpTraceStore {
+var BufferTraceStore = class extends BufferedTraceStore {
 	source;
 	constructor(source, opts) {
 		super(opts);
@@ -651,13 +656,41 @@ var OtlpBufferTraceStore = class extends BufferedOtlpTraceStore {
 		return "<memory>";
 	}
 };
+var SpanRecordTraceStore = class extends BufferTraceStore {
+	projectRecord(raw) {
+		return traceSpanSchema.parse(raw);
+	}
+};
+/**
+* Snapshot canonical spans without reinterpreting their identifiers, kind, or duration.
+* Reads use the same indexed, bounded engine as the OTLP adapters. Raw byte counts
+* and searches refer to the canonical JSONL snapshot, not an external source artifact.
+*/
+function spanRecordsToTraceAnalysisStore(records, options = {}) {
+	if (!records || records.length === 0) throw new CaptureIntegrityError("spanRecordsToTraceAnalysisStore: no span records supplied");
+	const seen = /* @__PURE__ */ new Map();
+	const lines = records.map((record, index) => {
+		try {
+			const span = traceSpanSchema.parse(record);
+			const traceSpans = seen.get(span.trace_id) ?? /* @__PURE__ */ new Set();
+			if (traceSpans.has(span.span_id)) throw new CaptureIntegrityError(`spanRecordsToTraceAnalysisStore: duplicate span '${span.span_id}' in trace '${span.trace_id}'`);
+			traceSpans.add(span.span_id);
+			seen.set(span.trace_id, traceSpans);
+			return JSON.stringify(span);
+		} catch (cause) {
+			if (cause instanceof CaptureIntegrityError) throw cause;
+			throw new CaptureIntegrityError(`spanRecordsToTraceAnalysisStore: invalid span record at index ${index}`, { cause });
+		}
+	});
+	return new SpanRecordTraceStore(Buffer.from(`${lines.join("\n")}\n`, "utf8"), options);
+}
 /** Build the bounded trace store directly from OpenInference JSONL text. */
 function otlpTextToTraceAnalysisStore(text, opts = {}) {
 	if (!text.trim()) throw new CaptureIntegrityError("OTLP trace text must not be empty");
-	return new OtlpBufferTraceStore(Buffer.from(text, "utf8"), opts);
+	return new BufferTraceStore(Buffer.from(text, "utf8"), opts);
 }
 function createOtlpBufferTraceStore(source, options = {}) {
-	return new OtlpBufferTraceStore(source, options);
+	return new BufferTraceStore(source, options);
 }
 /** A `"` at `idx` is a real JSON delimiter only when the run of `\`
 *  immediately preceding it is even-length; an odd run means the quote
@@ -757,6 +790,6 @@ function finalizeErrorClusters(clusters, errorTraceCount) {
 	return out;
 }
 //#endregion
-export { otlpTextToTraceAnalysisStore as i, OtlpFileTraceStore as n, createOtlpBufferTraceStore as r, DEFAULT_MAX_TRACE_FILE_BYTES as t };
+export { spanRecordsToTraceAnalysisStore as a, otlpTextToTraceAnalysisStore as i, OtlpFileTraceStore as n, createOtlpBufferTraceStore as r, DEFAULT_MAX_TRACE_FILE_BYTES as t };
 
-//# sourceMappingURL=store-otlp-yd9lDziN.js.map
+//# sourceMappingURL=store-otlp-BA7G1Du-.js.map

package/dist/store-otlp-BA7G1Du-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-otlp-BA7G1Du-.js","names":[],"sources":["../src/trace-analyst/shared-abortable-task.ts","../src/trace-analyst/store-otlp.ts"],"sourcesContent":["export interface SharedAbortableTask<T> {\n  controller: AbortController\n  promise: Promise<T>\n  consumers: number\n  settled: boolean\n}\n\nexport function createSharedAbortableTask<T>(\n  factory: (signal: AbortSignal) => Promise<T>,\n): SharedAbortableTask<T> {\n  const controller = new AbortController()\n  const task: SharedAbortableTask<T> = {\n    controller,\n    promise: factory(controller.signal),\n    consumers: 0,\n    settled: false,\n  }\n  void task.promise.then(\n    () => {\n      task.settled = true\n    },\n    () => {\n      task.settled = true\n    },\n  )\n  return task\n}\n\nexport function waitForSharedTask<T>(\n  task: SharedAbortableTask<T>,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  signal?.throwIfAborted()\n  task.consumers += 1\n\n  return new Promise<T>((resolve, reject) => {\n    let finished = false\n    const finish = (callback: () => void): void => {\n      if (finished) return\n      finished = true\n      signal?.removeEventListener('abort', onAbort)\n      task.consumers -= 1\n      callback()\n    }\n    const onAbort = (): void => {\n      finish(() => {\n        reject(signal?.reason)\n        if (!task.settled && task.consumers === 0) {\n          task.controller.abort(signal?.reason)\n        }\n      })\n    }\n\n    signal?.addEventListener('abort', onAbort, { once: true })\n    task.promise.then(\n      (value) => finish(() => resolve(value)),\n      (error: unknown) => finish(() => reject(error)),\n    )\n    if (signal?.aborted) onAbort()\n  })\n}\n","/**\n * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the\n * trace-analyst.\n *\n * Wire shape. Each line of the input file is one OTLP-shaped span. The\n * store understands flattened OTLP JSONL plus the OpenInference vocab.\n * We project upstream's full\n * span shape down to `TraceAnalystSpan` lazily — full materialisation\n * only happens for the spans the agent actually requests.\n *\n * Indexing. On first read the store builds an in-memory index keyed\n * by `trace_id` carrying:\n *   - byte offsets + lengths for each span line (for surgical reads\n *     without re-parsing the whole file)\n *   - a `TraceAnalystTraceSummary` rollup\n *   - sets of services / agents / models / tools / has_errors\n *   - byte size of the trace's JSONL slab\n *\n * Memory bound. The index keeps span metadata only — names, kinds,\n * offsets, status. Attribute payloads stay on disk until requested.\n * For a 50MB JSONL with 50k spans, the index is ~5MB.\n *\n * Concurrency. The store builds the index once on first read and\n * caches it. Subsequent reads reuse the index. The file is opened on\n * each read; we never hold a long-lived FD.\n */\n\nimport { readFile, stat } from 'node:fs/promises'\nimport type { RE2JS } from 're2js'\nimport { CaptureIntegrityError } from '../errors'\nimport {\n  SpanNotFoundError,\n  TraceAnalysisLimitError,\n  TraceAnalysisValidationError,\n  TraceFileMalformedError,\n  TraceFileMissingError,\n  TraceFileTooLargeError,\n  TraceNotFoundError,\n} from './errors'\nimport {\n  compareSpanTime,\n  extractOtlpAttributes,\n  projectOtlpFlatLine,\n  spanEpochMillis,\n} from './otlp-span'\nimport {\n  createSharedAbortableTask,\n  type SharedAbortableTask,\n  waitForSharedTask,\n} from './shared-abortable-task'\nimport {\n  compileSearchRegex,\n  TRACE_ANALYSIS_LIMITS,\n  type TraceAnalysisStore,\n  type TraceAnalysisStoreContext,\n  truncateForBudget,\n  validateInteger,\n} from './store'\nimport { bindSpanSourceReader } from './store-boundary'\nimport type { SpanSourceReader } from './store-contract'\nimport { traceSpanSchema } from './store-schemas'\nimport {\n  type DatasetOverview,\n  DEFAULT_TRACE_ANALYST_BUDGETS,\n  type ErrorCluster,\n  type QueryTracesPage,\n  type SearchSpanResult,\n  type SearchTraceResult,\n  type SpanMatchRecord,\n  type TraceAnalystFilters,\n  type TraceAnalystSpan,\n  type TraceAnalystSpanKind,\n  type TraceAnalystSpanStatus,\n  type TraceAnalystTraceSummary,\n  type ViewSpansResult,\n  type ViewTraceOversized,\n  type ViewTraceResult,\n} from './types'\n\n/** Lines indexed between event-loop yields. Bounded synchronous work per\n *  tick keeps the index build from starving other tasks on large files\n *  while staying coarse enough that the yields are cheap. */\nconst INDEX_YIELD_LINES = 5000\nconst SCAN_YIELD_ITEMS = 500\n\n/** Hand control back to the event loop without busy-waiting. */\nfunction yieldToEventLoop(): Promise<void> {\n  return new Promise((resolve) => setImmediate(resolve))\n}\n\nasync function scanCheckpoint(signal: AbortSignal | undefined, item: number): Promise<void> {\n  signal?.throwIfAborted()\n  if (item > 0 && item % SCAN_YIELD_ITEMS === 0) {\n    await yieldToEventLoop()\n    signal?.throwIfAborted()\n  }\n}\n\ninterface SpanIndexEntry {\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: TraceAnalystSpanKind\n  start_time: string\n  end_time: string\n  duration_ms: number\n  status: TraceAnalystSpanStatus\n  status_message: string | undefined\n  service_name: string | null\n  agent_name: string | null\n  model_name: string | null\n  tool_name: string | null\n  /** Byte offset in the raw JSONL file to the start of this span's line. */\n  line_byte_offset: number\n  /** Length of this line in bytes (excluding the trailing newline). */\n  line_byte_length: number\n}\n\ninterface TraceIndexEntry {\n  trace_id: string\n  service_name: string | null\n  agent_name: string | null\n  span_count: number\n  has_errors: boolean\n  start_time: string\n  end_time: string\n  duration_ms: number\n  raw_jsonl_bytes: number\n  agents: Set<string>\n  models: Set<string>\n  tools: Set<string>\n  spans: SpanIndexEntry[]\n  /** Sorted by line offset for stable iteration. */\n}\n\ninterface DatasetIndex {\n  byTrace: Map<string, TraceIndexEntry>\n  totalRawBytes: number\n  // Pre-computed sorted trace_ids for sample/query stability.\n  sortedTraceIds: string[]\n}\n\nexport interface ToolSpansToTraceAnalysisStoreOptions {\n  /** Authorized original-record lookup, exposed only when supplied. */\n  sourceReader?: SpanSourceReader\n  /** Override the discovery (`viewTrace`) per-attribute byte cap. */\n  perAttributeViewBudget?: number\n  /** Override the surgical (`viewSpans`) per-attribute byte cap. */\n  perAttributeSpanBudget?: number\n  /** Override the per-call ceiling that triggers oversized summaries. */\n  perCallByteCeiling?: number\n  /** Override the per-match text budget. */\n  perMatchTextBudget?: number\n}\n\n/** Budgets and authorized source access shared by canonical span-record stores. */\nexport type SpanRecordsToTraceAnalysisStoreOptions = ToolSpansToTraceAnalysisStoreOptions\n\ntype BufferedTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions\n\nexport interface OtlpFileTraceStoreOptions extends BufferedTraceStoreOptions {\n  /** Path to the OTLP-JSONL file. */\n  path: string\n  /**\n   * Hard ceiling on the trace file size in bytes. The store reads the\n   * whole file into one Buffer and indexes it in memory, so an\n   * unbounded file OOMs the process. Above this size the store fails\n   * loud with `TraceFileTooLargeError` instead of degrading silently.\n   * Default 256 MiB.\n   */\n  maxFileBytes?: number\n}\n\n/** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */\nexport const DEFAULT_MAX_TRACE_FILE_BYTES = 256 * 1024 * 1024\n\nabstract class BufferedTraceStore implements TraceAnalysisStore {\n  readonly readSpanSource?: SpanSourceReader\n  private readonly perAttributeViewBudget: number\n  private readonly perAttributeSpanBudget: number\n  private readonly perCallByteCeiling: number\n  private readonly perMatchTextBudget: number\n  private indexValue?: DatasetIndex\n  private indexTask?: SharedAbortableTask<DatasetIndex>\n  private bufferValue?: Buffer\n  private bufferTask?: SharedAbortableTask<Buffer>\n\n  constructor(opts: BufferedTraceStoreOptions) {\n    this.perAttributeViewBudget = validateInteger(\n      opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget,\n      'perAttributeViewBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    this.perAttributeSpanBudget = validateInteger(\n      opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget,\n      'perAttributeSpanBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    this.perCallByteCeiling = validateInteger(\n      opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling,\n      'perCallByteCeiling',\n      1,\n    )\n    this.perMatchTextBudget = validateInteger(\n      opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget,\n      'perMatchTextBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    if (opts.sourceReader !== undefined) {\n      this.readSpanSource = bindSpanSourceReader(this, opts.sourceReader, {\n        perAttributeSpanBudget: this.perAttributeSpanBudget,\n        perCallByteCeiling: this.perCallByteCeiling,\n      })\n    }\n  }\n\n  // ─── Public API ────────────────────────────────────────────────────\n\n  async hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    context?.signal?.throwIfAborted()\n    return idx.byTrace.has(trace_id)\n  }\n\n  async hasSpans(\n    opts: { trace_id: string; span_ids: readonly string[] },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<string[]> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) return []\n    const requested = new Set(opts.span_ids)\n    const found: string[] = []\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const spanId = trace.spans[index]!.span_id\n      if (requested.has(spanId)) found.push(spanId)\n    }\n    return found\n  }\n\n  async getOverview(\n    filters?: TraceAnalystFilters,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<DatasetOverview> {\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, filters, context)\n\n    const services = new Set<string>()\n    const agents = new Set<string>()\n    const models = new Set<string>()\n    const tools = new Set<string>()\n    let rawBytes = 0\n    let earliest: string | null = null\n    let latest: string | null = null\n    let errorTraceCount = 0\n    let errorSpanCount = 0\n    const clusters = new Map<string, ErrorClusterAccumulator>()\n\n    let traceIndex = 0\n    for (const t of matched) {\n      await scanCheckpoint(context?.signal, traceIndex++)\n      if (t.service_name) services.add(t.service_name)\n      for (const agent of t.agents) agents.add(agent)\n      for (const m of t.models) models.add(m)\n      for (const tn of t.tools) tools.add(tn)\n      rawBytes += t.raw_jsonl_bytes\n      if (!earliest || compareSpanTime(t.start_time, earliest) < 0) earliest = t.start_time\n      if (!latest || compareSpanTime(t.end_time, latest) > 0) latest = t.end_time\n      if (t.has_errors) {\n        errorTraceCount += 1\n        let spanIndex = 0\n        for (const s of t.spans) {\n          await scanCheckpoint(context?.signal, spanIndex++)\n          if (s.status !== 'ERROR') continue\n          errorSpanCount += 1\n          accumulateErrorCluster(clusters, t.trace_id, s)\n        }\n      }\n    }\n\n    const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id)\n    return {\n      total_traces: matched.length,\n      raw_jsonl_bytes: rawBytes,\n      services: [...services].sort(),\n      agents: [...agents].sort(),\n      models: [...models].sort(),\n      tool_names: [...tools].sort(),\n      sample_trace_ids,\n      errors: { trace_count: errorTraceCount, span_count: errorSpanCount },\n      error_clusters: finalizeErrorClusters(clusters, errorTraceCount),\n      time_range: earliest && latest ? { earliest, latest } : null,\n    }\n  }\n\n  async queryTraces(\n    opts: { filters?: TraceAnalystFilters; limit: number; offset?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<QueryTracesPage> {\n    const limit = validateInteger(\n      opts.limit,\n      'queryTraces.limit',\n      1,\n      TRACE_ANALYSIS_LIMITS.queryTraces,\n    )\n    const offset = validateInteger(opts.offset ?? 0, 'queryTraces.offset', 0)\n\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, opts.filters, context)\n    const slice = matched.slice(offset, offset + limit)\n    return {\n      traces: slice.map((t) => this.toSummary(t)),\n      total: matched.length,\n      has_more: offset + slice.length < matched.length,\n    }\n  }\n\n  async countTraces(\n    filters?: TraceAnalystFilters,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<number> {\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, filters, context)\n    return matched.length\n  }\n\n  async viewTrace(\n    opts: { trace_id: string; per_attribute_byte_cap?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<ViewTraceResult> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) {\n      throw new TraceNotFoundError(opts.trace_id)\n    }\n    const cap = validateInteger(\n      opts.per_attribute_byte_cap ?? this.perAttributeViewBudget,\n      'viewTrace.per_attribute_byte_cap',\n      1,\n    )\n\n    // Probe size first — if the materialised payload would exceed\n    // the per-call ceiling we return an oversized summary rather than\n    // blowing the agent's context.\n    const buf = await this.buffer(context)\n    const spans: TraceAnalystSpan[] = []\n    let runningBytes = 0\n    let span_response_bytes_max = 0\n    const counter: TruncationCounter = { value: 0 }\n    let spanIndex = 0\n    for (const s of trace.spans) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      const bytes = Buffer.byteLength(JSON.stringify(projected), 'utf8')\n      span_response_bytes_max = Math.max(span_response_bytes_max, bytes)\n      runningBytes += bytes\n      if (runningBytes > this.perCallByteCeiling) {\n        return {\n          trace_id: trace.trace_id,\n          oversized: this.buildOversizedSummary(trace, span_response_bytes_max),\n        }\n      }\n      spans.push(projected)\n    }\n    return { trace_id: trace.trace_id, spans }\n  }\n\n  async viewSpans(\n    opts: { trace_id: string; span_ids: readonly string[]; per_attribute_byte_cap?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<ViewSpansResult> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    if (opts.span_ids.length < 1 || opts.span_ids.length > TRACE_ANALYSIS_LIMITS.viewSpans) {\n      throw new TraceAnalysisValidationError(\n        `viewSpans.span_ids must contain 1..${TRACE_ANALYSIS_LIMITS.viewSpans} ids, got ${opts.span_ids.length}`,\n      )\n    }\n    const cap = validateInteger(\n      opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget,\n      'viewSpans.per_attribute_byte_cap',\n      1,\n    )\n\n    const requested = [...new Set(opts.span_ids)]\n    const wantSet = new Set(requested)\n    const foundById = new Map<string, SpanIndexEntry>()\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const span = trace.spans[index]!\n      if (wantSet.has(span.span_id)) foundById.set(span.span_id, span)\n    }\n    const missing = requested.filter((id) => !foundById.has(id))\n\n    const buf = await this.buffer(context)\n    const spans: TraceAnalystSpan[] = []\n    let truncatedAttributeCount = 0\n    const omitted = new Set(requested.filter((id) => foundById.has(id)))\n    const buildResult = (): ViewSpansResult => ({\n      trace_id: trace.trace_id,\n      spans,\n      missing_span_ids: missing,\n      omitted_span_ids: requested.filter((id) => omitted.has(id)),\n      has_more: omitted.size > 0,\n      truncated_attribute_count: truncatedAttributeCount,\n    })\n    const metadataBytes = Buffer.byteLength(JSON.stringify(buildResult()), 'utf8')\n    if (metadataBytes > this.perCallByteCeiling) {\n      throw new TraceAnalysisLimitError(\n        'viewSpans',\n        metadataBytes,\n        this.perCallByteCeiling,\n        `viewSpans accounting requires ${metadataBytes} bytes, over the ${this.perCallByteCeiling}-byte response limit`,\n      )\n    }\n    let spanIndex = 0\n    let smallestRejectedBytes = Number.POSITIVE_INFINITY\n    for (const id of requested) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const s = foundById.get(id)\n      if (!s) continue\n      const counter: TruncationCounter = { value: 0 }\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      spans.push(projected)\n      omitted.delete(id)\n      truncatedAttributeCount += counter.value\n      const responseBytes = Buffer.byteLength(JSON.stringify(buildResult()), 'utf8')\n      if (responseBytes <= this.perCallByteCeiling) {\n        continue\n      }\n      smallestRejectedBytes = Math.min(smallestRejectedBytes, responseBytes)\n      if (requested.length === 1) {\n        throw new TraceAnalysisLimitError(\n          'viewSpans',\n          responseBytes,\n          this.perCallByteCeiling,\n          `viewSpans cannot fit span ${JSON.stringify(id)} in the ${this.perCallByteCeiling}-byte response limit`,\n        )\n      }\n      spans.pop()\n      omitted.add(id)\n      truncatedAttributeCount -= counter.value\n    }\n    if (foundById.size > 0 && spans.length === 0) {\n      throw new TraceAnalysisLimitError(\n        'viewSpans',\n        smallestRejectedBytes,\n        this.perCallByteCeiling,\n        `viewSpans cannot fit one requested span in the ${this.perCallByteCeiling}-byte response limit`,\n      )\n    }\n    return buildResult()\n  }\n\n  async searchTrace(\n    opts: { trace_id: string; regex_pattern: string; max_matches?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<SearchTraceResult> {\n    const max_matches = validateInteger(\n      opts.max_matches ?? 50,\n      'searchTrace.max_matches',\n      1,\n      TRACE_ANALYSIS_LIMITS.searchMatches,\n    )\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    const re = compileSearchRegex(opts.regex_pattern)\n\n    const buf = await this.buffer(context)\n    const hits: SpanMatchRecord[] = []\n    let hasMore = false\n    let spanIndex = 0\n    for (const s of trace.spans) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const remaining = max_matches - hits.length\n      const localHits = await this.scanSpanForMatches(\n        buf,\n        trace.trace_id,\n        s,\n        re,\n        this.perMatchTextBudget,\n        remaining,\n        context,\n      )\n      for (const h of localHits.records) {\n        if (hits.length >= max_matches) break\n        hits.push(h)\n      }\n      if (localHits.hasMore) {\n        hasMore = true\n        break\n      }\n    }\n    return {\n      trace_id: trace.trace_id,\n      hits,\n      has_more: hasMore,\n    }\n  }\n\n  async searchSpan(\n    opts: { trace_id: string; span_id: string; regex_pattern: string; max_matches?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<SearchSpanResult> {\n    const max_matches = validateInteger(\n      opts.max_matches ?? 50,\n      'searchSpan.max_matches',\n      1,\n      TRACE_ANALYSIS_LIMITS.searchMatches,\n    )\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    let span: SpanIndexEntry | undefined\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const candidate = trace.spans[index]!\n      if (candidate.span_id === opts.span_id) {\n        span = candidate\n        break\n      }\n    }\n    if (!span) {\n      throw new SpanNotFoundError(opts.trace_id, opts.span_id)\n    }\n    const re = compileSearchRegex(opts.regex_pattern)\n    const buf = await this.buffer(context)\n    const localHits = await this.scanSpanForMatches(\n      buf,\n      trace.trace_id,\n      span,\n      re,\n      this.perMatchTextBudget,\n      max_matches,\n      context,\n    )\n    return {\n      trace_id: trace.trace_id,\n      span_id: span.span_id,\n      hits: localHits.records,\n      has_more: localHits.hasMore,\n    }\n  }\n\n  // ─── Index building ────────────────────────────────────────────────\n\n  /** Force the index to materialise. Useful to amortise startup cost\n   *  before the first agent call. */\n  async ensureIndexed(context?: TraceAnalysisStoreContext): Promise<void> {\n    await this.index(context)\n  }\n\n  private async buffer(context?: TraceAnalysisStoreContext): Promise<Buffer> {\n    context?.signal?.throwIfAborted()\n    if (this.bufferValue) return this.bufferValue\n    if (!this.bufferTask) {\n      const task = createSharedAbortableTask((signal) => this.readBuffer(signal))\n      this.bufferTask = task\n      void task.promise.then(\n        (value) => {\n          this.bufferValue = value\n          if (this.bufferTask === task) this.bufferTask = undefined\n        },\n        () => {\n          if (this.bufferTask === task) this.bufferTask = undefined\n        },\n      )\n    }\n    return waitForSharedTask(this.bufferTask, context?.signal)\n  }\n\n  protected abstract readBuffer(signal?: AbortSignal): Promise<Buffer>\n\n  protected abstract sourcePath(): string\n\n  protected projectRecord(raw: Record<string, unknown>): TraceAnalystSpan | null {\n    return projectOtlpFlatLine(raw)\n  }\n\n  private async index(context?: TraceAnalysisStoreContext): Promise<DatasetIndex> {\n    context?.signal?.throwIfAborted()\n    if (this.indexValue) return this.indexValue\n    if (!this.indexTask) {\n      const task = createSharedAbortableTask((signal) => this.buildIndex(signal))\n      this.indexTask = task\n      void task.promise.then(\n        (value) => {\n          this.indexValue = value\n          if (this.indexTask === task) this.indexTask = undefined\n        },\n        () => {\n          if (this.indexTask === task) this.indexTask = undefined\n        },\n      )\n    }\n    return waitForSharedTask(this.indexTask, context?.signal)\n  }\n\n  private async buildIndex(signal?: AbortSignal): Promise<DatasetIndex> {\n    // readGuarded surfaces missing/oversized files as typed errors.\n    const buf = await this.buffer({ signal })\n    signal?.throwIfAborted()\n\n    const byTrace = new Map<string, TraceIndexEntry>()\n    let cursor = 0\n    let lineNumber = 0\n    let sinceYield = 0\n    while (cursor < buf.length) {\n      lineNumber += 1\n      // Yield to the event loop every INDEX_YIELD_LINES lines so a huge\n      // file doesn't monopolise the thread for the whole index build.\n      if (++sinceYield >= INDEX_YIELD_LINES) {\n        sinceYield = 0\n        await yieldToEventLoop()\n        signal?.throwIfAborted()\n      }\n      const newlineIndex = buf.indexOf(0x0a, cursor) // \\n\n      const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex\n      const lineLength = lineEnd - cursor\n      if (lineLength === 0) {\n        cursor = lineEnd + 1\n        continue\n      }\n      const lineSlice = buf.subarray(cursor, lineEnd).toString('utf8')\n      const lineOffset = cursor\n      cursor = lineEnd + 1\n\n      let parsed: unknown\n      try {\n        parsed = JSON.parse(lineSlice)\n      } catch (cause) {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset, cause)\n      }\n      if (!parsed || typeof parsed !== 'object') {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset)\n      }\n      const span = this.projectRecord(parsed as Record<string, unknown>)\n      if (!span) {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset)\n      }\n\n      let entry = byTrace.get(span.trace_id)\n      if (!entry) {\n        entry = {\n          trace_id: span.trace_id,\n          service_name: span.service_name,\n          agent_name: span.agent_name,\n          span_count: 0,\n          has_errors: false,\n          start_time: span.start_time,\n          end_time: span.end_time,\n          duration_ms: 0,\n          raw_jsonl_bytes: 0,\n          agents: new Set(),\n          models: new Set(),\n          tools: new Set(),\n          spans: [],\n        }\n        byTrace.set(span.trace_id, entry)\n      } else {\n        // Pin the trace's service/agent to the first AGENT span we\n        // Prefer the first agent/service fields that appear in the trace.\n        if (!entry.service_name && span.service_name) entry.service_name = span.service_name\n        if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name\n      }\n\n      const indexEntry: SpanIndexEntry = {\n        span_id: span.span_id,\n        parent_span_id: span.parent_span_id,\n        name: span.name,\n        kind: span.kind,\n        start_time: span.start_time,\n        end_time: span.end_time,\n        duration_ms: span.duration_ms,\n        status: span.status,\n        status_message: span.status_message,\n        service_name: span.service_name,\n        agent_name: span.agent_name,\n        model_name: span.model_name,\n        tool_name: span.tool_name,\n        line_byte_offset: lineOffset,\n        line_byte_length: lineLength,\n      }\n      entry.spans.push(indexEntry)\n      entry.span_count += 1\n      entry.raw_jsonl_bytes += lineLength + 1 // +1 newline byte\n      if (span.status === 'ERROR') entry.has_errors = true\n      if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time\n      if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time\n      if (span.agent_name) entry.agents.add(span.agent_name)\n      if (span.model_name) entry.models.add(span.model_name)\n      if (span.tool_name) entry.tools.add(span.tool_name)\n    }\n\n    // Compute trace duration once, sort spans by start time for\n    // stable iteration.\n    let totalRawBytes = 0\n    for (const t of byTrace.values()) {\n      signal?.throwIfAborted()\n      totalRawBytes += t.raw_jsonl_bytes\n      t.spans.sort(\n        (a, b) =>\n          compareSpanTime(a.start_time, b.start_time) || a.line_byte_offset - b.line_byte_offset,\n      )\n      // Duration is 0 unless BOTH bounds parse — a missing/garbage timestamp\n      // yields 0, never a NaN (→ null in JSON) or a bogus epoch-from-zero span.\n      const startMs = spanEpochMillis(t.start_time)\n      const endMs = spanEpochMillis(t.end_time)\n      t.duration_ms = startMs === null || endMs === null ? 0 : Math.max(0, endMs - startMs)\n    }\n    const sortedTraceIds = [...byTrace.keys()].sort()\n    signal?.throwIfAborted()\n\n    return { byTrace, totalRawBytes, sortedTraceIds }\n  }\n\n  // ─── Filter pipeline ───────────────────────────────────────────────\n\n  private async matchedTraces(\n    idx: DatasetIndex,\n    filters: TraceAnalystFilters | undefined,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<TraceIndexEntry[]> {\n    context?.signal?.throwIfAborted()\n    const traces: TraceIndexEntry[] = []\n    for (let index = 0; index < idx.sortedTraceIds.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const trace = idx.byTrace.get(idx.sortedTraceIds[index]!)\n      if (trace) traces.push(trace)\n    }\n    if (!filters) return traces\n\n    const indexedFiltered: TraceIndexEntry[] = []\n    for (let index = 0; index < traces.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const t = traces[index]!\n      if (filters.has_errors !== undefined && t.has_errors !== filters.has_errors) continue\n      if (filters.service_names && filters.service_names.length > 0) {\n        if (!t.service_name || !filters.service_names.includes(t.service_name)) continue\n      }\n      if (filters.agent_names && filters.agent_names.length > 0) {\n        if (![...t.agents].some((agent) => filters.agent_names!.includes(agent))) continue\n      }\n      if (filters.model_names && filters.model_names.length > 0) {\n        if (![...t.models].some((m) => filters.model_names!.includes(m))) continue\n      }\n      if (filters.tool_names && filters.tool_names.length > 0) {\n        if (![...t.tools].some((tn) => filters.tool_names!.includes(tn))) continue\n      }\n      if (filters.start_time_after && t.start_time < filters.start_time_after) continue\n      if (filters.start_time_before && t.start_time > filters.start_time_before) continue\n      indexedFiltered.push(t)\n    }\n\n    if (!filters.regex_pattern) return indexedFiltered\n\n    // Opt-in raw-bytes scan — only over the already-narrowed set.\n    const re = compileSearchRegex(filters.regex_pattern)\n    const buf = await this.buffer(context)\n    const out: TraceIndexEntry[] = []\n    let traceIndex = 0\n    for (const t of indexedFiltered) {\n      await scanCheckpoint(context?.signal, traceIndex++)\n      let matched = false\n      let spanIndex = 0\n      for (const s of t.spans) {\n        await scanCheckpoint(context?.signal, spanIndex++)\n        const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n        // Buffer.toString allocates; tolerate it because regex_pattern\n        // is opt-in. Future optimisation: byte-level fast-path for\n        // ASCII-only patterns.\n        if (re.test(slice.toString('utf8'))) {\n          matched = true\n          break\n        }\n      }\n      if (matched) out.push(t)\n    }\n    return out\n  }\n\n  private toSummary(t: TraceIndexEntry): TraceAnalystTraceSummary {\n    return {\n      trace_id: t.trace_id,\n      service_name: t.service_name,\n      agent_name: t.agent_name,\n      span_count: t.span_count,\n      has_errors: t.has_errors,\n      start_time: t.start_time,\n      end_time: t.end_time,\n      duration_ms: t.duration_ms,\n      raw_jsonl_bytes: t.raw_jsonl_bytes,\n      models: [...t.models].sort(),\n      tools: [...t.tools].sort(),\n    }\n  }\n\n  // ─── Span projection (lazy attribute reads) ────────────────────────\n\n  private projectSpan(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    perAttrCap: number,\n    counter: TruncationCounter,\n  ): TraceAnalystSpan {\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    let raw: Record<string, unknown> = {}\n    try {\n      const parsed = JSON.parse(slice)\n      if (parsed && typeof parsed === 'object') raw = parsed as Record<string, unknown>\n    } catch {\n      // Should not happen — index pre-validated.\n    }\n    const attrs = extractOtlpAttributes(raw)\n    const projected: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(attrs)) {\n      if (typeof v === 'string') {\n        const trunc = truncateForBudget(v, perAttrCap)\n        if (trunc !== v) counter.value += 1\n        projected[k] = trunc\n      } else if (Array.isArray(v) || (v && typeof v === 'object')) {\n        const json = JSON.stringify(v)\n        const trunc = truncateForBudget(json, perAttrCap)\n        if (trunc !== json) {\n          counter.value += 1\n          projected[k] = trunc\n        } else {\n          projected[k] = v\n        }\n      } else {\n        projected[k] = v\n      }\n    }\n    return {\n      trace_id,\n      span_id: s.span_id,\n      parent_span_id: s.parent_span_id,\n      name: s.name,\n      kind: s.kind,\n      start_time: s.start_time,\n      end_time: s.end_time,\n      duration_ms: s.duration_ms,\n      status: s.status,\n      status_message: s.status_message,\n      service_name: s.service_name,\n      agent_name: s.agent_name,\n      model_name: s.model_name,\n      tool_name: s.tool_name,\n      attributes: projected,\n    }\n  }\n\n  private buildOversizedSummary(\n    t: TraceIndexEntry,\n    span_response_bytes_max: number,\n  ): ViewTraceOversized {\n    const counts = new Map<string, number>()\n    let errorCount = 0\n    for (const s of t.spans) {\n      counts.set(s.name, (counts.get(s.name) ?? 0) + 1)\n      if (s.status === 'ERROR') errorCount += 1\n    }\n    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20)\n    return {\n      span_count: t.span_count,\n      top_span_names: top,\n      span_response_bytes_max,\n      error_span_count: errorCount,\n    }\n  }\n\n  private async scanSpanForMatches(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    re: RE2JS,\n    textBudget: number,\n    recordCap: number,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<{ records: SpanMatchRecord[]; hasMore: boolean }> {\n    // We scan against the original raw JSONL slice for each span and\n    // record byte positions; the matched_text + context window is\n    // truncated to `textBudget` bytes per record so total tool output\n    // stays bounded even if hits cluster.\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    const records: SpanMatchRecord[] = []\n    let hasMore = false\n    let matchIndex = 0\n    for (const match of re.matchAll(slice)) {\n      await scanCheckpoint(context?.signal, matchIndex++)\n      if (records.length >= recordCap) {\n        hasMore = true\n        break\n      }\n      const offset = match.index ?? 0\n      const before = slice.slice(Math.max(0, offset - textBudget / 2), offset)\n      const after = slice.slice(\n        offset + match[0].length,\n        offset + match[0].length + Math.floor(textBudget / 2),\n      )\n      records.push({\n        trace_id,\n        span_id: s.span_id,\n        span_name: s.name,\n        span_kind: s.kind,\n        attribute_path: bestAttributePathForOffset(slice, offset) ?? 'span.raw',\n        matched_text: truncateForBudget(match[0], textBudget),\n        context_before: truncateForBudget(before, textBudget),\n        context_after: truncateForBudget(after, textBudget),\n        match_offset: offset,\n      })\n    }\n    return { records, hasMore }\n  }\n}\n\nexport class OtlpFileTraceStore extends BufferedTraceStore {\n  private readonly path: string\n  private readonly maxFileBytes: number\n\n  constructor(opts: OtlpFileTraceStoreOptions) {\n    super(opts)\n    this.path = opts.path\n    this.maxFileBytes = validateInteger(\n      opts.maxFileBytes ?? DEFAULT_MAX_TRACE_FILE_BYTES,\n      'maxFileBytes',\n      1,\n    )\n  }\n\n  /** Stat-then-read so an oversized file fails loud before allocating the\n   *  source buffer. Missing files remain distinct from malformed traces. */\n  protected async readBuffer(signal?: AbortSignal): Promise<Buffer> {\n    signal?.throwIfAborted()\n    let stats: Awaited<ReturnType<typeof stat>>\n    try {\n      stats = await stat(this.path)\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {\n        throw new TraceFileMissingError(this.path)\n      }\n      throw err\n    }\n    if (stats.size > this.maxFileBytes) {\n      throw new TraceFileTooLargeError(this.path, stats.size, this.maxFileBytes)\n    }\n    signal?.throwIfAborted()\n    return readFile(this.path, { signal })\n  }\n\n  protected sourcePath(): string {\n    return this.path\n  }\n}\n\nclass BufferTraceStore extends BufferedTraceStore {\n  constructor(\n    private readonly source: Buffer,\n    opts: BufferedTraceStoreOptions,\n  ) {\n    super(opts)\n  }\n\n  protected async readBuffer(signal?: AbortSignal): Promise<Buffer> {\n    signal?.throwIfAborted()\n    return this.source\n  }\n\n  protected sourcePath(): string {\n    return '<memory>'\n  }\n}\n\nclass SpanRecordTraceStore extends BufferTraceStore {\n  protected override projectRecord(raw: Record<string, unknown>): TraceAnalystSpan {\n    return traceSpanSchema.parse(raw)\n  }\n}\n\n/**\n * Snapshot canonical spans without reinterpreting their identifiers, kind, or duration.\n * Reads use the same indexed, bounded engine as the OTLP adapters. Raw byte counts\n * and searches refer to the canonical JSONL snapshot, not an external source artifact.\n */\nexport function spanRecordsToTraceAnalysisStore(\n  records: readonly TraceAnalystSpan[],\n  options: SpanRecordsToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  if (!records || records.length === 0) {\n    throw new CaptureIntegrityError('spanRecordsToTraceAnalysisStore: no span records supplied')\n  }\n  const seen = new Map<string, Set<string>>()\n  const lines = records.map((record, index) => {\n    try {\n      const span = traceSpanSchema.parse(record)\n      const traceSpans = seen.get(span.trace_id) ?? new Set<string>()\n      if (traceSpans.has(span.span_id)) {\n        throw new CaptureIntegrityError(\n          `spanRecordsToTraceAnalysisStore: duplicate span '${span.span_id}' in trace '${span.trace_id}'`,\n        )\n      }\n      traceSpans.add(span.span_id)\n      seen.set(span.trace_id, traceSpans)\n      return JSON.stringify(span)\n    } catch (cause) {\n      if (cause instanceof CaptureIntegrityError) throw cause\n      throw new CaptureIntegrityError(\n        `spanRecordsToTraceAnalysisStore: invalid span record at index ${index}`,\n        { cause },\n      )\n    }\n  })\n  return new SpanRecordTraceStore(Buffer.from(`${lines.join('\\n')}\\n`, 'utf8'), options)\n}\n\n/** Build the bounded trace store directly from OpenInference JSONL text. */\nexport function otlpTextToTraceAnalysisStore(\n  text: string,\n  opts: ToolSpansToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  if (!text.trim()) throw new CaptureIntegrityError('OTLP trace text must not be empty')\n  return new BufferTraceStore(Buffer.from(text, 'utf8'), opts)\n}\n\nexport function createOtlpBufferTraceStore(\n  source: Buffer,\n  options: ToolSpansToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  return new BufferTraceStore(source, options)\n}\n\nexport {\n  SpanNotFoundError,\n  TraceFileMalformedError,\n  TraceFileMissingError,\n  TraceFileTooLargeError,\n  TraceNotFoundError,\n} from './errors'\n\n// ─── OTLP shape readers ──────────────────────────────────────────────\n//\n// The per-line projection lives in `./otlp-span` so the index here and\n// `otlpToRunRecords` read the same vocabulary off the same parser.\n\n// Per-call truncation counter. Each public read that projects spans\n// owns one of these and threads it through projectSpan; a store-keyed\n// counter would let two concurrent reads on the same store report each\n// other's truncation counts.\ninterface TruncationCounter {\n  value: number\n}\n\n/** A `\"` at `idx` is a real JSON delimiter only when the run of `\\`\n *  immediately preceding it is even-length; an odd run means the quote\n *  is escaped (`\\\"`) and is part of a string value, not a boundary. */\nfunction isUnescapedQuote(slice: string, idx: number): boolean {\n  if (slice[idx] !== '\"') return false\n  let backslashes = 0\n  let b = idx - 1\n  while (b >= 0 && slice[b] === '\\\\') {\n    backslashes += 1\n    b -= 1\n  }\n  return backslashes % 2 === 0\n}\n\n/** Scan backwards from `from` (inclusive) for the nearest UNescaped `\"`.\n *  Returns its index, or -1 when none is found. */\nfunction prevUnescapedQuote(slice: string, from: number): number {\n  for (let i = from; i >= 0; i -= 1) {\n    if (slice[i] === '\"' && isUnescapedQuote(slice, i)) return i\n  }\n  return -1\n}\n\n/**\n * Best-effort: locate the JSON path for the substring at `offset` in\n * a single span's JSONL slice. The slice is '...,\"key\":\"value...\"' — we\n * walk back from `offset` to the value-opening quote, past the `:`, to\n * the key's closing then opening quote, skipping `\\\"`-escaped quotes that\n * live inside string values. Returns `null` when the offset doesn't fall\n * inside a recognisable string field.\n */\nfunction bestAttributePathForOffset(slice: string, offset: number): string | null {\n  // Value-opening quote: nearest unescaped '\"' at or before the offset.\n  const valueQuote = prevUnescapedQuote(slice, Math.min(offset, slice.length - 1))\n  if (valueQuote < 1) return null\n  // The ':' separating key and value sits before the value quote.\n  let j = valueQuote - 1\n  while (j >= 0 && slice[j] !== ':') j -= 1\n  if (j < 1) return null\n  // Key closing quote, then key opening quote — both unescaped.\n  const keyClose = prevUnescapedQuote(slice, j - 1)\n  if (keyClose < 1) return null\n  const keyOpen = prevUnescapedQuote(slice, keyClose - 1)\n  if (keyOpen < 0) return null\n  return slice.slice(keyOpen + 1, keyClose)\n}\n\n// ─── Error-cluster extraction ────────────────────────────────────────\n//\n// Deterministic failure-coverage population. The error-span loop in\n// getOverview already visits every ERROR span; bucketing them by a\n// normalized status_message signature turns \"N error spans\" into \"K\n// distinct failure modes\" — the checklist an analyst must close. No LLM.\n\nconst ERROR_CLUSTER_EXEMPLARS = 5\n\ninterface ErrorClusterAccumulator {\n  signature: string\n  sample: string\n  traceIds: Set<string>\n  spanIds: string[]\n  spanCount: number\n  spanNames: Map<string, number>\n  toolNames: Map<string, number>\n}\n\n/** Collapse volatile tokens so semantically identical failures share a key:\n *  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →\n *  <dur>, whitespace collapsed. Empty/absent messages fall back to the span\n *  name so a no-message error still forms a real cluster. */\nfunction normalizeErrorSignature(message: string | undefined, spanName: string): string {\n  const raw = (message ?? '').trim()\n  const base = raw.length > 0 ? raw : `(${spanName || 'error'} — no message)`\n  const norm = base\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<id>')\n    .replace(/\\b[0-9a-f]{12,}\\b/gi, '<id>')\n    .replace(/(?:\\/[\\w.\\-@]+){2,}/g, '<path>')\n    .replace(/\\b\\d+(?:\\.\\d+)?(ms|s|m|h|kb|mb|gb)?\\b/gi, (_m, u) => (u ? `#${u}` : '#'))\n    .replace(/\\s+/g, ' ')\n    .trim()\n  return norm\n}\n\nfunction bump(map: Map<string, number>, key: string | null): void {\n  if (!key) return\n  map.set(key, (map.get(key) ?? 0) + 1)\n}\n\nfunction topKey(map: Map<string, number>): string | null {\n  let best: string | null = null\n  let bestN = 0\n  for (const [k, n] of map)\n    if (n > bestN) {\n      best = k\n      bestN = n\n    }\n  return best\n}\n\nfunction accumulateErrorCluster(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  traceId: string,\n  span: SpanIndexEntry,\n): void {\n  const signature = normalizeErrorSignature(span.status_message, span.name)\n  let acc = clusters.get(signature)\n  if (!acc) {\n    acc = {\n      signature,\n      sample: span.status_message ?? span.name ?? '',\n      traceIds: new Set(),\n      spanIds: [],\n      spanCount: 0,\n      spanNames: new Map(),\n      toolNames: new Map(),\n    }\n    clusters.set(signature, acc)\n  }\n  acc.traceIds.add(traceId)\n  acc.spanCount += 1\n  if (acc.spanIds.length < ERROR_CLUSTER_EXEMPLARS && !acc.spanIds.includes(span.span_id)) {\n    acc.spanIds.push(span.span_id)\n  }\n  bump(acc.spanNames, span.name)\n  bump(acc.toolNames, span.tool_name)\n}\n\nfunction finalizeErrorClusters(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  errorTraceCount: number,\n): ErrorCluster[] {\n  const out = [...clusters.values()].map(\n    (acc): ErrorCluster => ({\n      signature: acc.signature,\n      status_message_sample: acc.sample,\n      span_name: topKey(acc.spanNames),\n      tool_name: topKey(acc.toolNames),\n      trace_count: acc.traceIds.size,\n      span_count: acc.spanCount,\n      prevalence: errorTraceCount > 0 ? acc.traceIds.size / errorTraceCount : 0,\n      exemplar_trace_ids: [...acc.traceIds].slice(0, ERROR_CLUSTER_EXEMPLARS),\n      exemplar_span_ids: acc.spanIds.slice(0, ERROR_CLUSTER_EXEMPLARS),\n    }),\n  )\n  out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count)\n  return out\n}\n"],"mappings":"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"}

package/dist/{store-tool-spans-fIE31bU8.d.ts → store-tool-spans-BYIarVrG.d.ts}

@@ -2,12 +2,12 @@ import { r as CaptureIntegrityError } from "./errors-DEE6u6ot.js";
 import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
 import { C as ToolSpan } from "./schema-2g7trUwH.js";
 import { d as RunTokenUsage } from "./run-record-DF-fuu31.js";
-import { E as SpanSourceReader, F as SearchTraceResult, K as ViewTraceResult, N as QueryTracesPage, O as TraceAnalysisStore, P as SearchSpanResult, W as ViewSpansResult, f as AnalystUsageReceipt, i as AnalystFinding, j as DatasetOverview, k as TraceAnalysisStoreContext, z as TraceAnalystFilters } from "./types-6VEehmEg.js";
+import { B as TraceAnalystSpan, E as SpanSourceReader, F as SearchTraceResult, K as ViewTraceResult, N as QueryTracesPage, O as TraceAnalysisStore, P as SearchSpanResult, W as ViewSpansResult, f as AnalystUsageReceipt, i as AnalystFinding, j as DatasetOverview, k as TraceAnalysisStoreContext, z as TraceAnalystFilters } from "./types-6VEehmEg.js";
 import { et as ProviderRedactor, rt as RawProviderSink } from "./types-DLxe96rp.js";
 import { i as SearchArtifactRef } from "./search-ledger-types-p2xKfiDJ.js";
 import { s as TraceStore } from "./store-C4avFjIi.js";
-import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-CaSqEVlL.js";
-import { t as TraceToolGroupName } from "./tool-groups-DP8b5kjF.js";
+import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-F_PvwesR.js";
+import { t as TraceToolGroupName } from "./tool-groups-B7_jUPHp.js";
 //#region src/trace/extract-usage.d.ts
 type ExtractedUsage = RunTokenUsage;
 type SseUsageMode = 'cumulative' | 'delta';
@@ -313,8 +313,10 @@ interface ToolSpansToTraceAnalysisStoreOptions {
   /** Override the per-match text budget. */
   perMatchTextBudget?: number;
 }
-type BufferedOtlpTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
-interface OtlpFileTraceStoreOptions extends BufferedOtlpTraceStoreOptions {
+/** Budgets and authorized source access shared by canonical span-record stores. */
+type SpanRecordsToTraceAnalysisStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
+type BufferedTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
+interface OtlpFileTraceStoreOptions extends BufferedTraceStoreOptions {
   /** Path to the OTLP-JSONL file. */
   path: string;
   /**
@@ -326,7 +328,7 @@ interface OtlpFileTraceStoreOptions extends BufferedOtlpTraceStoreOptions {
    */
   maxFileBytes?: number;
 }
-declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
+declare abstract class BufferedTraceStore implements TraceAnalysisStore {
   readonly readSpanSource?: SpanSourceReader;
   private readonly perAttributeViewBudget;
   private readonly perAttributeSpanBudget;
@@ -336,7 +338,7 @@ declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
   private indexTask?;
   private bufferValue?;
   private bufferTask?;
-  constructor(opts: BufferedOtlpTraceStoreOptions);
+  constructor(opts: BufferedTraceStoreOptions);
   hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean>;
   hasSpans(opts: {
     trace_id: string;
@@ -375,6 +377,7 @@ declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
   private buffer;
   protected abstract readBuffer(signal?: AbortSignal): Promise<Buffer>;
   protected abstract sourcePath(): string;
+  protected projectRecord(raw: Record<string, unknown>): TraceAnalystSpan | null;
   private index;
   private buildIndex;
   private matchedTraces;
@@ -383,7 +386,7 @@ declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
   private buildOversizedSummary;
   private scanSpanForMatches;
 }
-declare class OtlpFileTraceStore extends BufferedOtlpTraceStore {
+declare class OtlpFileTraceStore extends BufferedTraceStore {
   private readonly path;
   private readonly maxFileBytes;
   constructor(opts: OtlpFileTraceStoreOptions);
@@ -392,6 +395,12 @@ declare class OtlpFileTraceStore extends BufferedOtlpTraceStore {
   protected readBuffer(signal?: AbortSignal): Promise<Buffer>;
   protected sourcePath(): string;
 }
+/**
+ * Snapshot canonical spans without reinterpreting their identifiers, kind, or duration.
+ * Reads use the same indexed, bounded engine as the OTLP adapters. Raw byte counts
+ * and searches refer to the canonical JSONL snapshot, not an external source artifact.
+ */
+declare function spanRecordsToTraceAnalysisStore(records: readonly TraceAnalystSpan[], options?: SpanRecordsToTraceAnalysisStoreOptions): TraceAnalysisStore;
 /** Build the bounded trace store directly from OpenInference JSONL text. */
 declare function otlpTextToTraceAnalysisStore(text: string, opts?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
@@ -406,5 +415,5 @@ declare class ToolTraceMissingError extends CaptureIntegrityError {
  */
 declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
-export { AnalyzeTracesInput as A, CaptureFetchContext as B, inferDomainKeywords as C, planTraceInsightQuestions as D, isTraceInsightEvidence as E, OTEL_AGENT_EVAL_SCOPE as F, SseUsageMode as G, captureFetchToRawSink as H, OtlpExport as I, extractUsageFromSse as J, extractUsage as K, OtlpResourceSpans as L, AnalyzeTracesResult as M, analyzeTraces as N, scoreTraceInsightReadiness as O, OtlpFlatLine as P, OtlpSpan as R, domainEvidencePattern as S, isTraceInsightAttribution as T, ExtractUsageFromSseOptions as U, CaptureFetchOptions as V, ExtractedUsage as W, TraceInsightTask as _, ToolSpansToTraceAnalysisStoreOptions as a, defaultTraceInsightPanel as b, TraceInsightContext as c, TraceInsightPanelRole as d, TraceInsightPromptInput as f, TraceInsightSuite as g, TraceInsightReadiness as h, OtlpFileTraceStoreOptions as i, AnalyzeTracesOptions as j, tokenizeDomainWords as k, TraceInsightEvidence as l, TraceInsightQuestion as m, toolSpansToTraceAnalysisStore as n, otlpTextToTraceAnalysisStore as o, TraceInsightQualityGate as p, extractUsageFromResponse as q, OtlpFileTraceStore as r, TraceInsightAttribution as s, ToolTraceMissingError as t, TraceInsightFinding as u, buildTraceInsightContext as v, isTraceInsightArtifact as w, describeTraceInsightScope as x, buildTraceInsightPrompt as y, exportRunAsOtlp as z };
-//# sourceMappingURL=store-tool-spans-fIE31bU8.d.ts.map
+export { scoreTraceInsightReadiness as A, OtlpSpan as B, describeTraceInsightScope as C, isTraceInsightAttribution as D, isTraceInsightArtifact as E, analyzeTraces as F, ExtractUsageFromSseOptions as G, CaptureFetchContext as H, OtlpFlatLine as I, extractUsage as J, ExtractedUsage as K, OTEL_AGENT_EVAL_SCOPE as L, AnalyzeTracesInput as M, AnalyzeTracesOptions as N, isTraceInsightEvidence as O, AnalyzeTracesResult as P, OtlpExport as R, defaultTraceInsightPanel as S, inferDomainKeywords as T, CaptureFetchOptions as U, exportRunAsOtlp as V, captureFetchToRawSink as W, extractUsageFromSse as X, extractUsageFromResponse as Y, TraceInsightReadiness as _, SpanRecordsToTraceAnalysisStoreOptions as a, buildTraceInsightContext as b, spanRecordsToTraceAnalysisStore as c, TraceInsightEvidence as d, TraceInsightFinding as f, TraceInsightQuestion as g, TraceInsightQualityGate as h, OtlpFileTraceStoreOptions as i, tokenizeDomainWords as j, planTraceInsightQuestions as k, TraceInsightAttribution as l, TraceInsightPromptInput as m, toolSpansToTraceAnalysisStore as n, ToolSpansToTraceAnalysisStoreOptions as o, TraceInsightPanelRole as p, SseUsageMode as q, OtlpFileTraceStore as r, otlpTextToTraceAnalysisStore as s, ToolTraceMissingError as t, TraceInsightContext as u, TraceInsightSuite as v, domainEvidencePattern as w, buildTraceInsightPrompt as x, TraceInsightTask as y, OtlpResourceSpans as z };
+//# sourceMappingURL=store-tool-spans-BYIarVrG.d.ts.map

package/dist/{store-tool-spans-fIE31bU8.d.ts.map → store-tool-spans-BYIarVrG.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"store-tool-spans-fIE31bU8.d.ts","names":[],"sources":["../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otlp-flat.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts"],"mappings":"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"}
+{"version":3,"file":"store-tool-spans-BYIarVrG.d.ts","names":[],"sources":["../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otlp-flat.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts"],"mappings":"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"}

package/dist/{store-tool-spans-D5kOU0mr.js → store-tool-spans-DKoVbE-w.js}

@@ -1,11 +1,11 @@
 import { n as CaptureIntegrityError } from "./errors-Dngq5h35.js";
 import { t as LEDGER_HASH_PATTERN } from "./canonical-BsZVgBhW.js";
-import { r as runTraceAnalyst } from "./kind-factory-CdPPHtGZ.js";
+import { r as runTraceAnalyst } from "./kind-factory-Cn1lbsAd.js";
 import { OPENINFERENCE_SPAN_KIND, applyLlmSpanOtlpAttributes } from "./trace-attributes.js";
 import { r as extractUsageFromSse, t as extractUsage } from "./extract-usage-BrnzRJ6H.js";
 import { a as providerFromBaseUrl, i as defaultProviderRedactor } from "./raw-provider-sink-rB2DYxr6.js";
 import { n as traceSpanKindToOpenInferenceKind, t as applyToolSpanOtlpAttributes } from "./otlp-attributes-D9ptWaIJ.js";
-import { n as OtlpFileTraceStore, r as createOtlpBufferTraceStore } from "./store-otlp-yd9lDziN.js";
+import { n as OtlpFileTraceStore, r as createOtlpBufferTraceStore } from "./store-otlp-BA7G1Du-.js";
 import { randomUUID } from "node:crypto";
 import { deriveHexId, isW3CSpanId, isW3CTraceId } from "@tangle-network/agent-trace-contract";
 //#region src/trace/capture-fetch.ts
@@ -731,4 +731,4 @@ function toolSpanTimeIso(value, spanId, field) {
 //#endregion
 export { spanIdForWire as C, exportRunAsOtlp as S, captureFetchToRawSink as T, tokenizeDomainWords as _, spanStatusToOtlp as a, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as b, defaultTraceInsightPanel as c, inferDomainKeywords as d, isTraceInsightArtifact as f, scoreTraceInsightReadiness as g, planTraceInsightQuestions as h, epochMillisToIso as i, describeTraceInsightScope as l, isTraceInsightEvidence as m, toolSpansToTraceAnalysisStore as n, buildTraceInsightContext as o, isTraceInsightAttribution as p, createOtlpFlatLine as r, buildTraceInsightPrompt as s, ToolTraceMissingError as t, domainEvidencePattern as u, analyzeTraces as v, traceIdForWire as w, OTEL_AGENT_EVAL_SCOPE as x, TRACE_ANALYST_ACTOR_DESCRIPTION as y };
 
-//# sourceMappingURL=store-tool-spans-D5kOU0mr.js.map
+//# sourceMappingURL=store-tool-spans-DKoVbE-w.js.map