@tangle-network/agent-eval 0.136.0 → 0.137.0

package/docs/trace-analysis.md

@@ -1,52 +1,81 @@
 # Trace Analysis
 
-Trace analysis is the bridge between raw product telemetry and useful eval work.
+Trace analysis answers three different questions:
 
-```txt
-live product run
-  -> TraceEmitter / TraceStore
-  -> TraceAnalyst investigates trace corpora
-  -> findings become ASI, failures, replay cases, and release actions
-```
+1. What happened in the run?
+2. Which exact steps support a suspected problem?
+3. Does an analyst find labeled problems reliably enough to use?
+
+Keep those answers separate.
+A generated finding is a review request, not training truth.
+
+## Run The Built-In Analysts
+
+The default registry always includes deterministic checks.
+Model-assisted analysts are added only when you provide a model client.
+
+```ts
+import {
+  buildDefaultAnalystRegistry,
+} from '@tangle-network/agent-eval/analyst'
+import { OtlpFileTraceStore } from '@tangle-network/agent-eval/traces'
+
+const traceStore = new OtlpFileTraceStore({ path: 'traces.otlp.jsonl' })
+const analysts = buildDefaultAnalystRegistry()
+
+const result = await analysts.run('release-42', { traceStore })
 
-## When To Use TraceAnalyst
+for (const finding of result.findings) {
+  console.log(finding.claim, finding.evidence_refs)
+}
+```
 
-Use `TraceAnalyst` when you have more than a few traces and need to answer:
+Use `result.per_analyst` to inspect failures, latency, calls, tokens, and cost.
+An analyst failure is recorded separately from an agent failure.
 
-- which failure modes are recurring?
-- which spans explain a regression?
-- did retrieval, integrations, sandbox, or policy block the run?
-- are failed runs missing evidence that the optimizer needs?
-- which product surfaces deserve the next fix?
+Products can implement `TraceAnalysisStore`; they do not need to use the file store in production.
+Custom stores provide `hasTrace` and batched `hasSpans` alongside the seven reads, and accept a `TraceAnalysisStoreContext` so cancellation reaches storage and scans.
+The binding validates every custom-store result.
+Missing fields, undeclared fields, inconsistent counts, and false continuation flags throw `TraceAnalysisStoreContractError` with code `backend_integrity`.
+The analyst runs one Ax executor loop and accepts only an explicit structured `final(task, { report, findings })` result; max-turn fallback text fails loud.
 
-Use summary tables and release confidence for promotion decisions. Use
-TraceAnalyst to explain the evidence behind those decisions.
+### Bind the same reads into another agent environment
 
-## Minimal Flow
+`buildTraceAnalysisToolDescriptors()` is the canonical definition of the analyst's seven bounded read operations and does not expose Ax types.
+Each descriptor carries the stable `traces` namespace, function name, description, JSON input schema in `parameters`, and a handler already bound to the supplied `TraceAnalysisStore`.
+`buildTraceAnalystTools()` adapts those descriptors into Ax functions; it does not define a second tool surface.
+The bound handlers wrap custom stores with `createBoundedTraceAnalysisStore()`, so page limits, byte ceilings, not-found errors, and cancellation do not depend on the transport or adapter.
 
 ```ts
 import {
-  OtlpFileTraceStore,
-  analyzeTraces,
-} from '@tangle-network/agent-eval'
+  buildTraceAnalysisToolDescriptors,
+  type TraceAnalysisStore,
+} from '@tangle-network/agent-eval/traces'
 
-const abortController = new AbortController()
-const result = await analyzeTraces({
-  question: 'Why did app-runtime holdout runs fail this week?',
-}, {
-  source: new OtlpFileTraceStore({ path: 'traces/otlp.jsonl' }),
-  ai,
-  model: 'gpt-4o-2024-11-20',
-  maxSubqueries: 4,
-  maxParallelSubqueries: 2,
-  signal: abortController.signal,
-})
+declare const store: TraceAnalysisStore
+declare function qualifyToolName(namespace: string, name: string): string
 
-console.log(result.findings)
+const tools = buildTraceAnalysisToolDescriptors({ store }).map(
+  ({ namespace, name, description, parameters, handler }) => ({
+    name: qualifyToolName(namespace, name),
+    description,
+    inputSchema: parameters,
+    handler,
+  }),
+)
 ```
 
-Products can pass any `TraceAnalysisStore`; they do not need to use the file store in production.
-The analyst runs one Ax executor loop and accepts only an explicit structured `final(task, { report, findings })` result; max-turn fallback text fails loud.
+Map these fields into the host's existing tool transport.
+The host owns namespace encoding; use its existing convention instead of inventing one here.
+Do not copy the schemas or reimplement the handlers in an MCP, Runtime, or provider adapter.
+
+`queryTraces.limit`, `viewSpans.span_ids`, and search `max_matches` caps are present in the JSON Schemas and enforced before store calls.
+Invalid arguments throw `TraceAnalysisValidationError` with code `validation`; responses that cannot fit their byte ceiling throw `TraceAnalysisLimitError` with code `limit_exceeded`.
+Search patterns use RE2 syntax, which rejects backreferences and lookaround instead of allowing exponential-time expressions.
+Search results return `hits` and an exact `has_more` flag; they do not invent a total after a capped scan.
+`viewSpans` partitions every requested id across `spans`, `missing_span_ids`, and `omitted_span_ids`; `has_more` is true when omitted ids must be retried.
+Attribute and match text shortening includes a deterministic marker.
+Trace pages set `has_more`, and the overview returns every error cluster or fails explicitly when the configured response limit is too small.
 
 ### Analyze captured tool spans in memory
 
@@ -88,35 +117,322 @@ for (const c of overview.error_clusters) {
 }
 ```
 
-See `failureClusters` in [insight-report.md](./insight-report.md) and the
-`ErrorCluster` type doc-comments for the field-level contract.
+## Recursive control integrity (no LLM)
+
+`CONTROL_INTEGRITY_ANALYST` checks the existing `SupervisorRunSources` or `SupervisorRunTree` directly.
+It does not define another run format.
+Register it as a custom-input analyst and pass the existing value under its stable id:
+
+```ts
+import {
+  AnalystRegistry,
+  CONTROL_INTEGRITY_ANALYST,
+} from '@tangle-network/agent-eval/analyst'
+import {
+  readLoopsSupervisorRun,
+} from '@tangle-network/agent-eval/supervisor-run'
 
-## Required Trace Shape
+const sources = await readLoopsSupervisorRun(runDir)
+const registry = new AnalystRegistry()
+registry.register(CONTROL_INTEGRITY_ANALYST)
+
+const result = await registry.run('run-123', {
+  custom: { 'control-integrity': sources },
+})
+```
+
+Pass `SupervisorRunSources` when it is available.
+A `SupervisorRunTree` does not retain raw journal multiplicity or worker request and acknowledgement rows, so tree input explicitly reports those checks as unavailable.
+
+The deterministic pass can prove only facts represented by these two existing surfaces.
+
+| Question | Current evidence | What the analyst can say |
+|---|---|---|
+| Is every invocation attached to one unambiguous tree? | `rootId`, `rollout_id`, `parent_rollout_id`, `run_id` | Duplicate ids, missing parents, extra parentless roots, cross-run edges, and ancestry cycles are violations with exact field references. |
+| Did invocation roles survive capture? | Explicit journal and `RolloutLine.role` values | The root must remain `supervisor`; non-root roles are consumed as recorded, and workers may spawn workers. |
+| Is the causal order possible? | `outcome.metrics.spawned_at`, `started_at`, `settled_at`, `completed_at`, `finished_at` when present | A child before its parent, a child after its parent closed, or a close before a start is a violation; absent timestamps produce no timing claim. |
+| Did a queued steer reach the worker? | `SupervisorRunSources.workers[].inbox` and `.events` | Requests and acknowledgements are joined by request id, not compared as totals. Missing, malformed, duplicate, or uncorrelated rows make the affected count unavailable. |
+| Can behavior be attributed to an exact profile? | `policy.agent_profile_cell_id` | An absent id is reported as unavailable. |
+| Can action authorship or reasoning be inspected? | `messages[]` | Empty gap rows are reported as unavailable. |
+
+An empty finding list means only that no implemented rule fired on the captured fields.
+It does not certify that an agent chose the action, that the action was authorized, that a budget or depth limit was enforced, or that a finding caused a later decision.
+Those claims require upstream action-decision events carrying `action_id`, `actor_rollout_id`, `target_rollout_id`, `action_kind`, `authority_snapshot_id`, requested and granted resource/depth values, the authorization result, and any `finding_id` or evidence references that caused the action.
+Resume integrity additionally requires an explicit prior-session id and resumed-session id rather than a prose summary.
+
+Malformed source rows are excluded from structural claims.
+Their count is retained in `SupervisorRunTree.gaps`, so analyzing a projected tree later cannot turn an unreadable parent row into a missing-parent violation.
+
+## Add A Custom Analyst
+
+`defineTraceAnalyst()` fills the fixed registry fields.
+The custom function receives the same bounded `TraceAnalysisStore` used by the built-ins.
+
+```ts
+import {
+  AnalystRegistry,
+  defineTraceAnalyst,
+  makeFinding,
+} from '@tangle-network/agent-eval/analyst'
+
+const analysts = new AnalystRegistry()
+
+analysts.register(defineTraceAnalyst({
+  id: 'repeated-tool-errors',
+  description: 'Reports the largest repeated tool error cluster.',
+  cost: { kind: 'deterministic' },
+  async analyze(store) {
+    const overview = await store.getOverview({ has_errors: true })
+    const cluster = overview.error_clusters[0]
+    if (!cluster) return []
+
+    return [makeFinding({
+      analyst_id: 'repeated-tool-errors',
+      area: 'tool-use',
+      subject: cluster.signature,
+      claim: `${cluster.span_count} failed spans share one error`,
+      severity: 'high',
+      confidence: 1,
+      evidence_refs: [{
+        kind: 'span',
+        uri: `trace://${encodeURIComponent(cluster.exemplar_trace_ids[0])}/span/${encodeURIComponent(cluster.exemplar_span_ids[0])}`,
+        excerpt: cluster.status_message_sample,
+      }],
+      recommended_action: 'Fix the highest-frequency tool error before changing prompts.',
+      validation_plan: 'Run fresh cases and require this error signature to disappear.',
+    })]
+  },
+}))
+```
+
+Use code for exact facts such as exit codes, missing fields, and repeated calls.
+Use model-assisted analysts for semantic questions such as whether a response ignored user intent.
+
+## Measure An Analyst
+
+Do not judge an analyst by persuasive prose.
+Label the issue identity and exact evidence locations, then run the same cases through every implementation.
+
+```ts
+import {
+  compareAnalystRunners,
+  registryBenchmarkRunner,
+  renderAnalystBenchmarkMarkdown,
+  runAnalystBenchmark,
+  traceStoreEvidenceResolver,
+} from '@tangle-network/agent-eval/analyst'
 
-Every serious product run should include:
+const benchmark = await runAnalystBenchmark({
+  cases: [{
+    id: 'failed-command',
+    input: { traceStore },
+    expectedIssues: [{
+      id: 'repeated-command',
+      subjects: ['failure-mode:repeated-command'],
+      evidence: [{ kind: 'span', uri: 'trace://run-1/span/tool-3' }],
+      criticalEvidence: [{ kind: 'span', uri: 'trace://run-1/span/tool-1' }],
+    }],
+    labeledEvidence: [
+      { kind: 'span', uri: 'trace://run-1/span/tool-1' },
+      { kind: 'span', uri: 'trace://run-1/span/tool-3' },
+    ],
+  }],
+  runners: [registryBenchmarkRunner({ id: 'built-in', registry: analysts })],
+  repetitions: 3,
+  resolveEvidence: traceStoreEvidenceResolver((input) => input.traceStore),
+  benchmark: {
+    id: 'failure-localization',
+    dataset: {
+      id: 'my-team/trace-failures',
+      revision: 'git-sha-or-content-digest',
+      split: 'test',
+    },
+  },
+})
+
+console.log(renderAnalystBenchmarkMarkdown(benchmark))
+```
+
+The result reports:
+
+- issue recall and finding precision,
+- first bad step accuracy,
+- citation coverage, agreement with labeled locations, and actual location resolution,
+- false positives on clean cases,
+- repeat agreement,
+- failed runs,
+- latency, calls, every reported token counter, and known or missing cost,
+- dataset revision, case tags, case metadata, and runner metadata.
+
+Use `compareAnalystRunners()` for paired differences between two implementations.
+Repetitions are averaged within each case before comparison.
+Treat its interval as inferential only with at least 20 independent cases.
+
+## Load Public Trace Labels
+
+Use the published label adapters with `@tangle-network/traces` or your own trajectory loader.
+Agent Eval does not download datasets or own trace capture.
+Load public data at an immutable commit and record that commit in `benchmark.dataset.revision`.
+
+```ts
+import {
+  agentRxBenchmarkCase,
+  agentRxPredictionsToFindings,
+  codeTraceBenchCase,
+  codeTracerPredictionsToFindings,
+} from '@tangle-network/agent-eval/analyst'
+import { otlpTextToTraceAnalysisStore } from '@tangle-network/agent-eval/traces'
+import { chatTrajectoryToSpans, serializeSpans } from '@tangle-network/traces'
+
+const codeSpans = chatTrajectoryToSpans(codeTraceTrajectory, {
+  traceId: codeTraceRow.traj_id,
+})
+const codeCase = codeTraceBenchCase(codeTraceRow, {
+  traceStore: otlpTextToTraceAnalysisStore(serializeSpans(codeSpans)),
+})
+
+const agentRxSpans = chatTrajectoryToSpans(agentRxMessages, {
+  traceId: String(agentRxRow.trajectory_id),
+  stepMode: 'message',
+})
+const rootCauseCase = agentRxBenchmarkCase(agentRxRow, {
+  traceStore: otlpTextToTraceAnalysisStore(serializeSpans(agentRxSpans)),
+}, {
+  stepCount: agentRxMessages.length,
+})
+
+const codeTracerFindings = codeTracerPredictionsToFindings(
+  codeTraceRow.traj_id,
+  codetracerLabels,
+  { stepCount: codeTraceRow.step_count },
+)
+const agentRxFindings = agentRxPredictionsToFindings(
+  agentRxRow.trajectory_id,
+  agentRxJudgeOutput,
+  { stepCount: agentRxMessages.length },
+)
+```
+
+`codeTraceBenchCase()` accepts the public [CodeTraceBench](https://huggingface.co/datasets/NJU-LINK/CodeTraceBench) JSONL format.
+It scores the published incorrect-step task by default, including clean trajectories.
+Pass `labelSet: 'incorrect-and-unuseful'` to both the case and prediction adapters only for an explicitly combined experiment.
+Every cited step is checked against `step_count`.
+
+`agentRxBenchmarkCase()` accepts the public [AgentRx](https://huggingface.co/datasets/microsoft/AgentRx) label format.
+AgentRx category quality and root-step accuracy are scored independently.
+`traceAnalystQualityJudge` averages them when a root-step label exists.
+Pass `target: 'all-failures'` only when the analyst is designed to identify every annotated failure.
+
+Both adapters emit `trace://<id>/span/step-<n>` evidence by default.
+`@tangle-network/traces` uses the same IDs when converting chat trajectories.
+Pass `stepUri` when your trace store uses another URI scheme.
+`codeTracerPredictionsToFindings()` and `agentRxPredictionsToFindings()` translate the maintained upstream engines' native outputs into the same evidence and category shape.
+AgentRx `Report.to_dict()` judge votes reduce to the upstream majority failure type and Python-rounded mean step, and direct `failures` arrays use the same reduction.
+`failure_case: 0` produces no finding, which scores as a missed root cause on AgentRx's failed trajectories.
+
+## Use Upstream Scorers
+
+Agent Eval adapts upstream evaluators instead of copying them.
+
+```ts
+import { createEvaluator } from '@arizeai/phoenix-evals'
+import { ExactMatch } from 'autoevals'
+import {
+  autoevalsScorerJudge,
+  phoenixEvaluatorJudge,
+} from '@tangle-network/agent-eval/campaign'
+
+const phoenix = createEvaluator(
+  ({ output, expected }) => output === expected ? 1 : 0,
+  { name: 'exact-match', kind: 'CODE', telemetry: { isEnabled: false } },
+)
+
+const phoenixJudge = phoenixEvaluatorJudge(phoenix, {
+  mapInput: ({ artifact, scenario }) => ({ output: artifact, expected: scenario.expected }),
+})
+
+const autoevalsJudge = autoevalsScorerJudge(ExactMatch, {
+  name: 'exact-match',
+  kind: 'CODE',
+  mapInput: ({ artifact, scenario }) => ({ output: artifact, expected: scenario.expected }),
+})
+```
+
+These adapters do not install either upstream package for consumers.
+Install only the scorer package you use.
+Missing or non-finite scores throw instead of becoming passes.
+Phoenix evaluators marked `MINIMIZE` or `NEUTRAL` require `toComposite` so candidate selection never assumes the wrong direction.
+Mark model-backed evaluators as `kind: 'LLM'` and provide `paidCall` with the model and a receipt mapper.
+The campaign then passes its cancellation signal and cost ledger through the adapter.
+An LLM evaluator is rejected before execution when either cost capture or the campaign ledger is missing.
+
+## Turn Reviewed Findings Into Eval Data
+
+Generated findings can populate a review queue.
+They cannot promote themselves into learning data.
+
+```ts
+import {
+  analystFindingDigest,
+  analystRunDigest,
+  analystRunToFeedbackTrajectory,
+  analystRunToReviewRequests,
+} from '@tangle-network/agent-eval'
+
+const runDigest = analystRunDigest(result)
+const requests = analystRunToReviewRequests(result)
+await reviewQueue.add(requests)
+
+declare const acceptedFindingIds: ReadonlySet<string>
+
+const trajectory = analystRunToFeedbackTrajectory(result, {
+  task: { intent: 'Find why the command failed.' },
+  reviewRequests: requests,
+  reviewDecisions: [
+    ...result.findings.map((finding) => ({
+      runDigest,
+      findingId: finding.finding_id,
+      findingDigest: analystFindingDigest(finding),
+      verdict: acceptedFindingIds.has(finding.finding_id) ? 'confirmed' as const : 'rejected' as const,
+      source: 'user' as const,
+      reviewerId: 'reviewer-42',
+      reviewId: 'trace-review-918',
+      reason: 'Reviewed against the cited span.',
+      decidedAt: new Date().toISOString(),
+    })),
+    {
+      runDigest,
+      verdict: 'completeness_assessed',
+      missedIssues: [],
+      source: 'user',
+      reviewerId: 'reviewer-42',
+      reviewId: 'trace-review-918',
+      reason: 'Reviewed the full run for omitted findings.',
+      decidedAt: new Date().toISOString(),
+    },
+  ],
+  trace: { artifactUri: 'traces.otlp.jsonl', traceIds: ['run-1'] },
+})
+```
 
-- `runId`, `projectId`, `scenarioId`, `variantId`, and `layer`
-- commit, prompt hash, config hash, model fingerprint, and dataset version
-- LLM spans with model, inputs, outputs, token counts, and cost
-- tool/integration spans with arguments, result summaries, and error codes
-- retrieval spans with query, source ids, hit scores, and freshness metadata
-- sandbox/build/test/deploy spans with exit codes and log artifacts
-- custom events for knowledge readiness and integration gates
-- final run outcome with pass/score/failure class
+`analystRunToFeedbackTrajectory()` stores review requests separately from labels.
+It can archive an unreviewed run.
+`feedbackTrajectoryToOptimizerRow()` requires every decision to match the complete run digest, every finding decision to match the finding digest, and one independent completeness assessment.
+Its score is F1 over confirmed findings and independently identified misses.
+Generic labels and run-level outcomes do not satisfy these requirements.
 
-Do not put secrets, raw OAuth tokens, or unredacted PII in traces.
+## Required Trace Data
 
-## Product Loop
+Useful analysis needs:
 
-The product loop should not treat traces as a separate debug dump. The intended
-path is:
+- stable run, trace, and span IDs,
+- parent-child links and ordered timestamps,
+- model, prompt, and configuration identity,
+- complete tool names, arguments, results, and error codes,
+- token, cost, and latency data when available,
+- retrieval source IDs and scores when retrieval is involved,
+- final environment outcomes such as tests, task completion, or policy blocks.
 
-1. Wrap the real workflow in `runAgentControlLoop` or the product runtime.
-2. Emit canonical spans/events while the user task runs.
-3. Convert the completed run to `FeedbackTrajectory` for replay.
-4. Convert promotion-grade runs to `RunRecord` with `controlRunToRunRecord`.
-5. Run TraceAnalyst over failure-heavy trace sets.
-6. Feed findings into `ActionableSideInfo`, failure clusters, and release
-   reports.
+Do not include secrets, raw OAuth tokens, or unredacted personal data.
 
-That makes normal product usage become eval data instead of isolated logs.
+Use [`@tangle-network/traces`](https://github.com/tangle-network/traces) to normalize coding-agent sessions, run HALO as an external report engine, or run Hodoscope as a behavior-discovery engine.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.136.0",
+  "version": "0.137.0",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
@@ -171,12 +171,16 @@
     "@tangle-network/agent-core": "0.4.28",
     "@tangle-network/agent-interface": "0.39.0",
     "hono": "^4.12.32",
+    "linear-sum-assignment": "1.0.9",
+    "re2js": "2.8.6",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
+    "@arizeai/phoenix-evals": "^2.1.0",
     "@biomejs/biome": "^2.5.5",
     "@types/node": "^26.1.1",
+    "autoevals": "^0.3.0",
     "esbuild": "^0.28.1",
     "fast-check": "^4.9.0",
     "husky": "^9.1.7",

package/dist/analyst-BkTS3C58.d.ts

@@ -1,89 +0,0 @@
-import { t as TraceAnalysisStore } from "./store-CxJry_cs.js";
-import { AxAIService, AxAgentActorTurnCallbackArgs } from "@ax-llm/ax";
-//#region src/trace-analyst/analyst.d.ts
-interface AnalyzeTracesInput {
-  /** The user-facing question. Domain framing belongs here, not in the
-   *  actor description. */
-  question: string;
-}
-interface AnalyzeTracesResult {
-  /** The actor's submitted prose answer. */
-  answer: string;
-  /** Bulleted findings from the actor's structured completion. */
-  findings: string[];
-  /** Per-turn snapshots captured via `actorTurnCallback`. */
-  turns: AnalyzeTracesTurnSnapshot[];
-  /** Total turns the actor took. */
-  turnCount: number;
-  /** Token usage by role. */
-  usage: TraceAnalystUsage;
-  /** Full system + assistant + tool message log by role. */
-  chatLog: TraceAnalystChatLog;
-  /** Prompt version that produced this run. */
-  actorPromptVersion: string;
-}
-interface TraceAnalystUsage {
-  actor: TraceAnalystUsageEntry[];
-  responder: TraceAnalystUsageEntry[];
-}
-interface TraceAnalystUsageEntry {
-  [key: string]: unknown;
-}
-interface TraceAnalystChatLog {
-  actor: TraceAnalystChatMessage[];
-  responder: TraceAnalystChatMessage[];
-}
-interface TraceAnalystChatMessage {
-  [key: string]: unknown;
-}
-interface AnalyzeTracesTurnSnapshot {
-  stage: AxAgentActorTurnCallbackArgs['stage'];
-  turn: number;
-  isError: boolean;
-  /** The JS code the actor produced for this turn. */
-  code: string;
-  /** The formatted action-log entry the actor sees on the next turn. */
-  output: string;
-  /** Provider thought (when `executorOptions.showThoughts` is true and the
-   *  provider returns it). */
-  thought?: string;
-}
-interface AnalyzeTracesOptions {
-  /** Trace data source. Pass either an OTLP-JSONL path or a custom store. */
-  source: string | TraceAnalysisStore;
-  /** Caller-provided AxAIService. */
-  ai: AxAIService;
-  /** Model id forwarded to the actor. */
-  model?: string;
-  /** Maximum model subqueries. 0 disables model fan-out. Default 4. */
-  maxSubqueries?: number;
-  /** Maximum actor turns. Default 12. */
-  maxTurns?: number;
-  /** Maximum parallel model subqueries. Default 2. */
-  maxParallelSubqueries?: number;
-  /** Cancels in-flight model and tool work. */
-  signal?: AbortSignal;
-  /** Override the actor description. */
-  actorDescription?: string;
-  /** Per-turn observability hook. */
-  onTurn?: (turn: AnalyzeTracesTurnSnapshot) => void | Promise<void>;
-  /** Override max runtime characters per turn. Default 6000. */
-  maxRuntimeChars?: number;
-  /** When set, every turn's snapshot is appended to this JSONL file
-   *  immediately. If the analyst crashes mid-loop (provider 503,
-   *  network error, validator reject) the partial reasoning is still
-   *  on disk for diagnosis and recovery. */
-  progressLogPath?: string;
-}
-/**
- * Run the trace analyst.
- *
- * Throws:
- *   - `TraceFileMissingError` if `source` is a path and doesn't exist.
- *   - `AxAgentClarificationError` if the analyst asks for clarification.
- *   - Provider errors (auth, rate limits) propagate from the AI service.
- */
-declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
-//#endregion
-export { analyzeTraces as a, AnalyzeTracesTurnSnapshot as i, AnalyzeTracesOptions as n, AnalyzeTracesResult as r, AnalyzeTracesInput as t };
-//# sourceMappingURL=analyst-BkTS3C58.d.ts.map

package/dist/analyst-BkTS3C58.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyst-BkTS3C58.d.ts","names":[],"sources":["../src/trace-analyst/analyst.ts"],"mappings":";;;UAOiB;;;EAGf;;UAGe;;EAEf;;EAEA;;EAEA,OAAO;;EAEP;;EAEA,OAAO;;EAEP,SAAS;;EAET;;UAGe;EACf,OAAO;EACP,WAAW;;UAGI;GACd;;UAGc;EACf,OAAO;EACP,WAAW;;UAGI;GACd;;UAGc;EACf,OAAO;EACP;EACA;;EAEA;;EAEA;;;EAGA;;UAGe;;EAEf,iBAAiB;;EAEjB,IAAI;;EAEJ;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET;;EAEA,UAAU,MAAM,qCAAqC;;EAErD;;;;;EAKA;;;;;;;;;;iBAWoB,cACpB,OAAO,oBACP,SAAS,uBACR,QAAQ"}