@tangle-network/agent-eval 0.187.2 → 0.188.0

package/dist/{matrix-CPKsRY8Y.d.ts → matrix-BvA1WUpj.d.ts}

@@ -1,5 +1,5 @@
 import { p as CostProvenance } from "./cost-ledger-DbQdN3nO.js";
-import { w as JudgeScore } from "./types-BTRcIqFr.js";
+import { w as JudgeScore } from "./types-B1vDZ694.js";
 import { o as MatrixResult } from "./index-DNgf5gyG.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/types.d.ts
@@ -398,4 +398,4 @@ interface RunMultishotMatrixResult {
 declare function runMultishotMatrix<TPersona extends MultishotPersona>(opts: RunMultishotMatrixOptions<TPersona>): Promise<RunMultishotMatrixResult>;
 //#endregion
 export { MultishotToolExecutor as A, MultishotFatalToolError as C, MultishotShape as D, MultishotResult as E, assertMultishotShotResult as F, MultishotTransportRequest as M, MultishotTransportResponse as N, MultishotShotResultError as O, MultishotTransportToolCall as P, MultishotDriverEmptyError as S, MultishotPersona as T, JudgeRunResult as _, MultishotCellOutput as a, runJudge as b, RunMultishotMatrixResult as c, MultishotShot as d, RunMultishotOptions as f, JudgeDimension as g, JudgeConfig as h, ConversationJudgeInput as i, MultishotTransport as j, MultishotToolDefinition as k, computeCellComposite as l, DEFAULT_JUDGE_MODEL as m, CellCompositeInput as n, MultishotJudges as o, runMultishot as p, CellCompositeScore as r, RunMultishotMatrixOptions as s, ArtifactJudgeInput as t, runMultishotMatrix as u, renderDimensions as v, MultishotMessage as w, MultishotArtifact as x, renderJsonFooter as y };
-//# sourceMappingURL=matrix-CPKsRY8Y.d.ts.map
+//# sourceMappingURL=matrix-BvA1WUpj.d.ts.map

package/dist/{matrix-CPKsRY8Y.d.ts.map → matrix-BvA1WUpj.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"matrix-CPKsRY8Y.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}
+{"version":3,"file":"matrix-BvA1WUpj.d.ts","names":[],"sources":["../src/multishot/types.ts","../src/multishot/judges.ts","../src/multishot/multishot.ts","../src/multishot/matrix.ts"],"mappings":";;;;;UAIiB;EACf;EACA;EACA;EACA,YAAY;IAAQ;IAAY;IAAc,MAAM;;;UAGrC;EACf;EACA;EACA;IAAc;IAAc,MAAM;;EAClC;;UAGe;EACf,YAAY;EACZ,WAAW;EACX;EACA;;;EAGA;;;;;;;;EAQA,iBAAiB;;UAGF;EACf;EACA;IACE;IACA;IACA,YAAY;;;;;;UAOC;EACf;EACA,UAAU,MAAM;EAChB,QAAQ;EACR;EACA;EACA,SAAS;;UAGM;EACf;EACA;EACA;IAAY;IAAc;;;UAGX;EACf;IAAW;IAAyB,aAAa;;EACjD;IAAU;IAAwB;;;;EAGlC;;;;EAIA;;;;;;;;KASU,sBACV,KAAK,8BACF,QAAQ;KAED,yBACV,MAAM,yBACN;;EAEE,WAAW;EACX,SAAS;MAER;EAAU;EAAiB;;UAEf;;EAEf;;GAEC;;;;;;;;UASc,eAAe,iBAAiB;;EAE/C,eAAe,SAAS;;;EAGxB,2BAA2B,SAAS;;cAGzB,kCAAkC;WACjB;EAA5B,YAA4B;;cAMjB,gCAAgC;EAC3C,YAAY;;cAMD,iCAAiC;EAC5C,YAAY;;;;;;;;;;;;;;;;;;;iBAyBE,0BAA0B,yBAAyB,SAAS;;;cCvI/D;UAEI;;EAEf;;EAEA;;UAGe,YAAY;;EAE3B;;;EAGA,WAAW;;EAEX;;EAEA,YAAY;;EAEZ;;;EAGA,cAAc,OAAO;;EAErB;;UAGe;;EAEf,OAAO;;EAEP,MAAM;;iBAGc,SAAS,QAC7B,OAAO,YAAY,SACnB,OAAO,SACN,QAAQ;;;iBAsIK,iBAAiB,eAAe;;iBAKhC,iBAAiB,eAAe;;;UCxK/B,oBAAoB,iBAAiB;EACpD,SAAS;EACT,SAAS;;;EAGT,QAAQ,eAAe;;EAEvB,QAAQ;;EAER,gBAAgB,eAAe;;;;EAI/B,mBAAmB;EACnB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA,gBAAgB;;;;EAIhB,iBAAiB;;;EAGjB,gBAAgB;EAChB,SAAS;;;;;;;;;;;KAYC,cAAc,iBAAiB,qBACzC,MAAM,oBAAoB,cACvB,QAAQ;;;;;;;;;;;;;;;;;iBA2BS,aAAa,iBAAiB,kBAClD,MAAM,oBAAoB,YACzB,QAAQ;;;UClFM,uBAAuB,iBAAiB;EACvD,YAAY;EACZ,SAAS;;UAGM,mBAAmB,iBAAiB;EACnD,UAAU;EACV,SAAS;;UAGM,gBAAgB,iBAAiB;;EAEhD,cAAc,YAAY,uBAAuB;;EAEjD,aAAa,YAAY,mBAAmB;;EAE5C,iBAAiB,YAAY,mBAAmB;;EAEhD;;EAEA;;UAGe;EACf;EACA,cAAc;EACd;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;EAEF;IACE,aAAa,MAAM;MAAe;MAAc;;IAChD;;;UAIa,0BAA0B,iBAAiB;;EAE1D,UAAU;IAAQ;IAAY,OAAO;;;EAErC,UAAU;;;EAGV,QAAQ,eAAe;;EAEvB,QAAQ,gBAAgB;;EAExB,QAAQ;;EAER,gBAAgB,eAAe;;EAE/B,mBAAmB;;EAEnB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,gBAAgB;;EAEhB,iBAAiB;;;EAGjB,gBAAgB;;;;;;;;;;;;;;;EAehB,UAAU,cAAc;;;;;UAMT;EACf;EACA;EACA;;UAoBe;EACf,cAAc;;EAEd,cAAc,cAAc;;EAE5B,iBAAiB,cAAc;;;;;;;iBAQjB,qBAAqB,OAAO;EAC1C;EACA;EACA;EACA;;UAuBe;EACf,QAAQ,aAAa;;iBAGD,mBAAmB,iBAAiB,kBACxD,MAAM,0BAA0B,YAC/B,QAAQ"}

package/dist/meta-eval/index.d.ts

@@ -1,11 +1,11 @@
-import { f as Run } from "../schema-CR5cpjQ3.js";
+import { f as Run } from "../schema-2g7trUwH.js";
 import { a as ContinuousCalibrationResult, c as SelfPreferenceResult, d as calibrateJudgeContinuous, f as continuousAgreement, h as verbosityBias, i as ContinuousAgreementOptions, l as VerbosityBiasResult, m as selfPreference, n as CandidateScore, o as GoldenItem, p as positionalBias, r as ContinuousAgreement, s as PositionalBiasResult, t as CalibrationResult, u as calibrateJudge } from "../judge-calibration-DFtEMlde.js";
-import { n as SeriesConvergenceResult, o as CorpusAgreementReport, t as SeriesConvergenceOptions } from "../series-convergence-BnMs_uAr.js";
+import { n as SeriesConvergenceResult, o as CorpusAgreementReport, t as SeriesConvergenceOptions } from "../series-convergence-DY7ha0kx.js";
 import { r as LedgerHash } from "../canonical-CFpojCN5.js";
-import { s as TraceStore } from "../store-BErPvYBr.js";
+import { s as TraceStore } from "../store-C4avFjIi.js";
 import { a as OutcomeFilter, i as InMemoryOutcomeStore, n as FileSystemOutcomeStore, o as OutcomeStore, r as FileSystemOutcomeStoreOptions, s as OutcomeStoreError, t as DeploymentOutcome } from "../outcome-store-CNt4iZ67.js";
 import { a as ComputedInterval } from "../ast-hI-vjW6J.js";
-import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-CTU8y8Cv.js";
+import { a as RubricPredictiveValidityReport, c as CorrelationInterval, i as RubricPredictiveValidityInput, l as OutcomeReduction, n as RubricOutcomeExclusion, o as RubricRanking, r as RubricOutcomePair, s as rubricPredictiveValidity, t as OutcomeMetricSpec } from "../rubric-predictive-validity-B14yBAmM.js";
 import { z } from "zod";
 //#region src/meta-eval/correlation-study.d.ts
 interface EvalMetricSpec {

package/dist/{mint-BI14xehJ.d.ts → mint-CJFSYBIU.d.ts}

@@ -1,5 +1,5 @@
-import { a as RunRecord } from "./run-record-D9wS35fK.js";
-import { s as TraceStore } from "./store-BErPvYBr.js";
+import { a as RunRecord } from "./run-record-xEULpgML.js";
+import { s as TraceStore } from "./store-C4avFjIi.js";
 import { S as ToolDef, a as MintedRolloutLine, b as RolloutStep, m as RolloutLine, t as ChatMessage, v as RolloutRole, y as RolloutSplit } from "./schema-BzWDXhOR.js";
 //#region src/rollout/exporters.d.ts
 /**
@@ -282,4 +282,4 @@ declare function unmintableReasons(record: RunRecord): string[];
 declare function mintRolloutRows(records: RunRecord[], store: TraceStore, options?: MintRolloutOptions): Promise<MintRolloutResult>;
 //#endregion
 export { toRewardRows as C, toVerifiersRolloutOutput as D, toSftRows as E, toVerifiersRolloutOutputs as O, toJsonl as S, toRftItems as T, SftExportOptions as _, unmintableReasons as a, VerifiersRolloutOutput as b, isRealnessGated as c, scoreOrigin as d, trainingReward as f, RftItem as g, RewardRow as h, mintRolloutRows as i, observedScore as l, RealnessLabels as m, MintRolloutResult as n, ScoreOrigin as o, trainingScore as p, RolloutScrubber as r, ScorePreference as s, MintRolloutOptions as t, observedSplitScore as u, SftRow as v, toRftItem as w, VerifiersTokenUsage as x, TrainingExportOptions as y };
-//# sourceMappingURL=mint-BI14xehJ.d.ts.map
+//# sourceMappingURL=mint-CJFSYBIU.d.ts.map

package/dist/{mint-BI14xehJ.d.ts.map → mint-CJFSYBIU.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"mint-BI14xehJ.d.ts","names":[],"sources":["../src/rollout/exporters.ts","../src/rollout/reward.ts","../src/rollout/mint.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAiDiB;;EAEf;;;;;;EAMA;;UAiBe;;EAEf;;EAEA;;;;;;EAMA,cAAc;;;;;;;;;;;;;;;;;;;;;;KAuBJ;UAEK,kCAAkC;;EAEjD,aAAa;;KAGH,mBAAmB;UAEd;EACf,UAAU;EACV;IACE;IACA;IACA;IACA;IACA;MACE;;;;;;;;;;;;;;;;;;iBAmBU,UAAU,OAAO,qBAAqB,UAAS,mBAAwB;UAyBtE;;EAEf;EACA,OAAO;EACP;EACA;IACE;IACA;IACA;IACA;IACA,OAAO;MAUL;;;;;iBAMU,aACd,OAAO,qBACP,UAAS,wBACR;UAgCc;EACf;EACA;EACA;EACA;EACA;;UAGe;;EAEf,QAAQ;;EAER,YAAY;EACZ;EACA,SAAS;EACT,WAAW;EACX,aAAa;EACb;IACE,MAAM;IACN,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,MAAM;MACJ;;iBASU,yBAAyB,MAAM,oBAAoB;iBA+BnD,0BACd,OAAO,qBACP,UAAS,4BACR;UAoBc;;EAEf,UAAU;;EAEV;IACE;IACA;IACA;IACA;IACA;IACA,OAAO;IACP;MACE;;iBAGU,UAAU,MAAM,oBAAoB;;iBAmBpC,WACd,OAAO,qBACP,UAAS,4BACR;iBAkBa,QAAQ,MAAM;;;;;;;;KC3VlB;;KAGP,SAAS,KAAK;;iBAGH,gBAAgB,QAAQ;;;;;;;;;;;;;;iBAiBxB,mBAAmB,QAAQ,QAAQ,OAAO;;;;;;;;;;;;;;;;iBAmB1C,cACd,QAAQ,QACR,SAAQ;;KAOE;;;;;;;iBAQI,YAAY,QAAQ,QAAQ,SAAQ,kBAA8B;;;;;;;;;iBAelE,cACd,QAAQ,QACR,SAAQ;;;;;;;;;;;;iBAiBM,eAAe,QAAQ;EAAW;EAAuB;;;;;KCvE7D,mBAAmB;UAEd;EACf,QAAQ;;;;;;;EAOR,cACE,2BACY,4BAA4B,iBAAiB;;EAE3D;;EAEA,OAAO;;EAEP;;EAEA,YAAY;;UAGG;EACf,MAAM;;EAEN;;;;;;;;;;;;;;iBA4Pc,kBAAkB,QAAQ;;;;;;;iBA+JpB,gBACpB,SAAS,aACT,OAAO,YACP,UAAS,qBACR,QAAQ"}
+{"version":3,"file":"mint-CJFSYBIU.d.ts","names":[],"sources":["../src/rollout/exporters.ts","../src/rollout/reward.ts","../src/rollout/mint.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAiDiB;;EAEf;;;;;;EAMA;;UAiBe;;EAEf;;EAEA;;;;;;EAMA,cAAc;;;;;;;;;;;;;;;;;;;;;;KAuBJ;UAEK,kCAAkC;;EAEjD,aAAa;;KAGH,mBAAmB;UAEd;EACf,UAAU;EACV;IACE;IACA;IACA;IACA;IACA;MACE;;;;;;;;;;;;;;;;;;iBAmBU,UAAU,OAAO,qBAAqB,UAAS,mBAAwB;UAyBtE;;EAEf;EACA,OAAO;EACP;EACA;IACE;IACA;IACA;IACA;IACA,OAAO;MAUL;;;;;iBAMU,aACd,OAAO,qBACP,UAAS,wBACR;UAgCc;EACf;EACA;EACA;EACA;EACA;;UAGe;;EAEf,QAAQ;;EAER,YAAY;EACZ;EACA,SAAS;EACT,WAAW;EACX,aAAa;EACb;IACE,MAAM;IACN,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,MAAM;MACJ;;iBASU,yBAAyB,MAAM,oBAAoB;iBA+BnD,0BACd,OAAO,qBACP,UAAS,4BACR;UAoBc;;EAEf,UAAU;;EAEV;IACE;IACA;IACA;IACA;IACA;IACA,OAAO;IACP;MACE;;iBAGU,UAAU,MAAM,oBAAoB;;iBAmBpC,WACd,OAAO,qBACP,UAAS,4BACR;iBAkBa,QAAQ,MAAM;;;;;;;;KC3VlB;;KAGP,SAAS,KAAK;;iBAGH,gBAAgB,QAAQ;;;;;;;;;;;;;;iBAiBxB,mBAAmB,QAAQ,QAAQ,OAAO;;;;;;;;;;;;;;;;iBAmB1C,cACd,QAAQ,QACR,SAAQ;;KAOE;;;;;;;iBAQI,YAAY,QAAQ,QAAQ,SAAQ,kBAA8B;;;;;;;;;iBAelE,cACd,QAAQ,QACR,SAAQ;;;;;;;;;;;;iBAiBM,eAAe,QAAQ;EAAW;EAAuB;;;;;KCvE7D,mBAAmB;UAEd;EACf,QAAQ;;;;;;;EAOR,cACE,2BACY,4BAA4B,iBAAiB;;EAE3D;;EAEA,OAAO;;EAEP;;EAEA,YAAY;;UAGG;EACf,MAAM;;EAEN;;;;;;;;;;;;;;iBA4Pc,kBAAkB,QAAQ;;;;;;;iBA+JpB,gBACpB,SAAS,aACT,OAAO,YACP,UAAS,qBACR,QAAQ"}

package/dist/multishot/golden/index.d.ts

@@ -1,4 +1,4 @@
-import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-CPKsRY8Y.js";
+import { E as MultishotResult, M as MultishotTransportRequest, T as MultishotPersona, c as RunMultishotMatrixResult, f as RunMultishotOptions, k as MultishotToolDefinition, s as RunMultishotMatrixOptions } from "../../matrix-BvA1WUpj.js";
 //#region src/multishot/golden/compare.d.ts
 interface CompareOptions {
   /** Stop after this many mismatches. A structural divergence high in the

package/dist/multishot/index.d.ts

@@ -1,5 +1,5 @@
-import { w as JudgeScore } from "../types-BTRcIqFr.js";
-import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-CPKsRY8Y.js";
+import { w as JudgeScore } from "../types-B1vDZ694.js";
+import { A as MultishotToolExecutor, C as MultishotFatalToolError, D as MultishotShape, E as MultishotResult, F as assertMultishotShotResult, M as MultishotTransportRequest, N as MultishotTransportResponse, O as MultishotShotResultError, P as MultishotTransportToolCall, S as MultishotDriverEmptyError, T as MultishotPersona, _ as JudgeRunResult, a as MultishotCellOutput, b as runJudge, c as RunMultishotMatrixResult, d as MultishotShot, f as RunMultishotOptions, g as JudgeDimension, h as JudgeConfig, i as ConversationJudgeInput, j as MultishotTransport, k as MultishotToolDefinition, l as computeCellComposite, m as DEFAULT_JUDGE_MODEL, n as CellCompositeInput, o as MultishotJudges, p as runMultishot, r as CellCompositeScore, s as RunMultishotMatrixOptions, t as ArtifactJudgeInput, u as runMultishotMatrix, v as renderDimensions, w as MultishotMessage, x as MultishotArtifact, y as renderJsonFooter } from "../matrix-BvA1WUpj.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 //#region src/multishot/cost.d.ts
 /**

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.187.2",
+    "version": "0.188.0",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.1.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/pipelines/index.d.ts

@@ -1,24 +1,79 @@
-import { f as Run } from "../schema-CR5cpjQ3.js";
-import { a as RunFilter, s as TraceStore } from "../store-BErPvYBr.js";
-import { n as FailureClusterReport, r as failureClusterView, t as FailureCluster } from "../failure-cluster-OldNRoAt.js";
-import { n as TrajectoryStep } from "../trajectory-D7qrNvaN.js";
-import { c as computeToolUseMetrics, d as judgeAgreementView, f as BudgetBreachFinding, g as BaselineReport, h as BaselineOptions, i as toolWasteView, l as JudgeAgreementReport, m as budgetBreachView, n as ToolWasteOptions, p as BudgetBreachReport, r as ToolWasteReport, t as ToolWasteFinding, u as JudgePair } from "../tool-waste-D23I0zWm.js";
+import { f as Run } from "../schema-2g7trUwH.js";
+import { a as RunFilter, s as TraceStore } from "../store-C4avFjIi.js";
+import { n as FailureClusterReport, r as failureClusterView, t as FailureCluster } from "../failure-cluster-CbgEDcFJ.js";
+import { t as DiagnosisSpan } from "../spans-W0o8pbEg.js";
+import { n as TrajectoryStep } from "../trajectory-Y1fmdlw7.js";
+import { c as computeToolUseMetrics, d as judgeAgreementView, f as BudgetBreachFinding, g as BaselineReport, h as BaselineOptions, i as toolWasteView, l as JudgeAgreementReport, m as budgetBreachView, n as ToolWasteOptions, p as BudgetBreachReport, r as ToolWasteReport, t as ToolWasteFinding, u as JudgePair } from "../tool-waste-CP5DO383.js";
 //#region src/pipelines/first-divergence.d.ts
+/** One step of a run, as the diff reads it. */
+interface DiffStep {
+  /** The step's id within its run. */
+  id: string;
+  name: string;
+  kind: string;
+  /** Fields compared once two steps pair, such as status, tool or model. */
+  fields: Readonly<Record<string, string | number | boolean | null>>;
+}
+type StepPairing = 'id' | 'position' | 'name';
+interface FieldDifference {
+  field: string;
+  a: string | number | boolean | null;
+  b: string | number | boolean | null;
+}
+interface StepPair {
+  /** Index in run A. */
+  a: number;
+  /** Index in run B. */
+  b: number;
+  pairedBy: StepPairing;
+  /** Empty when the paired steps agree on name, kind and every field. */
+  differences: FieldDifference[];
+}
+type StepDivergenceKind = 'changed' | 'replaced' | 'only-in-a' | 'only-in-b' | 'reordered';
+interface StepDivergence {
+  /** The first index at which the runs stop agreeing; equals `commonPrefixLen`. */
+  index: number;
+  kind: StepDivergenceKind;
+  /** Index of the step at `index` in each run, or null when that run has ended. */
+  a: number | null;
+  b: number | null;
+  /** Set when `kind` is `changed`. */
+  differences: FieldDifference[];
+  reason: string;
+}
+interface StepDiff {
+  /** Paired steps in run A order. */
+  pairs: StepPair[];
+  /** Indexes of run A steps with no partner in run B. */
+  onlyInA: number[];
+  /** Indexes of run B steps with no partner in run A. */
+  onlyInB: number[];
+  /** Leading steps paired index for index with no difference. */
+  commonPrefixLen: number;
+  /** Null when the runs agree step for step. */
+  firstDivergence: StepDivergence | null;
+}
+declare function diffSteps(a: readonly DiffStep[], b: readonly DiffStep[]): StepDiff;
 interface DivergenceReport {
   runA: string;
   runB: string;
+  /** Null when the runs agree step for step. */
   firstDivergenceIndex: number | null;
   aStep?: TrajectoryStep;
   bStep?: TrajectoryStep;
   reason?: string;
-  /** Common prefix length (steps that matched). */
   commonPrefixLen: number;
+  /** The step diff behind the first divergence, over trajectory step indexes. */
+  diff: StepDiff;
 }
-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>;
+declare function firstDivergenceView(store: TraceStore, runA: string, runB: string): Promise<DivergenceReport>;
+/**
+ * One run's spans as diff steps, in containment order: depth first, siblings
+ * by start time, the same order `buildTrajectory` gives a trace store run.
+ * Spans whose parent is absent, or whose parents form a cycle, start their own
+ * subtree, so every span appears exactly once.
+ */
+declare function diffStepsFromSpans(spans: readonly DiagnosisSpan[]): DiffStep[];
 //#endregion
 //#region src/pipelines/regression.d.ts
 interface RegressionSpec {
@@ -67,5 +122,5 @@ interface StuckLoopOptions {
 }
 declare function stuckLoopView(store: TraceStore, options?: StuckLoopOptions): Promise<StuckLoopReport>;
 //#endregion
-export { BudgetBreachFinding, BudgetBreachReport, DivergenceOptions, DivergenceReport, FailureCluster, FailureClusterReport, JudgeAgreementReport, JudgePair, RegressionOptions, RegressionSpec, StuckLoopFinding, StuckLoopOptions, StuckLoopReport, ToolWasteFinding, ToolWasteOptions, ToolWasteReport, budgetBreachView, computeToolUseMetrics, failureClusterView, firstDivergenceView, judgeAgreementView, regressionView, stuckLoopView, toolWasteView };
+export { BudgetBreachFinding, BudgetBreachReport, DiffStep, DivergenceReport, FailureCluster, FailureClusterReport, FieldDifference, JudgeAgreementReport, JudgePair, RegressionOptions, RegressionSpec, StepDiff, StepDivergence, StepDivergenceKind, StepPair, StepPairing, StuckLoopFinding, StuckLoopOptions, StuckLoopReport, ToolWasteFinding, ToolWasteOptions, ToolWasteReport, budgetBreachView, computeToolUseMetrics, diffSteps, diffStepsFromSpans, failureClusterView, firstDivergenceView, judgeAgreementView, regressionView, stuckLoopView, toolWasteView };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/regression.ts","../../src/pipelines/stuck-loop.ts"],"mappings":";;;;;;UAYiB;EACf;EACA;EACA;EACA,QAAQ;EACR,QAAQ;EACR;;EAEA;;UAGe;;EAEf,cAAc,GAAG,gBAAgB,GAAG;;iBAGhB,oBACpB,OAAO,YACP,cACA,cACA,UAAS,oBACR,QAAQ;;;UCnBM;EACf;EACA;;;EAGA,WAAW,KAAK,KAAK,OAAO,eAAe;;UAG5B,0BAA0B;EACzC,UAAU;EACV,WAAW;;iBAGS,eACpB,OAAO,YACP,SAAS,kBACT,SAAS,oBACR,QAAQ;;;UCFM;EACf;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV;EACA;;UAGe;;EAEf;;EAEA;;;;;EAKA;;EAEA;;iBAGoB,cACpB,OAAO,YACP,UAAS,mBACR,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/regression.ts","../../src/pipelines/stuck-loop.ts"],"mappings":";;;;;;;;UAyBiB;;EAEf;EACA;EACA;;EAEA,QAAQ,SAAS;;KAGP;UAEK;EACf;EACA;EACA;;UAGe;;EAEf;;EAEA;EACA,UAAU;;EAEV,aAAa;;KAGH;UAEK;;EAEf;EACA,MAAM;;EAEN;EACA;;EAEA,aAAa;EACb;;UAGe;;EAEf,OAAO;;EAEP;;EAEA;;EAEA;;EAEA,iBAAiB;;iBAGH,UAAU,YAAY,YAAY,YAAY,aAAa;UAwI1D;EACf;EACA;;EAEA;EACA,QAAQ;EACR,QAAQ;EACR;EACA;;EAEA,MAAM;;iBAGc,oBACpB,OAAO,YACP,cACA,eACC,QAAQ;;;;;;;iBAmCK,mBAAmB,gBAAgB,kBAAkB;;;UC7PpD;EACf;EACA;;;EAGA,WAAW,KAAK,KAAK,OAAO,eAAe;;UAG5B,0BAA0B;EACzC,UAAU;EACV,WAAW;;iBAGS,eACpB,OAAO,YACP,SAAS,kBACT,SAAS,oBACR,QAAQ;;;UCFM;EACf;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV;EACA;;UAGe;;EAEf;;EAEA;;;;;EAKA;;EAEA;;iBAGoB,cACpB,OAAO,YACP,UAAS,mBACR,QAAQ"}

package/dist/pipelines/index.js

@@ -1,57 +1,194 @@
-import { a as budgetBreachView, i as failureClusterView, n as computeToolUseMetrics, r as judgeAgreementView, t as toolWasteView } from "../tool-waste-nbHPAxei.js";
+import { a as budgetBreachView, i as failureClusterView, n as computeToolUseMetrics, r as judgeAgreementView, t as toolWasteView } from "../tool-waste-CJDfxH45.js";
 import { t as compareToBaseline } from "../baseline-BC-eBZ7U.js";
 import { a as isToolSpan } from "../schema-CSf6qWgZ.js";
 import { a as hasCapturedToolArgs, r as argHash, u as runMetricExtractor } from "../query-DlV0pdx4.js";
 import { t as buildTrajectory } from "../trajectory-D_7rLrvE.js";
 import { t as executionTrackByLane } from "../execution-tracks-CpgFPpS5.js";
 //#region src/pipelines/first-divergence.ts
-async function firstDivergenceView(store, runA, runB, options = {}) {
-	const [a, b] = await Promise.all([buildTrajectory(store, runA), buildTrajectory(store, runB)]);
-	const eq = options.stepEquals ?? defaultStepEquals;
-	const minLen = Math.min(a.steps.length, b.steps.length);
-	for (let i = 0; i < minLen; i++) {
-		const aStep = a.steps[i];
-		const bStep = b.steps[i];
-		if (!eq(aStep, bStep)) return {
-			runA,
-			runB,
-			firstDivergenceIndex: i,
-			aStep,
-			bStep,
-			reason: describeDifference(aStep, bStep),
-			commonPrefixLen: i
-		};
+function diffSteps(a, b) {
+	const partnerOfA = /* @__PURE__ */ new Map();
+	const pairedB = /* @__PURE__ */ new Set();
+	const pair = (i, j, pairedBy) => {
+		partnerOfA.set(i, {
+			b: j,
+			pairedBy
+		});
+		pairedB.add(j);
+	};
+	const bById = /* @__PURE__ */ new Map();
+	b.forEach((step, j) => {
+		const list = bById.get(step.id);
+		if (list) list.push(j);
+		else bById.set(step.id, [j]);
+	});
+	a.forEach((step, i) => {
+		const j = bById.get(step.id)?.find((candidate) => !pairedB.has(candidate));
+		if (j !== void 0) pair(i, j, "id");
+	});
+	a.forEach((step, i) => {
+		if (partnerOfA.has(i) || i >= b.length || pairedB.has(i)) return;
+		if (sameShape(step, b[i])) pair(i, i, "position");
+	});
+	a.forEach((step, i) => {
+		if (partnerOfA.has(i)) return;
+		const j = b.findIndex((candidate, index) => !pairedB.has(index) && sameShape(step, candidate));
+		if (j >= 0) pair(i, j, "name");
+	});
+	const pairs = [...partnerOfA.entries()].sort(([x], [y]) => x - y).map(([i, partner]) => ({
+		a: i,
+		b: partner.b,
+		pairedBy: partner.pairedBy,
+		differences: differencesBetween(a[i], b[partner.b])
+	}));
+	const pairByA = new Map(pairs.map((entry) => [entry.a, entry]));
+	const partnerOfB = new Map(pairs.map((entry) => [entry.b, entry.a]));
+	let prefix = 0;
+	while (prefix < a.length && prefix < b.length) {
+		const entry = pairByA.get(prefix);
+		if (!entry || entry.b !== prefix || entry.differences.length > 0) break;
+		prefix += 1;
 	}
-	if (a.steps.length === b.steps.length) return {
-		runA,
-		runB,
-		firstDivergenceIndex: null,
-		commonPrefixLen: minLen
+	return {
+		pairs,
+		onlyInA: a.map((_, i) => i).filter((i) => !partnerOfA.has(i)),
+		onlyInB: b.map((_, j) => j).filter((j) => !pairedB.has(j)),
+		commonPrefixLen: prefix,
+		firstDivergence: prefix === a.length && prefix === b.length ? null : divergenceAt(prefix, a, b, pairByA.get(prefix), partnerOfB)
+	};
+}
+function divergenceAt(index, a, b, pairOfA, partnerOfB) {
+	const stepA = a[index];
+	const stepB = b[index];
+	const base = {
+		index,
+		a: stepA ? index : null,
+		b: stepB ? index : null,
+		differences: []
+	};
+	if (stepA && stepB && pairOfA?.b === index) return {
+		...base,
+		kind: "changed",
+		differences: pairOfA.differences,
+		reason: `at index ${index}, ${describe(stepA)} changed: ${pairOfA.differences.map((d) => `${d.field} ${String(d.a)} vs ${String(d.b)}`).join("; ")}`
+	};
+	const aUnpaired = stepA !== void 0 && pairOfA === void 0;
+	const bUnpaired = stepB !== void 0 && !partnerOfB.has(index);
+	if (stepA && stepB && aUnpaired && bUnpaired) return {
+		...base,
+		kind: "replaced",
+		reason: `at index ${index}, A ran ${describe(stepA)} and B ran ${describe(stepB)}`
+	};
+	if (stepA && aUnpaired) return {
+		...base,
+		kind: "only-in-a",
+		reason: `at index ${index}, only A has ${describe(stepA)}`
+	};
+	if (stepB && bUnpaired) return {
+		...base,
+		kind: "only-in-b",
+		reason: `at index ${index}, only B has ${describe(stepB)}`
+	};
+	return {
+		...base,
+		kind: "reordered",
+		reason: `at index ${index}, A ran ${describe(stepA)} and B ran ${describe(stepB)}; both steps occur in the other run at a different position`
 	};
-	const extra = (a.steps.length > b.steps.length ? a : b).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}`;
+}
+function sameShape(x, y) {
+	return x.name === y.name && x.kind === y.kind;
+}
+function differencesBetween(x, y) {
+	const differences = [];
+	if (x.kind !== y.kind) differences.push({
+		field: "kind",
+		a: x.kind,
+		b: y.kind
+	});
+	if (x.name !== y.name) differences.push({
+		field: "name",
+		a: x.name,
+		b: y.name
+	});
+	const fields = [.../* @__PURE__ */ new Set([...Object.keys(x.fields), ...Object.keys(y.fields)])].sort();
+	for (const field of fields) {
+		const left = x.fields[field] ?? null;
+		const right = y.fields[field] ?? null;
+		if (left !== right) differences.push({
+			field,
+			a: left,
+			b: right
+		});
+	}
+	return differences;
+}
+function describe(step) {
+	return `${step.kind} "${step.name}"`;
+}
+async function firstDivergenceView(store, runA, runB) {
+	const [a, b] = await Promise.all([buildTrajectory(store, runA), buildTrajectory(store, runB)]);
+	const diff = diffSteps(a.steps.map(trajectoryDiffStep), b.steps.map(trajectoryDiffStep));
+	const divergence = diff.firstDivergence;
 	return {
 		runA,
 		runB,
-		firstDivergenceIndex: minLen,
-		aStep: a.steps[minLen],
-		bStep: b.steps[minLen],
-		reason,
-		commonPrefixLen: minLen
+		firstDivergenceIndex: divergence?.index ?? null,
+		...divergence?.a != null ? { aStep: a.steps[divergence.a] } : {},
+		...divergence?.b != null ? { bStep: b.steps[divergence.b] } : {},
+		...divergence ? { reason: divergence.reason } : {},
+		commonPrefixLen: diff.commonPrefixLen,
+		diff
 	};
 }
-function defaultStepEquals(a, b) {
-	if (a.span.kind !== b.span.kind) return false;
-	if (a.span.kind === "tool" && b.span.kind === "tool") return a.span.toolName === b.span.toolName;
-	if (a.span.kind === "llm" && b.span.kind === "llm") return a.span.model === b.span.model;
-	if (a.span.kind === "judge" && b.span.kind === "judge") return a.span.dimension === b.span.dimension;
-	return a.span.name === b.span.name;
+function trajectoryDiffStep(step) {
+	const span = step.span;
+	const fields = { status: span.status ?? null };
+	if (span.kind === "tool") fields.tool = span.toolName;
+	if (span.kind === "llm") fields.model = span.model;
+	if (span.kind === "judge") fields.dimension = span.dimension;
+	return {
+		id: span.spanId,
+		name: span.name,
+		kind: span.kind,
+		fields
+	};
 }
-function describeDifference(a, b) {
-	if (a.span.kind !== b.span.kind) return `kind ${a.span.kind} vs ${b.span.kind}`;
-	if (a.span.kind === "tool" && b.span.kind === "tool" && a.span.toolName !== b.span.toolName) return `tool ${a.span.toolName} vs ${b.span.toolName}`;
-	if (a.span.kind === "llm" && b.span.kind === "llm" && a.span.model !== b.span.model) return `model ${a.span.model} vs ${b.span.model}`;
-	return `name "${a.span.name}" vs "${b.span.name}"`;
+/**
+* One run's spans as diff steps, in containment order: depth first, siblings
+* by start time, the same order `buildTrajectory` gives a trace store run.
+* Spans whose parent is absent, or whose parents form a cycle, start their own
+* subtree, so every span appears exactly once.
+*/
+function diffStepsFromSpans(spans) {
+	const ids = new Set(spans.map((span) => span.spanId));
+	const children = /* @__PURE__ */ new Map();
+	for (const span of spans) {
+		const parent = span.parentSpanId !== null && ids.has(span.parentSpanId) ? span.parentSpanId : null;
+		const list = children.get(parent);
+		if (list) list.push(span);
+		else children.set(parent, [span]);
+	}
+	const byStart = (x, y) => (x.startMs ?? 0) - (y.startMs ?? 0) || x.spanId.localeCompare(y.spanId);
+	for (const list of children.values()) list.sort(byStart);
+	const ordered = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (span) => {
+		if (visited.has(span.spanId)) return;
+		visited.add(span.spanId);
+		ordered.push({
+			id: span.spanId,
+			name: span.name,
+			kind: span.kind,
+			fields: {
+				status: span.status,
+				tool: span.toolName,
+				model: span.model
+			}
+		});
+		for (const child of children.get(span.spanId) ?? []) visit(child);
+	};
+	for (const root of children.get(null) ?? []) visit(root);
+	for (const span of [...spans].sort(byStart)) visit(span);
+	return ordered;
 }
 //#endregion
 //#region src/pipelines/regression.ts
@@ -237,6 +374,6 @@ function callsAreSerial(previous, next) {
 	return previous.span.endedAt !== void 0 && previous.span.endedAt <= next.span.startedAt;
 }
 //#endregion
-export { budgetBreachView, computeToolUseMetrics, failureClusterView, firstDivergenceView, judgeAgreementView, regressionView, stuckLoopView, toolWasteView };
+export { budgetBreachView, computeToolUseMetrics, diffSteps, diffStepsFromSpans, failureClusterView, firstDivergenceView, judgeAgreementView, regressionView, stuckLoopView, toolWasteView };
 
 //# sourceMappingURL=index.js.map

package/dist/pipelines/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/regression.ts","../../src/pipelines/stuck-loop.ts"],"sourcesContent":["/**\n * FirstDivergenceView — aligns two trajectories by step index, reports\n * the first step where they differ.\n *\n * \"Differ\" is configurable — default is (kind, toolName if tool, model\n * if llm). Use this view to attribute \"why is variant B better?\" to a\n * specific step rather than an aggregate mean delta.\n */\n\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory, type Trajectory, type TrajectoryStep } from '../trajectory'\n\nexport interface DivergenceReport {\n  runA: string\n  runB: string\n  firstDivergenceIndex: number | null\n  aStep?: TrajectoryStep\n  bStep?: TrajectoryStep\n  reason?: string\n  /** Common prefix length (steps that matched). */\n  commonPrefixLen: number\n}\n\nexport interface DivergenceOptions {\n  /** Returns true if two steps are considered equal. Default: kind + tool/model match. */\n  stepEquals?: (a: TrajectoryStep, b: TrajectoryStep) => boolean\n}\n\nexport async function firstDivergenceView(\n  store: TraceStore,\n  runA: string,\n  runB: string,\n  options: DivergenceOptions = {},\n): Promise<DivergenceReport> {\n  const [a, b] = await Promise.all([buildTrajectory(store, runA), buildTrajectory(store, runB)])\n  const eq = options.stepEquals ?? defaultStepEquals\n  const minLen = Math.min(a.steps.length, b.steps.length)\n  for (let i = 0; i < minLen; i++) {\n    const aStep = a.steps[i]!\n    const bStep = b.steps[i]!\n    if (!eq(aStep, bStep)) {\n      return {\n        runA,\n        runB,\n        firstDivergenceIndex: i,\n        aStep,\n        bStep,\n        reason: describeDifference(aStep, bStep),\n        commonPrefixLen: i,\n      }\n    }\n  }\n  if (a.steps.length === b.steps.length) {\n    return { runA, runB, firstDivergenceIndex: null, commonPrefixLen: minLen }\n  }\n  const longer: Trajectory = a.steps.length > b.steps.length ? a : b\n  const extra = longer.steps.length - minLen\n  // minLen === 0 means one trajectory is empty: divergence is the first step\n  // itself (index 0), and the absent side has no step to surface.\n  const reason =\n    minLen === 0\n      ? `one trajectory is empty; the other has ${extra} step(s) starting at index 0`\n      : `one trajectory has ${extra} more step(s) after index ${minLen - 1}`\n  return {\n    runA,\n    runB,\n    firstDivergenceIndex: minLen,\n    aStep: a.steps[minLen],\n    bStep: b.steps[minLen],\n    reason,\n    commonPrefixLen: minLen,\n  }\n}\n\nfunction defaultStepEquals(a: TrajectoryStep, b: TrajectoryStep): boolean {\n  if (a.span.kind !== b.span.kind) return false\n  if (a.span.kind === 'tool' && b.span.kind === 'tool') return a.span.toolName === b.span.toolName\n  if (a.span.kind === 'llm' && b.span.kind === 'llm') return a.span.model === b.span.model\n  if (a.span.kind === 'judge' && b.span.kind === 'judge')\n    return a.span.dimension === b.span.dimension\n  return a.span.name === b.span.name\n}\n\nfunction describeDifference(a: TrajectoryStep, b: TrajectoryStep): string {\n  if (a.span.kind !== b.span.kind) return `kind ${a.span.kind} vs ${b.span.kind}`\n  if (a.span.kind === 'tool' && b.span.kind === 'tool' && a.span.toolName !== b.span.toolName) {\n    return `tool ${a.span.toolName} vs ${b.span.toolName}`\n  }\n  if (a.span.kind === 'llm' && b.span.kind === 'llm' && a.span.model !== b.span.model) {\n    return `model ${a.span.model} vs ${b.span.model}`\n  }\n  return `name \"${a.span.name}\" vs \"${b.span.name}\"`\n}\n","/**\n * RegressionView — compares a candidate slice to a baseline slice on a\n * named metric. Delegates the statistics (Welch's t-test, Cohen's d,\n * IQR stability) to `baseline.ts`.\n *\n * This is the entry point for CI regression gates: \"given runs tagged\n * release=A and release=B, did any metric regress?\"\n */\n\nimport { type BaselineOptions, type BaselineReport, compareToBaseline } from '../baseline'\nimport { runMetricExtractor } from '../trace/query'\nimport type { Run } from '../trace/schema'\nimport type { RunFilter, TraceStore } from '../trace/store'\n\nexport interface RegressionSpec {\n  metric: string\n  higherIsBetter: boolean\n  /** Extract a scalar from a run. Omit it and `metric` must name one of\n   *  `RUN_METRICS`; any other name is refused. */\n  extract?: (run: Run, store: TraceStore) => Promise<number | null>\n}\n\nexport interface RegressionOptions extends BaselineOptions {\n  baseline: RunFilter\n  candidate: RunFilter\n}\n\nexport async function regressionView(\n  store: TraceStore,\n  metrics: RegressionSpec[],\n  options: RegressionOptions,\n): Promise<BaselineReport> {\n  const baselineRuns = await store.listRuns(options.baseline)\n  const candidateRuns = await store.listRuns(options.candidate)\n  const samples = await Promise.all(\n    metrics.map(async (m) => {\n      const extract = m.extract ?? runMetricExtractor(m.metric)\n      const baseline = await extractAll(baselineRuns, extract, store)\n      const candidate = await extractAll(candidateRuns, extract, store)\n      return { metric: m.metric, higherIsBetter: m.higherIsBetter, baseline, candidate }\n    }),\n  )\n  return compareToBaseline(samples, options)\n}\n\nasync function extractAll(\n  runs: Run[],\n  extract: (r: Run, s: TraceStore) => Promise<number | null>,\n  store: TraceStore,\n): Promise<number[]> {\n  const out: number[] = []\n  for (const r of runs) {\n    const v = await extract(r, store)\n    if (v !== null && Number.isFinite(v)) out.push(v)\n  }\n  return out\n}\n","/**\n * StuckLoopView — detects when an agent calls the same tool with the\n * same (or structurally similar) arguments ≥ N times in a short window.\n *\n * Rationale: agents that loop are the number-one production failure\n * mode on long-horizon flows. The view returns (runId, toolName,\n * argHash, occurrences, windowMs) for each detected loop plus a\n * fraction of runs affected.\n */\n\nimport { executionTrackByLane } from '../trace/execution-tracks'\nimport { argHash, hasCapturedToolArgs } from '../trace/query'\nimport { isToolSpan, type Span, type ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\n\nconst DEFAULT_MAX_WINDOW_MS = 60_000\nconst DEFAULT_MAX_INTERVENING_TOOL_CALLS = 0\n\ninterface ScopedToolCall {\n  span: ToolSpan\n  scopeSpanId: string | null\n  laneSpanId: string | null\n}\n\ninterface IndexedToolCall extends ScopedToolCall {\n  toolCallIndex: number\n  trackId: string\n}\n\nexport interface StuckLoopFinding {\n  runId: string\n  toolName: string\n  argHash: string\n  /** Calls in this episode's densest qualifying interval, not the whole-run total. */\n  occurrences: number\n  spanIds: string[]\n  /** Nearest agent ancestor, or the direct parent when ancestry is incomplete. */\n  scopeSpanId?: string\n  /** Milliseconds between first and last call in the loop. */\n  windowMs: number\n}\n\nexport interface StuckLoopReport {\n  findings: StuckLoopFinding[]\n  affectedRunRatio: number\n  totalRuns: number\n}\n\nexport interface StuckLoopOptions {\n  /** Minimum call count to flag a loop (default 3). */\n  minOccurrences?: number\n  /** Maximum time between the first and last repeated call (default 60 seconds). */\n  maxWindowMs?: number\n  /**\n   * Maximum other tool calls allowed between adjacent repeats (default 0).\n   * Set to 1 to detect alternating patterns such as A,B,A,B,A.\n   */\n  maxInterveningToolCalls?: number\n  /** Filter to a specific runId; omit to scan the entire corpus. */\n  runId?: string\n}\n\nexport async function stuckLoopView(\n  store: TraceStore,\n  options: StuckLoopOptions = {},\n): Promise<StuckLoopReport> {\n  const minOccurrences = options.minOccurrences ?? 3\n  const maxWindowMs = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS\n  const maxInterveningToolCalls =\n    options.maxInterveningToolCalls ?? DEFAULT_MAX_INTERVENING_TOOL_CALLS\n  if (!Number.isInteger(minOccurrences) || minOccurrences < 1) {\n    throw new RangeError('minOccurrences must be a positive integer')\n  }\n  if (!Number.isFinite(maxWindowMs) || maxWindowMs < 0) {\n    throw new RangeError('maxWindowMs must be a finite non-negative number')\n  }\n  if (!Number.isInteger(maxInterveningToolCalls) || maxInterveningToolCalls < 0) {\n    throw new RangeError('maxInterveningToolCalls must be a non-negative integer')\n  }\n  const runs = options.runId\n    ? [{ runId: options.runId }]\n    : (await store.listRuns()).map((r) => ({ runId: r.runId }))\n\n  const findings: StuckLoopFinding[] = []\n  for (const { runId } of runs) {\n    const spans = await store.spans({ runId })\n    const spansById = new Map(spans.map((span) => [span.spanId, span]))\n    const scopedTools: ScopedToolCall[] = spans\n      .filter(isToolSpan)\n      .map((span, sourceIndex) => ({ span, sourceIndex }))\n      .sort((a, b) => a.span.startedAt - b.span.startedAt || a.sourceIndex - b.sourceIndex)\n      .map(({ span }) => ({ span, ...executionScope(span, spansById) }))\n    const trackByLane = executionTrackByLane(\n      scopedTools.map((call) => {\n        const direct = call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n        const timed = direct\n          ? call.span\n          : call.laneSpanId\n            ? spansById.get(call.laneSpanId)\n            : undefined\n        return {\n          key: executionKey(call),\n          scopeKey: JSON.stringify(call.scopeSpanId),\n          start: timed?.startedAt ?? null,\n          end: timed?.endedAt ?? null,\n        }\n      }),\n    )\n    const nextToolIndexByTrack = new Map<string, number>()\n    const orderedTools: IndexedToolCall[] = scopedTools.map((call) => {\n      const trackId = trackByLane.get(executionKey(call))!\n      const toolCallIndex = nextToolIndexByTrack.get(trackId) ?? 0\n      nextToolIndexByTrack.set(trackId, toolCallIndex + 1)\n      return { ...call, toolCallIndex, trackId }\n    })\n    const byKey = new Map<\n      string,\n      {\n        calls: IndexedToolCall[]\n        argHash: string\n        toolName: string\n        scopeSpanId: string | null\n      }\n    >()\n    for (const call of orderedTools) {\n      if (!hasCapturedToolArgs(call.span)) continue\n      const h = argHash(call.span.args)\n      const key = JSON.stringify([call.trackId, call.span.toolName, h])\n      const bucket = byKey.get(key) ?? {\n        calls: [],\n        argHash: h,\n        toolName: call.span.toolName,\n        scopeSpanId: call.scopeSpanId,\n      }\n      bucket.calls.push(call)\n      byKey.set(key, bucket)\n    }\n    for (const { calls, argHash: h, toolName, scopeSpanId } of byKey.values()) {\n      if (calls.length < minOccurrences) continue\n      let episodeStart = 0\n      for (let episodeEnd = 1; episodeEnd <= calls.length; episodeEnd += 1) {\n        const previous = calls[episodeEnd - 1]!\n        const next = calls[episodeEnd]\n        const episodeEnded =\n          next === undefined ||\n          next.span.startedAt - previous.span.startedAt > maxWindowMs ||\n          next.toolCallIndex - previous.toolCallIndex - 1 > maxInterveningToolCalls ||\n          !callsAreSerial(previous, next)\n        if (!episodeEnded) continue\n\n        const episode = calls.slice(episodeStart, episodeEnd)\n        let left = 0\n        let bestStart = 0\n        let bestEnd = -1\n        for (let right = 0; right < episode.length; right += 1) {\n          while (episode[right]!.span.startedAt - episode[left]!.span.startedAt > maxWindowMs) {\n            left += 1\n          }\n          if (right - left > bestEnd - bestStart) {\n            bestStart = left\n            bestEnd = right\n          }\n        }\n        if (bestEnd - bestStart + 1 >= minOccurrences) {\n          const loop = episode.slice(bestStart, bestEnd + 1)\n          const first = loop[0]!.span.startedAt\n          const last = loop[loop.length - 1]!.span.startedAt\n          findings.push({\n            runId,\n            toolName,\n            argHash: h,\n            occurrences: loop.length,\n            spanIds: loop.map((call) => call.span.spanId),\n            ...(scopeSpanId ? { scopeSpanId } : {}),\n            windowMs: last - first,\n          })\n        }\n        episodeStart = episodeEnd\n      }\n    }\n  }\n\n  const affectedRuns = new Set(findings.map((f) => f.runId))\n  return {\n    findings,\n    affectedRunRatio: runs.length > 0 ? affectedRuns.size / runs.length : 0,\n    totalRuns: runs.length,\n  }\n}\n\nfunction laneKey(call: Pick<ScopedToolCall, 'scopeSpanId' | 'laneSpanId'>): string {\n  return JSON.stringify([call.scopeSpanId, call.laneSpanId])\n}\n\nfunction executionKey(call: ScopedToolCall): string {\n  return call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n    ? JSON.stringify([call.scopeSpanId, call.span.spanId])\n    : laneKey(call)\n}\n\nfunction executionScope(\n  span: ToolSpan,\n  spansById: ReadonlyMap<string, Span>,\n): { scopeSpanId: string | null; laneSpanId: string | null } {\n  const directParent = span.parentSpanId\n  if (!directParent) return { scopeSpanId: null, laneSpanId: null }\n\n  let currentId: string | undefined = directParent\n  let laneSpanId: string | null = null\n  const seen = new Set<string>()\n  while (currentId && !seen.has(currentId)) {\n    seen.add(currentId)\n    const current = spansById.get(currentId)\n    if (!current) return { scopeSpanId: directParent, laneSpanId: directParent }\n    if (current.kind === 'agent') {\n      return { scopeSpanId: current.spanId, laneSpanId: laneSpanId ?? current.spanId }\n    }\n    laneSpanId = current.spanId\n    currentId = current.parentSpanId\n  }\n  return { scopeSpanId: directParent, laneSpanId: directParent }\n}\n\nfunction callsAreSerial(previous: IndexedToolCall, next: IndexedToolCall): boolean {\n  return previous.span.endedAt !== undefined && previous.span.endedAt <= next.span.startedAt\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/pipelines/first-divergence.ts","../../src/pipelines/regression.ts","../../src/pipelines/stuck-loop.ts"],"sourcesContent":["/**\n * Step diff between two runs, with the first divergence marked.\n *\n * Steps pair in three passes, each over the steps still unpaired:\n *   1. `id`: the same step id in both runs, e.g. a forked run that kept its\n *      parent's span ids.\n *   2. `position`: the same index with the same name and kind.\n *   3. `name`: the same name and kind anywhere, first unpaired step in order.\n * A step left unpaired exists in only one run. The first divergence is the\n * first index at which the two runs stop agreeing step for step, and it says\n * how: a paired step changed, one run replaced, added or removed a step, or the\n * runs ran the same steps in a different order.\n *\n * `diffSteps` reads plain `DiffStep` lists, so the same diff serves agent-eval\n * trace stores (`firstDivergenceView`) and flat OTLP spans\n * (`diffStepsFromSpans`). Use it to attribute \"why is variant B better?\" to a\n * step, and to compare sibling or parent and child runs of a search tree.\n */\n\nimport type { DiagnosisSpan } from '../diagnosis/spans'\nimport type { Span } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory, type TrajectoryStep } from '../trajectory'\n\n/** One step of a run, as the diff reads it. */\nexport interface DiffStep {\n  /** The step's id within its run. */\n  id: string\n  name: string\n  kind: string\n  /** Fields compared once two steps pair, such as status, tool or model. */\n  fields: Readonly<Record<string, string | number | boolean | null>>\n}\n\nexport type StepPairing = 'id' | 'position' | 'name'\n\nexport interface FieldDifference {\n  field: string\n  a: string | number | boolean | null\n  b: string | number | boolean | null\n}\n\nexport interface StepPair {\n  /** Index in run A. */\n  a: number\n  /** Index in run B. */\n  b: number\n  pairedBy: StepPairing\n  /** Empty when the paired steps agree on name, kind and every field. */\n  differences: FieldDifference[]\n}\n\nexport type StepDivergenceKind = 'changed' | 'replaced' | 'only-in-a' | 'only-in-b' | 'reordered'\n\nexport interface StepDivergence {\n  /** The first index at which the runs stop agreeing; equals `commonPrefixLen`. */\n  index: number\n  kind: StepDivergenceKind\n  /** Index of the step at `index` in each run, or null when that run has ended. */\n  a: number | null\n  b: number | null\n  /** Set when `kind` is `changed`. */\n  differences: FieldDifference[]\n  reason: string\n}\n\nexport interface StepDiff {\n  /** Paired steps in run A order. */\n  pairs: StepPair[]\n  /** Indexes of run A steps with no partner in run B. */\n  onlyInA: number[]\n  /** Indexes of run B steps with no partner in run A. */\n  onlyInB: number[]\n  /** Leading steps paired index for index with no difference. */\n  commonPrefixLen: number\n  /** Null when the runs agree step for step. */\n  firstDivergence: StepDivergence | null\n}\n\nexport function diffSteps(a: readonly DiffStep[], b: readonly DiffStep[]): StepDiff {\n  const partnerOfA = new Map<number, { b: number; pairedBy: StepPairing }>()\n  const pairedB = new Set<number>()\n  const pair = (i: number, j: number, pairedBy: StepPairing) => {\n    partnerOfA.set(i, { b: j, pairedBy })\n    pairedB.add(j)\n  }\n\n  const bById = new Map<string, number[]>()\n  b.forEach((step, j) => {\n    const list = bById.get(step.id)\n    if (list) list.push(j)\n    else bById.set(step.id, [j])\n  })\n  a.forEach((step, i) => {\n    const j = bById.get(step.id)?.find((candidate) => !pairedB.has(candidate))\n    if (j !== undefined) pair(i, j, 'id')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i) || i >= b.length || pairedB.has(i)) return\n    if (sameShape(step, b[i]!)) pair(i, i, 'position')\n  })\n  a.forEach((step, i) => {\n    if (partnerOfA.has(i)) return\n    const j = b.findIndex((candidate, index) => !pairedB.has(index) && sameShape(step, candidate))\n    if (j >= 0) pair(i, j, 'name')\n  })\n\n  const pairs: StepPair[] = [...partnerOfA.entries()]\n    .sort(([x], [y]) => x - y)\n    .map(([i, partner]) => ({\n      a: i,\n      b: partner.b,\n      pairedBy: partner.pairedBy,\n      differences: differencesBetween(a[i]!, b[partner.b]!),\n    }))\n  const pairByA = new Map(pairs.map((entry) => [entry.a, entry]))\n  const partnerOfB = new Map(pairs.map((entry) => [entry.b, entry.a]))\n\n  let prefix = 0\n  while (prefix < a.length && prefix < b.length) {\n    const entry = pairByA.get(prefix)\n    if (!entry || entry.b !== prefix || entry.differences.length > 0) break\n    prefix += 1\n  }\n\n  return {\n    pairs,\n    onlyInA: a.map((_, i) => i).filter((i) => !partnerOfA.has(i)),\n    onlyInB: b.map((_, j) => j).filter((j) => !pairedB.has(j)),\n    commonPrefixLen: prefix,\n    firstDivergence:\n      prefix === a.length && prefix === b.length\n        ? null\n        : divergenceAt(prefix, a, b, pairByA.get(prefix), partnerOfB),\n  }\n}\n\nfunction divergenceAt(\n  index: number,\n  a: readonly DiffStep[],\n  b: readonly DiffStep[],\n  pairOfA: StepPair | undefined,\n  partnerOfB: ReadonlyMap<number, number>,\n): StepDivergence {\n  const stepA = a[index]\n  const stepB = b[index]\n  const base = {\n    index,\n    a: stepA ? index : null,\n    b: stepB ? index : null,\n    differences: [] as FieldDifference[],\n  }\n  if (stepA && stepB && pairOfA?.b === index) {\n    return {\n      ...base,\n      kind: 'changed',\n      differences: pairOfA.differences,\n      reason: `at index ${index}, ${describe(stepA)} changed: ${pairOfA.differences\n        .map((d) => `${d.field} ${String(d.a)} vs ${String(d.b)}`)\n        .join('; ')}`,\n    }\n  }\n  const aUnpaired = stepA !== undefined && pairOfA === undefined\n  const bUnpaired = stepB !== undefined && !partnerOfB.has(index)\n  if (stepA && stepB && aUnpaired && bUnpaired) {\n    return {\n      ...base,\n      kind: 'replaced',\n      reason: `at index ${index}, A ran ${describe(stepA)} and B ran ${describe(stepB)}`,\n    }\n  }\n  if (stepA && aUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-a',\n      reason: `at index ${index}, only A has ${describe(stepA)}`,\n    }\n  }\n  if (stepB && bUnpaired) {\n    return {\n      ...base,\n      kind: 'only-in-b',\n      reason: `at index ${index}, only B has ${describe(stepB)}`,\n    }\n  }\n  return {\n    ...base,\n    kind: 'reordered',\n    reason: `at index ${index}, A ran ${describe(stepA!)} and B ran ${describe(stepB!)}; both steps occur in the other run at a different position`,\n  }\n}\n\nfunction sameShape(x: DiffStep, y: DiffStep): boolean {\n  return x.name === y.name && x.kind === y.kind\n}\n\nfunction differencesBetween(x: DiffStep, y: DiffStep): FieldDifference[] {\n  const differences: FieldDifference[] = []\n  if (x.kind !== y.kind) differences.push({ field: 'kind', a: x.kind, b: y.kind })\n  if (x.name !== y.name) differences.push({ field: 'name', a: x.name, b: y.name })\n  const fields = [...new Set([...Object.keys(x.fields), ...Object.keys(y.fields)])].sort()\n  for (const field of fields) {\n    const left = x.fields[field] ?? null\n    const right = y.fields[field] ?? null\n    if (left !== right) differences.push({ field, a: left, b: right })\n  }\n  return differences\n}\n\nfunction describe(step: DiffStep): string {\n  return `${step.kind} \"${step.name}\"`\n}\n\n// ── agent-eval trace store ────────────────────────────────────────────\n\nexport interface DivergenceReport {\n  runA: string\n  runB: string\n  /** Null when the runs agree step for step. */\n  firstDivergenceIndex: number | null\n  aStep?: TrajectoryStep\n  bStep?: TrajectoryStep\n  reason?: string\n  commonPrefixLen: number\n  /** The step diff behind the first divergence, over trajectory step indexes. */\n  diff: StepDiff\n}\n\nexport async function firstDivergenceView(\n  store: TraceStore,\n  runA: string,\n  runB: string,\n): Promise<DivergenceReport> {\n  const [a, b] = await Promise.all([buildTrajectory(store, runA), buildTrajectory(store, runB)])\n  const diff = diffSteps(a.steps.map(trajectoryDiffStep), b.steps.map(trajectoryDiffStep))\n  const divergence = diff.firstDivergence\n  return {\n    runA,\n    runB,\n    firstDivergenceIndex: divergence?.index ?? null,\n    ...(divergence?.a != null ? { aStep: a.steps[divergence.a] } : {}),\n    ...(divergence?.b != null ? { bStep: b.steps[divergence.b] } : {}),\n    ...(divergence ? { reason: divergence.reason } : {}),\n    commonPrefixLen: diff.commonPrefixLen,\n    diff,\n  }\n}\n\nfunction trajectoryDiffStep(step: TrajectoryStep): DiffStep {\n  const span: Span = step.span\n  const fields: Record<string, string | number | boolean | null> = {\n    status: span.status ?? null,\n  }\n  if (span.kind === 'tool') fields.tool = span.toolName\n  if (span.kind === 'llm') fields.model = span.model\n  if (span.kind === 'judge') fields.dimension = span.dimension\n  return { id: span.spanId, name: span.name, kind: span.kind, fields }\n}\n\n// ── flat OTLP spans ───────────────────────────────────────────────────\n\n/**\n * One run's spans as diff steps, in containment order: depth first, siblings\n * by start time, the same order `buildTrajectory` gives a trace store run.\n * Spans whose parent is absent, or whose parents form a cycle, start their own\n * subtree, so every span appears exactly once.\n */\nexport function diffStepsFromSpans(spans: readonly DiagnosisSpan[]): DiffStep[] {\n  const ids = new Set(spans.map((span) => span.spanId))\n  const children = new Map<string | null, DiagnosisSpan[]>()\n  for (const span of spans) {\n    const parent =\n      span.parentSpanId !== null && ids.has(span.parentSpanId) ? span.parentSpanId : null\n    const list = children.get(parent)\n    if (list) list.push(span)\n    else children.set(parent, [span])\n  }\n  const byStart = (x: DiagnosisSpan, y: DiagnosisSpan) =>\n    (x.startMs ?? 0) - (y.startMs ?? 0) || x.spanId.localeCompare(y.spanId)\n  for (const list of children.values()) list.sort(byStart)\n  const ordered: DiffStep[] = []\n  const visited = new Set<string>()\n  const visit = (span: DiagnosisSpan) => {\n    if (visited.has(span.spanId)) return\n    visited.add(span.spanId)\n    ordered.push({\n      id: span.spanId,\n      name: span.name,\n      kind: span.kind,\n      fields: { status: span.status, tool: span.toolName, model: span.model },\n    })\n    for (const child of children.get(span.spanId) ?? []) visit(child)\n  }\n  for (const root of children.get(null) ?? []) visit(root)\n  for (const span of [...spans].sort(byStart)) visit(span)\n  return ordered\n}\n","/**\n * RegressionView — compares a candidate slice to a baseline slice on a\n * named metric. Delegates the statistics (Welch's t-test, Cohen's d,\n * IQR stability) to `baseline.ts`.\n *\n * This is the entry point for CI regression gates: \"given runs tagged\n * release=A and release=B, did any metric regress?\"\n */\n\nimport { type BaselineOptions, type BaselineReport, compareToBaseline } from '../baseline'\nimport { runMetricExtractor } from '../trace/query'\nimport type { Run } from '../trace/schema'\nimport type { RunFilter, TraceStore } from '../trace/store'\n\nexport interface RegressionSpec {\n  metric: string\n  higherIsBetter: boolean\n  /** Extract a scalar from a run. Omit it and `metric` must name one of\n   *  `RUN_METRICS`; any other name is refused. */\n  extract?: (run: Run, store: TraceStore) => Promise<number | null>\n}\n\nexport interface RegressionOptions extends BaselineOptions {\n  baseline: RunFilter\n  candidate: RunFilter\n}\n\nexport async function regressionView(\n  store: TraceStore,\n  metrics: RegressionSpec[],\n  options: RegressionOptions,\n): Promise<BaselineReport> {\n  const baselineRuns = await store.listRuns(options.baseline)\n  const candidateRuns = await store.listRuns(options.candidate)\n  const samples = await Promise.all(\n    metrics.map(async (m) => {\n      const extract = m.extract ?? runMetricExtractor(m.metric)\n      const baseline = await extractAll(baselineRuns, extract, store)\n      const candidate = await extractAll(candidateRuns, extract, store)\n      return { metric: m.metric, higherIsBetter: m.higherIsBetter, baseline, candidate }\n    }),\n  )\n  return compareToBaseline(samples, options)\n}\n\nasync function extractAll(\n  runs: Run[],\n  extract: (r: Run, s: TraceStore) => Promise<number | null>,\n  store: TraceStore,\n): Promise<number[]> {\n  const out: number[] = []\n  for (const r of runs) {\n    const v = await extract(r, store)\n    if (v !== null && Number.isFinite(v)) out.push(v)\n  }\n  return out\n}\n","/**\n * StuckLoopView — detects when an agent calls the same tool with the\n * same (or structurally similar) arguments ≥ N times in a short window.\n *\n * Rationale: agents that loop are the number-one production failure\n * mode on long-horizon flows. The view returns (runId, toolName,\n * argHash, occurrences, windowMs) for each detected loop plus a\n * fraction of runs affected.\n */\n\nimport { executionTrackByLane } from '../trace/execution-tracks'\nimport { argHash, hasCapturedToolArgs } from '../trace/query'\nimport { isToolSpan, type Span, type ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\n\nconst DEFAULT_MAX_WINDOW_MS = 60_000\nconst DEFAULT_MAX_INTERVENING_TOOL_CALLS = 0\n\ninterface ScopedToolCall {\n  span: ToolSpan\n  scopeSpanId: string | null\n  laneSpanId: string | null\n}\n\ninterface IndexedToolCall extends ScopedToolCall {\n  toolCallIndex: number\n  trackId: string\n}\n\nexport interface StuckLoopFinding {\n  runId: string\n  toolName: string\n  argHash: string\n  /** Calls in this episode's densest qualifying interval, not the whole-run total. */\n  occurrences: number\n  spanIds: string[]\n  /** Nearest agent ancestor, or the direct parent when ancestry is incomplete. */\n  scopeSpanId?: string\n  /** Milliseconds between first and last call in the loop. */\n  windowMs: number\n}\n\nexport interface StuckLoopReport {\n  findings: StuckLoopFinding[]\n  affectedRunRatio: number\n  totalRuns: number\n}\n\nexport interface StuckLoopOptions {\n  /** Minimum call count to flag a loop (default 3). */\n  minOccurrences?: number\n  /** Maximum time between the first and last repeated call (default 60 seconds). */\n  maxWindowMs?: number\n  /**\n   * Maximum other tool calls allowed between adjacent repeats (default 0).\n   * Set to 1 to detect alternating patterns such as A,B,A,B,A.\n   */\n  maxInterveningToolCalls?: number\n  /** Filter to a specific runId; omit to scan the entire corpus. */\n  runId?: string\n}\n\nexport async function stuckLoopView(\n  store: TraceStore,\n  options: StuckLoopOptions = {},\n): Promise<StuckLoopReport> {\n  const minOccurrences = options.minOccurrences ?? 3\n  const maxWindowMs = options.maxWindowMs ?? DEFAULT_MAX_WINDOW_MS\n  const maxInterveningToolCalls =\n    options.maxInterveningToolCalls ?? DEFAULT_MAX_INTERVENING_TOOL_CALLS\n  if (!Number.isInteger(minOccurrences) || minOccurrences < 1) {\n    throw new RangeError('minOccurrences must be a positive integer')\n  }\n  if (!Number.isFinite(maxWindowMs) || maxWindowMs < 0) {\n    throw new RangeError('maxWindowMs must be a finite non-negative number')\n  }\n  if (!Number.isInteger(maxInterveningToolCalls) || maxInterveningToolCalls < 0) {\n    throw new RangeError('maxInterveningToolCalls must be a non-negative integer')\n  }\n  const runs = options.runId\n    ? [{ runId: options.runId }]\n    : (await store.listRuns()).map((r) => ({ runId: r.runId }))\n\n  const findings: StuckLoopFinding[] = []\n  for (const { runId } of runs) {\n    const spans = await store.spans({ runId })\n    const spansById = new Map(spans.map((span) => [span.spanId, span]))\n    const scopedTools: ScopedToolCall[] = spans\n      .filter(isToolSpan)\n      .map((span, sourceIndex) => ({ span, sourceIndex }))\n      .sort((a, b) => a.span.startedAt - b.span.startedAt || a.sourceIndex - b.sourceIndex)\n      .map(({ span }) => ({ span, ...executionScope(span, spansById) }))\n    const trackByLane = executionTrackByLane(\n      scopedTools.map((call) => {\n        const direct = call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n        const timed = direct\n          ? call.span\n          : call.laneSpanId\n            ? spansById.get(call.laneSpanId)\n            : undefined\n        return {\n          key: executionKey(call),\n          scopeKey: JSON.stringify(call.scopeSpanId),\n          start: timed?.startedAt ?? null,\n          end: timed?.endedAt ?? null,\n        }\n      }),\n    )\n    const nextToolIndexByTrack = new Map<string, number>()\n    const orderedTools: IndexedToolCall[] = scopedTools.map((call) => {\n      const trackId = trackByLane.get(executionKey(call))!\n      const toolCallIndex = nextToolIndexByTrack.get(trackId) ?? 0\n      nextToolIndexByTrack.set(trackId, toolCallIndex + 1)\n      return { ...call, toolCallIndex, trackId }\n    })\n    const byKey = new Map<\n      string,\n      {\n        calls: IndexedToolCall[]\n        argHash: string\n        toolName: string\n        scopeSpanId: string | null\n      }\n    >()\n    for (const call of orderedTools) {\n      if (!hasCapturedToolArgs(call.span)) continue\n      const h = argHash(call.span.args)\n      const key = JSON.stringify([call.trackId, call.span.toolName, h])\n      const bucket = byKey.get(key) ?? {\n        calls: [],\n        argHash: h,\n        toolName: call.span.toolName,\n        scopeSpanId: call.scopeSpanId,\n      }\n      bucket.calls.push(call)\n      byKey.set(key, bucket)\n    }\n    for (const { calls, argHash: h, toolName, scopeSpanId } of byKey.values()) {\n      if (calls.length < minOccurrences) continue\n      let episodeStart = 0\n      for (let episodeEnd = 1; episodeEnd <= calls.length; episodeEnd += 1) {\n        const previous = calls[episodeEnd - 1]!\n        const next = calls[episodeEnd]\n        const episodeEnded =\n          next === undefined ||\n          next.span.startedAt - previous.span.startedAt > maxWindowMs ||\n          next.toolCallIndex - previous.toolCallIndex - 1 > maxInterveningToolCalls ||\n          !callsAreSerial(previous, next)\n        if (!episodeEnded) continue\n\n        const episode = calls.slice(episodeStart, episodeEnd)\n        let left = 0\n        let bestStart = 0\n        let bestEnd = -1\n        for (let right = 0; right < episode.length; right += 1) {\n          while (episode[right]!.span.startedAt - episode[left]!.span.startedAt > maxWindowMs) {\n            left += 1\n          }\n          if (right - left > bestEnd - bestStart) {\n            bestStart = left\n            bestEnd = right\n          }\n        }\n        if (bestEnd - bestStart + 1 >= minOccurrences) {\n          const loop = episode.slice(bestStart, bestEnd + 1)\n          const first = loop[0]!.span.startedAt\n          const last = loop[loop.length - 1]!.span.startedAt\n          findings.push({\n            runId,\n            toolName,\n            argHash: h,\n            occurrences: loop.length,\n            spanIds: loop.map((call) => call.span.spanId),\n            ...(scopeSpanId ? { scopeSpanId } : {}),\n            windowMs: last - first,\n          })\n        }\n        episodeStart = episodeEnd\n      }\n    }\n  }\n\n  const affectedRuns = new Set(findings.map((f) => f.runId))\n  return {\n    findings,\n    affectedRunRatio: runs.length > 0 ? affectedRuns.size / runs.length : 0,\n    totalRuns: runs.length,\n  }\n}\n\nfunction laneKey(call: Pick<ScopedToolCall, 'scopeSpanId' | 'laneSpanId'>): string {\n  return JSON.stringify([call.scopeSpanId, call.laneSpanId])\n}\n\nfunction executionKey(call: ScopedToolCall): string {\n  return call.laneSpanId === null || call.laneSpanId === call.scopeSpanId\n    ? JSON.stringify([call.scopeSpanId, call.span.spanId])\n    : laneKey(call)\n}\n\nfunction executionScope(\n  span: ToolSpan,\n  spansById: ReadonlyMap<string, Span>,\n): { scopeSpanId: string | null; laneSpanId: string | null } {\n  const directParent = span.parentSpanId\n  if (!directParent) return { scopeSpanId: null, laneSpanId: null }\n\n  let currentId: string | undefined = directParent\n  let laneSpanId: string | null = null\n  const seen = new Set<string>()\n  while (currentId && !seen.has(currentId)) {\n    seen.add(currentId)\n    const current = spansById.get(currentId)\n    if (!current) return { scopeSpanId: directParent, laneSpanId: directParent }\n    if (current.kind === 'agent') {\n      return { scopeSpanId: current.spanId, laneSpanId: laneSpanId ?? current.spanId }\n    }\n    laneSpanId = current.spanId\n    currentId = current.parentSpanId\n  }\n  return { scopeSpanId: directParent, laneSpanId: directParent }\n}\n\nfunction callsAreSerial(previous: IndexedToolCall, next: IndexedToolCall): boolean {\n  return previous.span.endedAt !== undefined && previous.span.endedAt <= next.span.startedAt\n}\n"],"mappings":"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"}

package/dist/{prime-protocol-CDBcL9NM.d.ts → prime-protocol-CF8Z43Fj.d.ts}

@@ -1,5 +1,5 @@
 import { b as CustomTokenPricing } from "./cost-ledger-DbQdN3nO.js";
-import { f as AnalystUsageReceipt } from "./types-BjB2wZM9.js";
+import { f as AnalystUsageReceipt } from "./types-DDp2Mb8Y.js";
 import { t as PrimeBridgeTransport } from "./prime-bridge-transport-6feEglLf.js";
 //#region src/analyst/reply-contract.d.ts
 /**
@@ -328,4 +328,4 @@ interface PrimeProtocolIdentity {
 declare function primeProtocolSha256(identity: PrimeProtocolIdentity): string;
 //#endregion
 export { ReplyRowDecoded as A, primeProtocolSha256 as C, DecodedReply as D, runPrimeExchange as E, decodeReplyRows as M, ReplyContract as O, normalizePrimeUsage as S, projectPrimeTrajectory as T, buildPrimePrompt as _, PrimeProjectionOutcome as a, extractPrimeJsonObject as b, PrimeProtocolIdentity as c, PrimeRepairPromptSpec as d, PrimeRepairState as f, analystUsageReceiptFromPrimeUsage as g, PrimeTurnRecord as h, PrimeProjectionDelivery as i, ReplyRowRejection as j, ReplyEnvelope as k, PrimeRawUsage as l, PrimeRowDecoded as m, PrimeExchangeOutcome as n, PrimeProjectionSource as o, PrimeReplyContract as p, PrimeFailure as r, PrimePromptSpec as s, PrimeExchangeOptions as t, PrimeRejectedRow as u, buildPrimeRepairPrompt as v, primeReplyDefect as w, mergePrimeRawUsage as x, emptyPrimeRawUsage as y };
-//# sourceMappingURL=prime-protocol-CDBcL9NM.d.ts.map
+//# sourceMappingURL=prime-protocol-CF8Z43Fj.d.ts.map

package/dist/{prime-protocol-CDBcL9NM.d.ts.map → prime-protocol-CF8Z43Fj.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"prime-protocol-CDBcL9NM.d.ts","names":[],"sources":["../src/analyst/reply-contract.ts","../src/analyst/prime-protocol.ts"],"mappings":";;;;;;;;;;;;;;KAaY,gBAAgB;EAAU;EAAU,KAAK;;EAAW;EAAW;;;UAG1D;EACf;;EAEA,QAAQ;;UAGO,cAAc;;EAE7B;;EAEA;;;;;EAKA;;;;;;EAMA,UAAU,cAAc,gBAAgB,gBAAgB;;;;;;EAMxD;;;;;;EAMA,eAAe,iBAAiB;;;;;;EAMhC;;;;;EAKA;;;UAIe;EACf;EACA;;UAGe,aAAa;EAC5B,MAAM;;EAEN,QAAQ;EACR,UAAU;;EAEV;;EAEA;;;;;;iBAmCc,gBAAgB,MAC9B,UAAU,cAAc,OACxB,iBACC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCjFJ,gBAAgB,QAAQ,gBAAgB;KAExC,mBAAmB,QAAQ,cAAc;UAIpC;EACf;;EAEA;EACA;;EAEA;EACA;;EAEA;;iBAGc,iBAAiB,MAAM;UAatB;EACf;EACA;EACA;;;iBAIc,uBAAuB,MAAM;;;;;;;;;;iBAuB7B,uBAAuB,eAAe;;iBAkBtC,iBACd,QAAQ,gCACR;;;;;;UAyBe;;;;;;EAMf;;EAEA;;EAEA;;;;;;;EAOA;;iBAGc,sBAAsB;;iBAKtB,oBAAoB,eAAe;;;;;;iBAgBnC,mBAAmB,GAAG,eAAe,GAAG,gBAAgB;;;;;;;;;;;;;iBA6BxD,kCACd,OAAO,eACP,SAAS,qBACR;;;;;;;;KAqCS;EAEN;EACA;;EAEA;EAAqB;EAAiB;EAAgB;;EACtD;EAAiB;EAAiB;;UAEvB;EACf;;EAEA;;;UAIe;EACf;EACA,OAAO;;EAEP;;UAGe;EACf;EACA;;KAGU,qBAAqB;EAE3B;;EAEA;EACA,MAAM;EACN,UAAU;;EAEV;;EAEA;EACA,OAAO;EACP,OAAO;EACP,QAAQ;EACR;;EAGA;EACA,SAAS;EACT,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;UAGW,qBAAqB;EACpC,UAAU,mBAAmB;EAC7B;EACA,WAAW;;EAEX;EACA;;EAEA;;EAEA;EACA,SAAS;;;;;;;iBAQW,iBAAiB,MACrC,SAAS,qBAAqB,QAC7B,QAAQ,qBAAqB;;;;;;UAyLf,sBAAsB;;EAErC,QAAQ,iBAAiB;;EAEzB,UAAU,iBAAiB;;EAE3B;;UAGe;EACf;EACA;EACA;;KAGU,uBAAuB;EAE7B;EACA,gBAAgB;EAChB;EACA,UAAU;;EAEV;EAAW;EAAgB;;;;;;;;;iBASX,uBAAuB,OAC3C,QAAQ,sBAAsB,QAC9B;EAAU;IACT,QAAQ,uBAAuB;UA8BjB;EACf;EACA;EACA;EACA;;EAEA,QAAQ,SAAS;;;;;;;;;;;;iBAaH,oBAAoB,UAAU"}
+{"version":3,"file":"prime-protocol-CF8Z43Fj.d.ts","names":[],"sources":["../src/analyst/reply-contract.ts","../src/analyst/prime-protocol.ts"],"mappings":";;;;;;;;;;;;;;KAaY,gBAAgB;EAAU;EAAU,KAAK;;EAAW;EAAW;;;UAG1D;EACf;;EAEA,QAAQ;;UAGO,cAAc;;EAE7B;;EAEA;;;;;EAKA;;;;;;EAMA,UAAU,cAAc,gBAAgB,gBAAgB;;;;;;EAMxD;;;;;;EAMA,eAAe,iBAAiB;;;;;;EAMhC;;;;;EAKA;;;UAIe;EACf;EACA;;UAGe,aAAa;EAC5B,MAAM;;EAEN,QAAQ;EACR,UAAU;;EAEV;;EAEA;;;;;;iBAmCc,gBAAgB,MAC9B,UAAU,cAAc,OACxB,iBACC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCjFJ,gBAAgB,QAAQ,gBAAgB;KAExC,mBAAmB,QAAQ,cAAc;UAIpC;EACf;;EAEA;EACA;;EAEA;EACA;;EAEA;;iBAGc,iBAAiB,MAAM;UAatB;EACf;EACA;EACA;;;iBAIc,uBAAuB,MAAM;;;;;;;;;;iBAuB7B,uBAAuB,eAAe;;iBAkBtC,iBACd,QAAQ,gCACR;;;;;;UAyBe;;;;;;EAMf;;EAEA;;EAEA;;;;;;;EAOA;;iBAGc,sBAAsB;;iBAKtB,oBAAoB,eAAe;;;;;;iBAgBnC,mBAAmB,GAAG,eAAe,GAAG,gBAAgB;;;;;;;;;;;;;iBA6BxD,kCACd,OAAO,eACP,SAAS,qBACR;;;;;;;;KAqCS;EAEN;EACA;;EAEA;EAAqB;EAAiB;EAAgB;;EACtD;EAAiB;EAAiB;;UAEvB;EACf;;EAEA;;;UAIe;EACf;EACA,OAAO;;EAEP;;UAGe;EACf;EACA;;KAGU,qBAAqB;EAE3B;;EAEA;EACA,MAAM;EACN,UAAU;;EAEV;;EAEA;EACA,OAAO;EACP,OAAO;EACP,QAAQ;EACR;;EAGA;EACA,SAAS;EACT,OAAO;EACP,OAAO;EACP,QAAQ;;EAER;;UAGW,qBAAqB;EACpC,UAAU,mBAAmB;EAC7B;EACA,WAAW;;EAEX;EACA;;EAEA;;EAEA;EACA,SAAS;;;;;;;iBAQW,iBAAiB,MACrC,SAAS,qBAAqB,QAC7B,QAAQ,qBAAqB;;;;;;UAyLf,sBAAsB;;EAErC,QAAQ,iBAAiB;;EAEzB,UAAU,iBAAiB;;EAE3B;;UAGe;EACf;EACA;EACA;;KAGU,uBAAuB;EAE7B;EACA,gBAAgB;EAChB;EACA,UAAU;;EAEV;EAAW;EAAgB;;;;;;;;;iBASX,uBAAuB,OAC3C,QAAQ,sBAAsB,QAC9B;EAAU;IACT,QAAQ,uBAAuB;UA8BjB;EACf;EACA;EACA;EACA;;EAEA,QAAQ,SAAS;;;;;;;;;;;;iBAaH,oBAAoB,UAAU"}