@tangle-network/agent-eval 0.93.0 → 0.95.0

package/dist/perf/ratchet.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Percentile ratchet over perf metric records.
+ *
+ * `summarizeRecords` folds flat records into per-scenario p50/p90 stats;
+ * `gatePerf` compares a current summary against a committed baseline and
+ * trips on regressions beyond tolerance. Percentiles use nearest-rank on
+ * sorted values. Null / non-numeric metric values are excluded from the
+ * stat (n reflects only real samples); a field with zero samples is
+ * omitted entirely — no fake zeros.
+ */
+export interface PerfStat {
+    p50: number;
+    p90: number;
+    n: number;
+}
+export interface PerfBaseline {
+    version: 1;
+    /** key → metric field → stat. */
+    scenarios: Record<string, Record<string, PerfStat>>;
+}
+export interface PerfRegression {
+    scenarioKey: string;
+    field: string;
+    baseline: PerfStat;
+    current: PerfStat;
+    /** percent over baseline p50 / p90, whichever tripped. */
+    overBy: {
+        p50Pct: number;
+        p90Pct: number;
+    };
+}
+export interface PerfGateResult {
+    succeeded: boolean;
+    regressions: PerfRegression[];
+    /** Negative overBy: strictly better than baseline on both percentiles. */
+    improvements: PerfRegression[];
+    /** In baseline but absent (or under-sampled, n < minSamples) in current. */
+    missingScenarios: string[];
+    /** In records but absent from baseline. */
+    newScenarios: string[];
+}
+export declare function summarizeRecords(records: ReadonlyArray<Record<string, unknown>>, keyOf: (record: Record<string, unknown>) => string | null, metricFields: ReadonlyArray<string>): PerfBaseline;
+export declare function gatePerf(current: PerfBaseline, baseline: PerfBaseline, options?: {
+    tolerancePct?: number;
+    minSamples?: number;
+}): PerfGateResult;
+//# sourceMappingURL=ratchet.d.ts.map

package/dist/perf/ratchet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ratchet.d.ts","sourceRoot":"","sources":["../../src/perf/ratchet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,CAAC,CAAA;IACV,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAA;CACpD;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,CAAA;IACjB,0DAA0D;IAC1D,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,0EAA0E;IAC1E,YAAY,EAAE,cAAc,EAAE,CAAA;IAC9B,4EAA4E;IAC5E,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,2CAA2C;IAC3C,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AASD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC/C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,IAAI,EACzD,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,GAClC,YAAY,CAoCd;AAUD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD,cAAc,CAiDhB"}

package/dist/pipelines/budget-breach.d.ts

@@ -0,0 +1,31 @@
+/**
+ * BudgetBreachView — aggregates breach events across the corpus.
+ *
+ * Answers: which dimensions get hit most often? Which scenarios are
+ * underbudgeted? Which variants trigger the most breaches?
+ */
+import type { BudgetSpec } from '../trace/schema';
+import type { TraceStore } from '../trace/store';
+export interface BudgetBreachFinding {
+    runId: string;
+    scenarioId: string;
+    variantId?: string;
+    dimension: keyof BudgetSpec;
+    limit: number;
+    consumed: number;
+    excessRatio: number;
+    timestamp: number;
+}
+export interface BudgetBreachReport {
+    findings: BudgetBreachFinding[];
+    byDimension: Record<string, number>;
+    byScenario: Record<string, number>;
+    byVariant: Record<string, number>;
+    totalRuns: number;
+    breachedRunRatio: number;
+}
+export declare function budgetBreachView(store: TraceStore, options?: {
+    scenarioId?: string;
+    variantId?: string;
+}): Promise<BudgetBreachReport>;
+//# sourceMappingURL=budget-breach.d.ts.map

package/dist/pipelines/budget-breach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-breach.d.ts","sourceRoot":"","sources":["../../src/pipelines/budget-breach.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,UAAU,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,mBAAmB,EAAE,CAAA;IAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,EAAE,MAAM,CAAA;CACzB;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,OAAO,CAAC,kBAAkB,CAAC,CAwC7B"}

package/dist/pipelines/budget-breach.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=budget-breach.test.d.ts.map

package/dist/pipelines/budget-breach.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-breach.test.d.ts","sourceRoot":"","sources":["../../src/pipelines/budget-breach.test.ts"],"names":[],"mappings":""}

package/dist/pipelines/failure-cluster.d.ts

@@ -0,0 +1,38 @@
+/**
+ * FailureClusterView — groups failed runs by (failureClass, triggerTool,
+ * argHash-prefix) so weekly reviews can prioritize the top-N clusters.
+ *
+ * Each cluster includes: N runs, scenarios affected, representative
+ * error message, a proposed mitigation hint (rule → action table).
+ */
+import { type FailureRule } from '../failure-taxonomy';
+import type { FailureClass } from '../trace/schema';
+import type { TraceStore } from '../trace/store';
+export interface FailureCluster {
+    failureClass: FailureClass;
+    /** Tool name when the trigger was a tool span, else undefined. */
+    toolName?: string;
+    /** First 16 chars of argHash — clusters similar args. */
+    argPrefix?: string;
+    /**
+     * Source dimension when the trigger was a judge span (e.g. `'format'`,
+     * `'safety'`, `'correctness'`). Lets cross-template aggregators
+     * group failures by the dimension that fired without overloading
+     * `argPrefix`. Optional — clusters without this field deserialize cleanly.
+     */
+    dimension?: string;
+    runCount: number;
+    scenarioIds: string[];
+    exampleError?: string;
+    exampleRunId: string;
+}
+export interface FailureClusterReport {
+    clusters: FailureCluster[];
+    totalFailures: number;
+    totalRuns: number;
+}
+export declare function failureClusterView(store: TraceStore, options?: {
+    rules?: FailureRule[];
+    minClusterSize?: number;
+}): Promise<FailureClusterReport>;
+//# sourceMappingURL=failure-cluster.d.ts.map

package/dist/pipelines/failure-cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-cluster.d.ts","sourceRoot":"","sources":["../../src/pipelines/failure-cluster.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAkC,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEtF,OAAO,KAAK,EAAE,YAAY,EAAQ,MAAM,iBAAiB,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,YAAY,CAAA;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/D,OAAO,CAAC,oBAAoB,CAAC,CAqE/B"}

package/dist/pipelines/failure-cluster.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=failure-cluster.test.d.ts.map

package/dist/pipelines/failure-cluster.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-cluster.test.d.ts","sourceRoot":"","sources":["../../src/pipelines/failure-cluster.test.ts"],"names":[],"mappings":""}

package/dist/pipelines/first-divergence.d.ts

@@ -0,0 +1,26 @@
+/**
+ * FirstDivergenceView — aligns two trajectories by step index, reports
+ * the first step where they differ.
+ *
+ * "Differ" is configurable — default is (kind, toolName if tool, model
+ * if llm). Use this view to attribute "why is variant B better?" to a
+ * specific step rather than an aggregate mean delta.
+ */
+import type { TraceStore } from '../trace/store';
+import { type TrajectoryStep } from '../trajectory';
+export interface DivergenceReport {
+    runA: string;
+    runB: string;
+    firstDivergenceIndex: number | null;
+    aStep?: TrajectoryStep;
+    bStep?: TrajectoryStep;
+    reason?: string;
+    /** Common prefix length (steps that matched). */
+    commonPrefixLen: number;
+}
+export interface DivergenceOptions {
+    /** Returns true if two steps are considered equal. Default: kind + tool/model match. */
+    stepEquals?: (a: TrajectoryStep, b: TrajectoryStep) => boolean;
+}
+export declare function firstDivergenceView(store: TraceStore, runA: string, runB: string, options?: DivergenceOptions): Promise<DivergenceReport>;
+//# sourceMappingURL=first-divergence.d.ts.map

package/dist/pipelines/first-divergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-divergence.d.ts","sourceRoot":"","sources":["../../src/pipelines/first-divergence.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAoC,KAAK,cAAc,EAAE,MAAM,eAAe,CAAA;AAErF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,wFAAwF;IACxF,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,KAAK,OAAO,CAAA;CAC/D;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAuC3B"}

package/dist/pipelines/first-divergence.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=first-divergence.test.d.ts.map

package/dist/pipelines/first-divergence.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"first-divergence.test.d.ts","sourceRoot":"","sources":["../../src/pipelines/first-divergence.test.ts"],"names":[],"mappings":""}

package/dist/pipelines/index.d.ts

@@ -1,173 +1,8 @@
-import { h as BudgetSpec, R as Run, T as ToolSpan } from '../schema-m0gsnbt3.js';
-import { T as TraceStore, R as RunFilter } from '../store-CKUAgsJz.js';
-export { a as FailureCluster, F as FailureClusterReport, f as failureClusterView } from '../failure-cluster-CL7IVgkJ.js';
-import { a as TrajectoryStep } from '../trajectory-GEdXJCL5.js';
-import { B as BaselineOptions, a as BaselineReport } from '../baseline-DE36-Np7.js';
-export { c as computeToolUseMetrics } from '../baseline-DE36-Np7.js';
-import { l as llmSpans } from '../query-CqTxMwDw.js';
-
-/**
- * BudgetBreachView — aggregates breach events across the corpus.
- *
- * Answers: which dimensions get hit most often? Which scenarios are
- * underbudgeted? Which variants trigger the most breaches?
- */
-
-interface BudgetBreachFinding {
-    runId: string;
-    scenarioId: string;
-    variantId?: string;
-    dimension: keyof BudgetSpec;
-    limit: number;
-    consumed: number;
-    excessRatio: number;
-    timestamp: number;
-}
-interface BudgetBreachReport {
-    findings: BudgetBreachFinding[];
-    byDimension: Record<string, number>;
-    byScenario: Record<string, number>;
-    byVariant: Record<string, number>;
-    totalRuns: number;
-    breachedRunRatio: number;
-}
-declare function budgetBreachView(store: TraceStore, options?: {
-    scenarioId?: string;
-    variantId?: string;
-}): Promise<BudgetBreachReport>;
-
-/**
- * FirstDivergenceView — aligns two trajectories by step index, reports
- * the first step where they differ.
- *
- * "Differ" is configurable — default is (kind, toolName if tool, model
- * if llm). Use this view to attribute "why is variant B better?" to a
- * specific step rather than an aggregate mean delta.
- */
-
-interface DivergenceReport {
-    runA: string;
-    runB: string;
-    firstDivergenceIndex: number | null;
-    aStep?: TrajectoryStep;
-    bStep?: TrajectoryStep;
-    reason?: string;
-    /** Common prefix length (steps that matched). */
-    commonPrefixLen: number;
-}
-interface DivergenceOptions {
-    /** Returns true if two steps are considered equal. Default: kind + tool/model match. */
-    stepEquals?: (a: TrajectoryStep, b: TrajectoryStep) => boolean;
-}
-declare function firstDivergenceView(store: TraceStore, runA: string, runB: string, options?: DivergenceOptions): Promise<DivergenceReport>;
-
-/**
- * JudgeAgreementView — pairwise agreement between judges across the
- * corpus, grouped by dimension.
- *
- * Output drives two workflows:
- *   - Judge robustness audit: "does Claude agree with GPT at κ ≥ 0.6?"
- *   - Calibration tracking: κ vs golden human labels over time (by
- *     providing a `humanGoldenJudgeId`).
- */
-
-interface JudgePair {
-    judgeA: string;
-    judgeB: string;
-    dimension: string;
-    /** Number of (targetSpanId, dimension) tuples both judges scored. */
-    commonItems: number;
-    pearson: number;
-    krippendorff: number;
-}
-interface JudgeAgreementReport {
-    pairs: JudgePair[];
-    dimensions: string[];
-    judgeIds: string[];
-}
-declare function judgeAgreementView(store: TraceStore): Promise<JudgeAgreementReport>;
-
-/**
- * RegressionView — compares a candidate slice to a baseline slice on a
- * named metric. Delegates the statistics (Welch's t-test, Cohen's d,
- * IQR stability) to `baseline.ts`.
- *
- * This is the entry point for CI regression gates: "given runs tagged
- * release=A and release=B, did any metric regress?"
- */
-
-interface RegressionSpec {
-    metric: string;
-    higherIsBetter: boolean;
-    /** Extract a scalar from a run. Default extractors handle common metrics. */
-    extract?: (run: Run, store: TraceStore) => Promise<number | null>;
-}
-interface RegressionOptions extends BaselineOptions {
-    baseline: RunFilter;
-    candidate: RunFilter;
-}
-declare function regressionView(store: TraceStore, metrics: RegressionSpec[], options: RegressionOptions): Promise<BaselineReport>;
-
-/**
- * StuckLoopView — detects when an agent calls the same tool with the
- * same (or structurally similar) arguments ≥ N times in a short window.
- *
- * Rationale: agents that loop are the number-one production failure
- * mode on long-horizon flows. The view returns (runId, toolName,
- * argHash, occurrences, windowMs) for each detected loop plus a
- * fraction of runs affected.
- */
-
-interface StuckLoopFinding {
-    runId: string;
-    toolName: string;
-    argHash: string;
-    occurrences: number;
-    spanIds: string[];
-    /** Milliseconds between first and last call in the loop. */
-    windowMs: number;
-}
-interface StuckLoopReport {
-    findings: StuckLoopFinding[];
-    affectedRunRatio: number;
-    totalRuns: number;
-}
-interface StuckLoopOptions {
-    /** Minimum call count to flag a loop (default 3). */
-    minOccurrences?: number;
-    /** Filter to a specific runId; omit to scan the entire corpus. */
-    runId?: string;
-}
-declare function stuckLoopView(store: TraceStore, options?: StuckLoopOptions): Promise<StuckLoopReport>;
-
-/**
- * ToolWasteView — fraction of tool calls whose results weren't used
- * downstream. Without a "used" signal we fall back to structural
- * proxies: error calls, duplicate calls, and tool calls followed by
- * zero subsequent LLM spans are all considered waste.
- *
- * Consumers can pass a `usageOracle` that inspects a tool span and
- * returns true iff the tool's result appears in a later LLM message,
- * artifact, or state mutation — that's the canonical definition; the
- * default heuristic is a reasonable fallback.
- */
-
-interface ToolWasteFinding {
-    runId: string;
-    wastedCalls: number;
-    totalCalls: number;
-    wasteRate: number;
-}
-interface ToolWasteReport {
-    byRun: ToolWasteFinding[];
-    overallWasteRate: number;
-}
-interface ToolWasteOptions {
-    runId?: string;
-    usageOracle?: (tool: ToolSpan, later: {
-        llm: Awaited<ReturnType<typeof llmSpans>>;
-    }) => boolean;
-}
-declare function toolWasteView(store: TraceStore, options?: ToolWasteOptions): Promise<ToolWasteReport>;
-
-export { type BudgetBreachFinding, type BudgetBreachReport, type DivergenceOptions, type DivergenceReport, type JudgeAgreementReport, type JudgePair, type RegressionOptions, type RegressionSpec, type StuckLoopFinding, type StuckLoopOptions, type StuckLoopReport, type ToolWasteFinding, type ToolWasteOptions, type ToolWasteReport, budgetBreachView, firstDivergenceView, judgeAgreementView, regressionView, stuckLoopView, toolWasteView };
+export * from './budget-breach';
+export * from './failure-cluster';
+export * from './first-divergence';
+export * from './judge-agreement';
+export * from './regression';
+export * from './stuck-loop';
+export * from './tool-waste';
+//# sourceMappingURL=index.d.ts.map

package/dist/pipelines/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipelines/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA"}

package/dist/pipelines/index.js

@@ -3,20 +3,20 @@ import {
   classifyFailure,
   compareToBaseline,
   computeToolUseMetrics
-} from "../chunk-L3JOU6XM.js";
+} from "../chunk-NACM5RS7.js";
 import {
   buildTrajectory
 } from "../chunk-RZTMDUO7.js";
 import {
   interRaterReliability
-} from "../chunk-LMZQ2Z4U.js";
+} from "../chunk-56GC6VYO.js";
 import {
   aggregateLlm,
   argHash,
   llmSpans,
   runFailureClass,
   toolSpans
-} from "../chunk-47X6LRCE.js";
+} from "../chunk-UFSG7ACU.js";
 import "../chunk-5BKGXME7.js";
 import "../chunk-3BFEG2F6.js";
 import "../chunk-PZ5AY32C.js";
@@ -149,13 +149,15 @@ async function firstDivergenceView(store, runA, runB, options = {}) {
     return { runA, runB, firstDivergenceIndex: null, commonPrefixLen: minLen };
   }
   const longer = a.steps.length > b.steps.length ? a : b;
+  const extra = longer.steps.length - minLen;
+  const reason = minLen === 0 ? `one trajectory is empty; the other has ${extra} step(s) starting at index 0` : `one trajectory has ${extra} more step(s) after index ${minLen - 1}`;
   return {
     runA,
     runB,
     firstDivergenceIndex: minLen,
     aStep: a.steps[minLen],
     bStep: b.steps[minLen],
-    reason: `one trajectory has ${longer.steps.length - minLen} more step(s) after index ${minLen - 1}`,
+    reason,
     commonPrefixLen: minLen
   };
 }
@@ -320,19 +322,19 @@ async function stuckLoopView(store, options = {}) {
     const byKey = /* @__PURE__ */ new Map();
     for (const t of tools) {
       const h = argHash(t.args);
-      const key = `${t.toolName}|${h}`;
-      const bucket = byKey.get(key) ?? { spans: [], argHash: h };
+      const key = `${t.toolName}\0${h}`;
+      const bucket = byKey.get(key) ?? { spans: [], argHash: h, toolName: t.toolName };
       bucket.spans.push(t);
       byKey.set(key, bucket);
     }
-    for (const [key, { spans, argHash: h }] of byKey) {
+    for (const { spans, argHash: h, toolName } of byKey.values()) {
       if (spans.length < minOccurrences) continue;
       const sorted = [...spans].sort((a, b) => a.startedAt - b.startedAt);
       const first = sorted[0].startedAt;
       const last = sorted[sorted.length - 1].startedAt;
       findings.push({
         runId,
-        toolName: key.split("|")[0],
+        toolName,
         argHash: h,
         occurrences: sorted.length,
         spanIds: sorted.map((s) => s.spanId),
@@ -361,22 +363,23 @@ async function toolWasteView(store, options = {}) {
       continue;
     }
     const llms = await llmSpans(store, runId);
+    const sortedLlm = [...llms].sort((a, b) => a.startedAt - b.startedAt);
+    const startTimes = sortedLlm.map((l) => l.startedAt);
+    const suffixText = buildSuffixText(sortedLlm);
     let wasted = 0;
     for (const t of tools) {
       if (t.status === "error") {
         wasted++;
         continue;
       }
-      const laterLlm = llms.filter((l) => l.startedAt > t.startedAt);
+      const cutoff = upperBound(startTimes, t.startedAt);
       if (options.usageOracle) {
-        if (!options.usageOracle(t, { llm: laterLlm })) wasted++;
+        if (!options.usageOracle(t, { llm: sortedLlm.slice(cutoff) })) wasted++;
       } else {
         const resultStr = stringify(t.result);
-        const used = laterLlm.some(
-          (l) => l.messages.some(
-            (m) => typeof m.content === "string" && resultStr && m.content.includes(resultStr.slice(0, 120))
-          )
-        );
+        if (resultStr === "") continue;
+        const haystack = suffixText[cutoff] ?? "";
+        const used = haystack.includes(resultStr.slice(0, 120));
         if (!used) wasted++;
       }
     }
@@ -387,6 +390,28 @@ async function toolWasteView(store, options = {}) {
   }
   return { byRun, overallWasteRate: totalCalls > 0 ? totalWasted / totalCalls : 0 };
 }
+function buildSuffixText(spans) {
+  const result = new Array(spans.length + 1);
+  result[spans.length] = "";
+  for (let i = spans.length - 1; i >= 0; i--) {
+    const own = spans[i].messages.map(
+      (m) => typeof m.content === "string" ? m.content : ""
+    ).join("\n");
+    result[i] = `${own}
+${result[i + 1]}`;
+  }
+  return result;
+}
+function upperBound(sorted, target) {
+  let lo = 0;
+  let hi = sorted.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (sorted[mid] <= target) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
 function stringify(v) {
   if (v === null || v === void 0) return "";
   if (typeof v === "string") return v;