@tangle-network/traces 0.8.18 → 0.8.19

package/README.md

@@ -104,7 +104,8 @@ traces inspect  session-index.json --out inspection-report.md
 traces evidence --harness codex --last 20 --out policy-evidence.jsonl
 traces export   policy-evidence.jsonl --out spans.openinference.jsonl
 traces watch    --all                              # live observer; loops + semantic findings
-traces stream   --all --no-spans                   # live JSONL events for dashboards/visualizers
+traces stream   --all --mode findings              # low-volume semantic feed
+traces stream   --all --mode agent                 # findings + deterministic report events
 traces stream   spans.openinference.jsonl --format openinference --no-spans
 traces upload   --since 1h --dry-run               # redact + dedup + preview, no network
 traces upload   --since 24h                        # upload last day to the Intelligence Platform
@@ -123,9 +124,10 @@ traces upload   --since 24h                        # upload last day to the Inte
 | `--otlp <path>` | OTLP artifact path (also evidence provenance / dry-run upload preview) |
 | `--format <kind>` | `export` / file `stream`: `auto`, `policy-evidence`, `sandbox-events`, or `openinference` |
 | `--llm` / `--budget <usd>` | Enable agentic analysts (needs `OPENAI_API_KEY`) / cap their spend |
-| `--config <path>` | `investigate` / `improve`: load BYO analysts, external analyzers, and proposal adapters |
+| `--config <path>` | `investigate` / `improve` / `stream`: load BYO analysts, live analysts, external analyzers, and proposal adapters |
 | `--interval <s>` / `--window <m>` | `watch` / live `stream`: poll seconds (default 5) / active-session window minutes (default 30) |
 | `--min-loop <n>` | Identical repeated calls before flagging a loop (default 3) |
+| `--mode <kind>` | `stream`: `visualizer` (spans + findings), `findings` (low-volume), or `agent` (findings + reports) |
 | `--replay` / `--once` | `stream`: scan once, then exit |
 | `--no-spans` / `--no-findings` | `stream`: suppress raw span rows / finding rows |
 | `--no-content` | `upload`: send metadata only — strip all prompt/response text |
@@ -141,13 +143,15 @@ It emits newline-delimited JSON events that a dashboard, art visualizer, local w
 
 ```bash
 traces stream --all
-traces stream --all --no-spans
+traces stream --all --mode findings
+traces stream --all --mode agent --config traces.config.mjs
 traces stream spans.openinference.jsonl --format openinference --no-spans
 ```
 
-The stream emits `session`, `span`, `analysis_batch`, `finding`, and `tick` events.
+Live streaming emits `session`, `span`, `analysis_batch`, `finding`, and `tick` events; `--mode agent` also emits `report` events.
 The semantic findings currently cover repeated failing commands, verification churn without code/config changes, completion claims without later verification, and high tool-error rates.
-Use `--no-spans` when you want the low-volume meaning layer; keep spans on for real-time visualizers that need motion, timing, and tool-call texture.
+Use `--mode findings` when you want the low-volume meaning layer; keep `visualizer` for real-time views that need motion, timing, and tool-call texture.
+Use `--mode agent` when another agent needs deterministic loop/tool-use reports alongside the findings.
 
 ## Improvement engine
 
@@ -177,6 +181,7 @@ traces improve --last 5 --config examples/improvement-config.mjs --dir .traces/i
 The config can export:
 
 - `analysts`: deterministic or LLM analysts that implement the `agent-eval` `Analyst` contract
+- `liveAnalysts`: deterministic online analysts that implement the `TraceLiveAnalyst` contract for `traces stream`
 - `registry`: a prebuilt `AnalystRegistry`
 - `externalAnalyzers`: HALO or any command/model adapter that reads the OTLP artifact
 - `improvementAdapter`: a proposal writer that maps recommendations to patches, profile edits, prompts, or validation commands
@@ -317,6 +322,8 @@ The CLI is a thin consumer of these exports.
 | `streamSessions` | `(TraceStreamOptions) → Promise<void>` | live JSONL-ready event stream over active sessions |
 | `traceStreamEventsFromSpans` | `(spans, opts?) → TraceStreamEvent[]` | replay an existing span list as stream events |
 | `analyzeLiveBatch` | `(spans, opts?) → TraceLiveBatch` | compute semantic online findings for one batch |
+| `classifyLiveActions` | `(spans) → TraceLiveAction[]` | classify spans once as read/edit/verify/claim/tool/other |
+| `defaultTraceLiveAnalysts` | `TraceLiveAnalyst[]` | the built-in online analysts; extend or replace them |
 | `collectSessionIndex` | `(ScanOptions) → TraceSessionIndex` | scan sessions and return a reusable JSON-ready catalog |
 | `inspectSessionIndex` | `(TraceSessionIndex) → TraceInspectionReport` | rank improvement findings from an index without rescanning sessions |
 | `buildPolicyEvidenceRecord` | `(ref, spans, opts?) → PolicyEvidenceRecord` | summarize one session for downstream policy mining |

package/dist/{chunk-G3OBZSWY.js → chunk-FCTZLWP7.js}

@@ -4297,6 +4297,36 @@ function isChange(span2) {
   if (!isTool(span2)) return false;
   return CHANGE_RE.test(`${toolName2(span2)} ${span2.name} ${spanContent(span2)}`);
 }
+function isRead(span2) {
+  if (!isTool(span2)) return false;
+  return /\b(read|cat|less|grep|rg|sed -n|nl|ls|find|git show|git diff)\b/i.test(`${toolName2(span2)} ${span2.name} ${spanContent(span2)}`);
+}
+function actionKind(span2) {
+  if (isVerification(span2)) return "verify";
+  if (isChange(span2)) return "edit";
+  if (isRead(span2)) return "read";
+  if (isTool(span2)) return "tool";
+  if (isTextSpan(span2) && CLAIM_DONE_RE.test(spanContent(span2))) return "claim";
+  return "other";
+}
+function classifyLiveActions(spans) {
+  return orderSpans(spans).map((span2) => {
+    const tool = isTool(span2) ? toolName2(span2) : void 0;
+    return {
+      kind: actionKind(span2),
+      spanId: span2.span_id,
+      span: span2,
+      ...tool ? { toolName: tool } : {},
+      signature: toolSignature(span2),
+      errored: span2.status.code === "ERROR"
+    };
+  });
+}
+function actionCounts(actions) {
+  const counts = { tool: 0, read: 0, edit: 0, verify: 0, claim: 0, other: 0 };
+  for (const action of actions) counts[action.kind] += 1;
+  return counts;
+}
 function timeOf(span2) {
   const parsed = Date.parse(span2.start_time);
   return Number.isFinite(parsed) ? parsed : 0;
@@ -4339,54 +4369,52 @@ function finding(input) {
     observedAt: input.observedAt
   };
 }
-function analyzeLiveBatch(spans, opts = {}) {
-  const ordered2 = orderSpans(spans);
-  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const session = sessionFrom(ordered2, opts);
-  const tools = ordered2.filter(isTool);
-  const erroredTools = tools.filter((span2) => span2.status.code === "ERROR");
-  const verificationCalls = tools.filter(isVerification);
-  const changeCalls = tools.filter(isChange);
-  const findings = [];
-  const failedBySignature = /* @__PURE__ */ new Map();
-  for (const span2 of erroredTools) {
-    const signature = toolSignature(span2);
-    failedBySignature.set(signature, [...failedBySignature.get(signature) ?? [], span2]);
-  }
-  for (const [signature, rows] of failedBySignature) {
-    if (rows.length < 2) continue;
-    findings.push(finding({
-      ruleId: "same-failing-command",
-      severity: rows.length >= 3 ? "high" : "medium",
-      title: "Same failing command is repeating",
-      claim: `${rows.length} failed tool call(s) repeated the same command or arguments.`,
-      action: "Stop rerunning it; inspect the first failure, change state, or choose a different diagnostic path before another retry.",
-      check: "The next action should read the failing file, inspect the stack/output, or edit code before this command runs again.",
-      evidence: [
-        evidence2("pattern", "command", signature, rows.map((span2) => span2.span_id)),
-        evidence2("metric", "failed_repeats", String(rows.length))
-      ],
-      session,
-      observedAt: generatedAt,
-      signature: [signature, String(rows.length)]
-    }));
-  }
-  let lastChangeIndex = -1;
-  let verificationSinceChange = 0;
-  const verificationSpanIds = [];
-  for (let i = 0; i < ordered2.length; i++) {
-    const span2 = ordered2[i];
-    if (isChange(span2)) {
-      lastChangeIndex = i;
-      verificationSinceChange = 0;
-      verificationSpanIds.length = 0;
-    } else if (isVerification(span2)) {
-      verificationSinceChange += 1;
-      verificationSpanIds.push(span2.span_id);
+var sameFailingCommandAnalyst = {
+  id: "same-failing-command",
+  analyze(context) {
+    const findings = [];
+    const failedBySignature = /* @__PURE__ */ new Map();
+    for (const action of context.actions) {
+      if (!action.toolName || !action.errored) continue;
+      failedBySignature.set(action.signature, [...failedBySignature.get(action.signature) ?? [], action.span]);
+    }
+    for (const [signature, rows] of failedBySignature) {
+      if (rows.length < 2) continue;
+      findings.push(finding({
+        ruleId: "same-failing-command",
+        severity: rows.length >= 3 ? "high" : "medium",
+        title: "Same failing command is repeating",
+        claim: `${rows.length} failed tool call(s) repeated the same command or arguments.`,
+        action: "Stop rerunning it; inspect the first failure, change state, or choose a different diagnostic path before another retry.",
+        check: "The next action should read the failing file, inspect the stack/output, or edit code before this command runs again.",
+        evidence: [
+          evidence2("pattern", "command", signature, rows.map((span2) => span2.span_id)),
+          evidence2("metric", "failed_repeats", String(rows.length))
+        ],
+        session: context.session,
+        observedAt: context.generatedAt,
+        signature: [signature, String(rows.length)]
+      }));
     }
+    return findings;
   }
-  if (verificationSinceChange >= 2) {
-    findings.push(finding({
+};
+var verificationWithoutChangeAnalyst = {
+  id: "verification-without-change",
+  analyze(context) {
+    let verificationSinceChange = 0;
+    const verificationSpanIds = [];
+    for (const action of context.actions) {
+      if (action.kind === "edit") {
+        verificationSinceChange = 0;
+        verificationSpanIds.length = 0;
+      } else if (action.kind === "verify") {
+        verificationSinceChange += 1;
+        verificationSpanIds.push(action.spanId);
+      }
+    }
+    if (verificationSinceChange < 2) return [];
+    return [finding({
       ruleId: "verification-without-change",
       severity: verificationSinceChange >= 3 ? "high" : "medium",
       title: "Verification is repeating without a state change",
@@ -4395,51 +4423,89 @@ function analyzeLiveBatch(spans, opts = {}) {
       check: "The next action should be a code/config edit, targeted file read, or a different narrow diagnostic command.",
       evidence: [
         evidence2("metric", "verification_calls_since_change", String(verificationSinceChange), verificationSpanIds),
-        evidence2("metric", "change_calls", String(changeCalls.length))
+        evidence2("metric", "change_calls", String(context.changeActions.length))
       ],
-      session,
-      observedAt: generatedAt,
+      session: context.session,
+      observedAt: context.generatedAt,
       signature: [String(verificationSinceChange), verificationSpanIds.join(",")]
-    }));
+    })];
   }
-  const lastClaim = [...ordered2].reverse().find((span2) => isTextSpan(span2) && CLAIM_DONE_RE.test(spanContent(span2)));
-  if (lastClaim) {
-    const claimTime = timeOf(lastClaim);
-    const verificationAfterClaim = verificationCalls.some((span2) => timeOf(span2) > claimTime);
-    if (!verificationAfterClaim) {
-      findings.push(finding({
-        ruleId: "completion-claim-without-verification",
-        severity: "medium",
-        title: "Completion claim has no later verification",
-        claim: "The agent claimed completion, correctness, or verification without a later verification tool call in the observed trace.",
-        action: "Require a concrete check after the claim, or downgrade the claim to an unverified hypothesis.",
-        check: "A later test/build/typecheck/lint/smoke command should appear after the claim.",
-        evidence: [
-          evidence2("span", "claim_span", spanContent(lastClaim).slice(0, 240), [lastClaim.span_id]),
-          evidence2("metric", "verification_after_claim", "0")
-        ],
-        session,
-        observedAt: generatedAt,
-        signature: [lastClaim.span_id, spanContent(lastClaim).slice(0, 120)]
-      }));
-    }
+};
+var completionClaimWithoutVerificationAnalyst = {
+  id: "completion-claim-without-verification",
+  analyze(context) {
+    const lastClaim = [...context.actions].reverse().find((action) => action.kind === "claim");
+    if (!lastClaim) return [];
+    const claimTime = timeOf(lastClaim.span);
+    const verificationAfterClaim = context.verificationActions.some((action) => timeOf(action.span) > claimTime);
+    if (verificationAfterClaim) return [];
+    return [finding({
+      ruleId: "completion-claim-without-verification",
+      severity: "medium",
+      title: "Completion claim has no later verification",
+      claim: "The agent claimed completion, correctness, or verification without a later verification tool call in the observed trace.",
+      action: "Require a concrete check after the claim, or downgrade the claim to an unverified hypothesis.",
+      check: "A later test/build/typecheck/lint/smoke command should appear after the claim.",
+      evidence: [
+        evidence2("span", "claim_span", spanContent(lastClaim.span).slice(0, 240), [lastClaim.spanId]),
+        evidence2("metric", "verification_after_claim", "0")
+      ],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [lastClaim.spanId, spanContent(lastClaim.span).slice(0, 120)]
+    })];
   }
-  if (tools.length >= 4 && erroredTools.length / tools.length >= 0.5) {
-    findings.push(finding({
+};
+var highToolErrorRateAnalyst = {
+  id: "high-tool-error-rate",
+  analyze(context) {
+    if (context.tools.length < 4 || context.erroredTools.length / context.tools.length < 0.5) return [];
+    return [finding({
       ruleId: "high-tool-error-rate",
-      severity: erroredTools.length / tools.length >= 0.75 ? "high" : "medium",
+      severity: context.erroredTools.length / context.tools.length >= 0.75 ? "high" : "medium",
       title: "Tool calls are mostly failing",
-      claim: `${erroredTools.length}/${tools.length} tool call(s) in this live batch ended with ERROR.`,
+      claim: `${context.erroredTools.length}/${context.tools.length} tool call(s) in this live batch ended with ERROR.`,
       action: "Switch from broad execution to diagnosis: classify the dominant error, then run one targeted command to validate the fix path.",
       check: "The next batch should reduce the error ratio or show a new targeted diagnostic result.",
       evidence: [
-        evidence2("metric", "errored_tool_calls", `${erroredTools.length}/${tools.length}`, erroredTools.map((span2) => span2.span_id))
+        evidence2("metric", "errored_tool_calls", `${context.erroredTools.length}/${context.tools.length}`, context.erroredTools.map((span2) => span2.span_id))
       ],
-      session,
-      observedAt: generatedAt,
-      signature: [String(erroredTools.length), String(tools.length)]
-    }));
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [String(context.erroredTools.length), String(context.tools.length)]
+    })];
   }
+};
+var defaultTraceLiveAnalysts = [
+  sameFailingCommandAnalyst,
+  verificationWithoutChangeAnalyst,
+  completionClaimWithoutVerificationAnalyst,
+  highToolErrorRateAnalyst
+];
+function liveAnalysts(opts) {
+  return [...opts.analysts ?? defaultTraceLiveAnalysts, ...opts.extraAnalysts ?? []];
+}
+function analyzeLiveBatch(spans, opts = {}) {
+  const ordered2 = orderSpans(spans);
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const session = sessionFrom(ordered2, opts);
+  const actions = classifyLiveActions(ordered2);
+  const tools = ordered2.filter(isTool);
+  const erroredTools = tools.filter((span2) => span2.status.code === "ERROR");
+  const verificationActions = actions.filter((action) => action.kind === "verify");
+  const changeActions = actions.filter((action) => action.kind === "edit");
+  const context = {
+    spans: ordered2,
+    actions,
+    tools,
+    erroredTools,
+    verificationActions,
+    changeActions,
+    session,
+    generatedAt,
+    newSpanCount: opts.newSpanCount ?? ordered2.length
+  };
+  const findings = liveAnalysts(opts).flatMap((analyst) => [...analyst.analyze(context)]);
   return {
     schemaVersion: 1,
     kind: "traces.live_batch",
@@ -4449,8 +4515,9 @@ function analyzeLiveBatch(spans, opts = {}) {
     newSpanCount: opts.newSpanCount ?? ordered2.length,
     toolCallCount: tools.length,
     erroredToolCallCount: erroredTools.length,
-    verificationCallCount: verificationCalls.length,
-    changeCallCount: changeCalls.length,
+    verificationCallCount: verificationActions.length,
+    changeCallCount: changeActions.length,
+    actionCounts: actionCounts(actions),
     findingCount: findings.length,
     findings
   };
@@ -4475,14 +4542,20 @@ function traceStreamEventsFromSpans(spans, opts = {}) {
     session: opts.ref ? { harness: opts.ref.harness, sessionId: opts.ref.sessionId, cwd: opts.ref.cwd, path: opts.ref.path } : opts.session
   });
   const ordered2 = orderSpans(spans);
-  const batch = analyzeLiveBatch(ordered2, { generatedAt, session, newSpanCount: ordered2.length });
+  const batch = analyzeLiveBatch(ordered2, {
+    generatedAt,
+    session,
+    newSpanCount: ordered2.length,
+    analysts: opts.analysts,
+    extraAnalysts: opts.extraAnalysts
+  });
   const events = [sessionEvent(session, ordered2, generatedAt)];
   if (opts.includeSpans !== false) {
     for (const span2 of ordered2) {
       events.push({ schemaVersion: 1, kind: "traces.stream.span", event: "span", generatedAt, session, span: span2 });
     }
   }
-  events.push({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, batch });
+  events.push({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, ref: opts.ref, batch });
   if (opts.includeFindings !== false) {
     for (const liveFinding of batch.findings) {
       events.push({ schemaVersion: 1, kind: "traces.stream.finding", event: "finding", generatedAt, finding: liveFinding });
@@ -4494,12 +4567,24 @@ function serializeTraceStreamEvent(event) {
   return `${JSON.stringify(event)}
 `;
 }
+function loopsFromReport(session, report) {
+  return report.stuckLoops.findings.map((loop) => ({
+    harness: session.harness,
+    sessionId: session.sessionId,
+    cwd: session.cwd,
+    toolName: loop.toolName,
+    argHash: loop.argHash,
+    occurrences: loop.occurrences,
+    windowMs: loop.windowMs
+  }));
+}
 async function streamSessions(opts) {
   const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
   const windowMs = opts.windowMs ?? 30 * 6e4;
   const includeSpans = opts.includeSpans !== false;
   const includeFindings = opts.includeFindings !== false;
   const includeBatches = opts.includeBatches !== false;
+  const includeReports = opts.includeReports === true;
   const seenSessions = /* @__PURE__ */ new Set();
   const seenSpans = /* @__PURE__ */ new Set();
   const seenFindings = /* @__PURE__ */ new Set();
@@ -4533,9 +4618,31 @@ async function streamSessions(opts) {
           await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.span", event: "span", generatedAt, session, span: span2 });
         }
       }
-      const batch = analyzeLiveBatch(ordered2, { generatedAt, session, newSpanCount: unseen.length });
+      const batch = analyzeLiveBatch(ordered2, {
+        generatedAt,
+        session,
+        newSpanCount: unseen.length,
+        extraAnalysts: opts.extraAnalysts
+      });
       if (includeBatches) {
-        await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, batch });
+        await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, ref, batch });
+      }
+      if (includeReports) {
+        try {
+          const report = await runPipelines(ordered2, { minLoopOccurrences: opts.minLoopOccurrences });
+          await opts.onEvent({
+            schemaVersion: 1,
+            kind: "traces.stream.report",
+            event: "report",
+            generatedAt,
+            session,
+            ref,
+            report,
+            loops: loopsFromReport(session, report)
+          });
+        } catch (err) {
+          opts.onError?.(err, ref);
+        }
       }
       if (includeFindings) {
         for (const liveFinding of batch.findings) {
@@ -4561,107 +4668,52 @@ async function streamSessions(opts) {
 }
 
 // src/observer.ts
-var sleep2 = (ms, signal) => new Promise((resolve2) => {
-  if (signal?.aborted) {
-    resolve2();
-    return;
+function loopKey(loop) {
+  return `${loop.sessionId}:${loop.toolName}:${loop.argHash}`;
+}
+async function callSafely(ref, onError, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    onError?.(err, ref);
   }
-  const onAbort = () => {
-    clearTimeout(t);
-    resolve2();
-  };
-  const t = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve2();
-  }, ms);
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-function loopKey(sessionId, toolName3, argHash) {
-  return `${sessionId}:${toolName3}:${argHash}`;
 }
 async function watchSessions(opts) {
-  const windowMs = opts.windowMs ?? 30 * 6e4;
-  const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
-  const minLoop = opts.minLoopOccurrences ?? 3;
-  const seen = /* @__PURE__ */ new Map();
-  const seenFindings = /* @__PURE__ */ new Set();
-  while (!opts.signal?.aborted) {
-    let sessionCount = 0;
-    for await (const { adapter, ref, spans } of scanSessions({
-      adapters: opts.adapters,
-      all: opts.all,
-      harnesses: opts.harnesses,
-      cwd: opts.cwd,
-      sinceMs: Date.now() - windowMs,
-      signal: opts.signal,
-      onError: opts.onError
-    })) {
-      let report;
-      try {
-        report = await runPipelines(spans, { minLoopOccurrences: minLoop });
-      } catch (err) {
-        opts.onError?.(err, ref);
-        continue;
-      }
-      sessionCount += 1;
-      if (opts.onReport) {
-        try {
-          await opts.onReport(ref, report);
-        } catch (err) {
-          opts.onError?.(err, ref);
+  const seenLoops = /* @__PURE__ */ new Map();
+  await streamSessions({
+    adapters: opts.adapters,
+    all: opts.all,
+    harnesses: opts.harnesses,
+    cwd: opts.cwd,
+    windowMs: opts.windowMs,
+    intervalMs: opts.intervalMs,
+    minLoopOccurrences: opts.minLoopOccurrences,
+    signal: opts.signal,
+    includeSpans: false,
+    includeBatches: Boolean(opts.onBatch),
+    includeFindings: Boolean(opts.onFinding),
+    includeReports: Boolean(opts.onReport || opts.onLoop),
+    onError: opts.onError,
+    onEvent: async (event) => {
+      if (event.event === "analysis_batch") {
+        if (event.ref) {
+          await callSafely(event.ref, opts.onError, () => opts.onBatch?.(event.ref, event.batch));
         }
-      }
-      const batch = analyzeLiveBatch(spans, {
-        session: { harness: adapter.harness, sessionId: ref.sessionId, cwd: ref.cwd, path: ref.path }
-      });
-      if (opts.onBatch) {
-        try {
-          await opts.onBatch(ref, batch);
-        } catch (err) {
-          opts.onError?.(err, ref);
-        }
-      }
-      if (opts.onFinding) {
-        for (const finding2 of batch.findings) {
-          if (seenFindings.has(finding2.id)) continue;
-          seenFindings.add(finding2.id);
-          try {
-            await opts.onFinding(finding2);
-          } catch (err) {
-            opts.onError?.(err, ref);
-          }
-        }
-      }
-      for (const f of report.stuckLoops.findings) {
-        const key = loopKey(ref.sessionId, f.toolName, f.argHash);
-        if (f.occurrences > (seen.get(key) ?? 0)) {
-          seen.set(key, f.occurrences);
-          if (opts.onLoop) {
-            try {
-              await opts.onLoop({
-                harness: adapter.harness,
-                sessionId: ref.sessionId,
-                cwd: ref.cwd,
-                toolName: f.toolName,
-                argHash: f.argHash,
-                occurrences: f.occurrences,
-                windowMs: f.windowMs
-              });
-            } catch (err) {
-              opts.onError?.(err, ref);
-            }
-          }
+      } else if (event.event === "finding") {
+        await callSafely(void 0, opts.onError, () => opts.onFinding?.(event.finding));
+      } else if (event.event === "report") {
+        await callSafely(event.ref, opts.onError, () => opts.onReport?.(event.ref, event.report));
+        for (const loop of event.loops) {
+          const key = loopKey(loop);
+          if (loop.occurrences <= (seenLoops.get(key) ?? 0)) continue;
+          seenLoops.set(key, loop.occurrences);
+          await callSafely(event.ref, opts.onError, () => opts.onLoop?.(loop));
         }
+      } else if (event.event === "tick") {
+        await callSafely(void 0, opts.onError, () => opts.onTick?.({ sessions: event.sessions }));
       }
     }
-    try {
-      opts.onTick?.({ sessions: sessionCount });
-    } catch (err) {
-      opts.onError?.(err);
-    }
-    if (opts.signal?.aborted) break;
-    await sleep2(intervalMs, opts.signal);
-  }
+  });
 }
 
 // src/session-index.ts
@@ -5140,6 +5192,8 @@ export {
   writeTraceImprovementArtifacts,
   runTraceImprovementLoop,
   saveReport,
+  classifyLiveActions,
+  defaultTraceLiveAnalysts,
   analyzeLiveBatch,
   traceStreamEventsFromSpans,
   serializeTraceStreamEvent,

package/dist/cli.js

@@ -43,7 +43,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-G3OBZSWY.js";
+} from "./chunk-FCTZLWP7.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
@@ -119,6 +119,9 @@ function parseArgs(argv) {
       case "--config":
         a.config = next();
         break;
+      case "--mode":
+        a.mode = next();
+        break;
       case "--metadata":
         a.metadata = next();
         break;
@@ -519,10 +522,26 @@ function formatLiveFinding(finding) {
     `  check: ${finding.check}`
   ].join("\n");
 }
-async function streamExplicitSession(args) {
+function streamMode(raw) {
+  if (raw === void 0) return "visualizer";
+  if (raw === "visualizer" || raw === "findings" || raw === "agent") return raw;
+  throw new Error(`unknown stream mode "${raw}" (expected visualizer, findings, or agent)`);
+}
+function streamPreset(args) {
+  const mode = streamMode(args.mode);
+  return {
+    mode,
+    includeSpans: !args.noSpans && mode === "visualizer",
+    includeFindings: !args.noFindings,
+    includeBatches: true,
+    includeReports: mode === "agent"
+  };
+}
+async function streamExplicitSession(args, extraAnalysts) {
   if (!args.session) throw new Error("streamExplicitSession needs --session");
   const adapter = resolveAdapter(args.harness);
   if (!adapter) throw new Error(`unknown harness "${args.harness}"`);
+  const preset = streamPreset(args);
   const st = await stat(args.session);
   const ref = {
     harness: adapter.harness,
@@ -534,13 +553,16 @@ async function streamExplicitSession(args) {
   const spans = await parseSession(adapter, ref);
   for (const event of traceStreamEventsFromSpans(spans, {
     ref,
-    includeSpans: !args.noSpans,
-    includeFindings: !args.noFindings
+    includeSpans: preset.includeSpans,
+    includeFindings: preset.includeFindings,
+    extraAnalysts
   })) {
     process.stdout.write(serializeTraceStreamEvent(event));
   }
 }
 async function cmdStream(args) {
+  const config = await loadTracesConfig(args.config);
+  const preset = streamPreset(args);
   if (args.input) {
     const { spans, harness } = await collectImportedSpans(args);
     const ref = {
@@ -552,15 +574,16 @@ async function cmdStream(args) {
     };
     for (const event of traceStreamEventsFromSpans(spans, {
       ref,
-      includeSpans: !args.noSpans,
-      includeFindings: !args.noFindings
+      includeSpans: preset.includeSpans,
+      includeFindings: preset.includeFindings,
+      extraAnalysts: config?.liveAnalysts
     })) {
       process.stdout.write(serializeTraceStreamEvent(event));
     }
     return;
   }
   if (args.session) {
-    await streamExplicitSession(args);
+    await streamExplicitSession(args, config?.liveAnalysts);
     return;
   }
   const all = args.all || !args.harnessExplicit && !args.cwd;
@@ -568,7 +591,7 @@ async function cmdStream(args) {
   process.once("SIGINT", () => controller.abort());
   if (!args.replay) {
     process.stderr.write(
-      `traces stream \u2014 JSONL live feed for ${all ? "all harnesses" : args.harness}, last ${args.window}m, every ${args.interval}s. Ctrl-C to stop.
+      `traces stream \u2014 ${preset.mode} JSONL feed for ${all ? "all harnesses" : args.harness}, last ${args.window}m, every ${args.interval}s. Ctrl-C to stop.
 `
     );
   }
@@ -580,8 +603,11 @@ async function cmdStream(args) {
     windowMs: args.window * 6e4,
     intervalMs: args.interval * 1e3,
     once: args.replay,
-    includeSpans: !args.noSpans,
-    includeFindings: !args.noFindings,
+    includeSpans: preset.includeSpans,
+    includeFindings: preset.includeFindings,
+    includeBatches: preset.includeBatches,
+    includeReports: preset.includeReports,
+    extraAnalysts: config?.liveAnalysts,
     signal: controller.signal,
     onEvent: (event) => {
       process.stdout.write(serializeTraceStreamEvent(event));
@@ -735,12 +761,13 @@ Options:
   --format <kind>  analyze/export file: auto | policy-evidence | sandbox-events | openinference | intelligence-spans
   --metadata <json> analyze/export file: attach JSON object fields as span attributes
   --attr <k=v>     analyze/export file: attach one span attribute (repeatable)
+  --mode <kind>    stream: visualizer | findings | agent (default visualizer)
   --replay, --once stream: scan once and exit (default for positional input / --session)
   --no-spans       stream: omit per-span pulse events
   --no-findings    stream: omit semantic live-finding events
   --llm            Enable agentic RLM analysts (needs OPENAI_API_KEY / OPENAI_BASE_URL)
   --model <id>     --llm model id (e.g. a router model like glm-5.2); default is agent-eval's
-  --config <path>  investigate/improve: JS config with analysts, external analyzers, or proposal adapter
+  --config <path>  investigate/improve/stream: JS config with analysts, liveAnalysts, external analyzers, or proposal adapter
   --budget <usd>   USD cap for agentic analysts
   --analyzer <cmd> analyze: also run an external engine over the OTLP (repeatable; "halo" or any command)
   --analyzer-prompt <p>  analyze: prompt passed to external analyzers (default: diagnose)

package/dist/index.d.ts

@@ -1106,9 +1106,175 @@ declare function commandRedactor(spec: {
     timeoutMs?: number;
 }): Redactor;
 
+type TraceLiveSeverity = 'info' | 'low' | 'medium' | 'high';
+interface TraceLiveEvidence {
+    readonly kind: 'metric' | 'span' | 'pattern';
+    readonly label: string;
+    readonly value: string;
+    readonly spanIds?: readonly string[];
+}
+interface TraceLiveFinding {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.live_finding';
+    readonly id: string;
+    readonly ruleId: string;
+    readonly fingerprint: string;
+    readonly severity: TraceLiveSeverity;
+    readonly title: string;
+    readonly claim: string;
+    readonly action: string;
+    readonly check: string;
+    readonly evidence: readonly TraceLiveEvidence[];
+    readonly session: TraceStreamSession;
+    readonly observedAt: string;
+}
+interface TraceStreamSession {
+    readonly harness: string;
+    readonly sessionId: string;
+    readonly cwd: string | null;
+    readonly path?: string;
+}
+type TraceLiveActionKind = 'tool' | 'read' | 'edit' | 'verify' | 'claim' | 'other';
+interface TraceLiveAction {
+    readonly kind: TraceLiveActionKind;
+    readonly spanId: string;
+    readonly span: OtlpSpan;
+    readonly toolName?: string;
+    readonly signature: string;
+    readonly errored: boolean;
+}
+interface TraceLiveLoop {
+    readonly harness: string;
+    readonly sessionId: string;
+    readonly cwd: string | null;
+    readonly toolName: string;
+    readonly argHash: string;
+    readonly occurrences: number;
+    readonly windowMs: number;
+}
+interface TraceLiveAnalysisContext {
+    readonly spans: readonly OtlpSpan[];
+    readonly actions: readonly TraceLiveAction[];
+    readonly tools: readonly OtlpSpan[];
+    readonly erroredTools: readonly OtlpSpan[];
+    readonly verificationActions: readonly TraceLiveAction[];
+    readonly changeActions: readonly TraceLiveAction[];
+    readonly session: TraceStreamSession;
+    readonly generatedAt: string;
+    readonly newSpanCount: number;
+}
+interface TraceLiveAnalyst {
+    readonly id: string;
+    analyze(context: TraceLiveAnalysisContext): readonly TraceLiveFinding[];
+}
+interface TraceLiveBatch {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.live_batch';
+    readonly generatedAt: string;
+    readonly session: TraceStreamSession;
+    readonly spanCount: number;
+    readonly newSpanCount: number;
+    readonly toolCallCount: number;
+    readonly erroredToolCallCount: number;
+    readonly verificationCallCount: number;
+    readonly changeCallCount: number;
+    readonly actionCounts: Readonly<Record<TraceLiveActionKind, number>>;
+    readonly findingCount: number;
+    readonly findings: readonly TraceLiveFinding[];
+}
+type TraceStreamEvent = {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.session';
+    readonly event: 'session';
+    readonly generatedAt: string;
+    readonly session: TraceStreamSession;
+    readonly spanCount: number;
+    readonly startedAt: string | null;
+    readonly endedAt: string | null;
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.span';
+    readonly event: 'span';
+    readonly generatedAt: string;
+    readonly session: TraceStreamSession;
+    readonly span: OtlpSpan;
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.batch';
+    readonly event: 'analysis_batch';
+    readonly generatedAt: string;
+    readonly ref?: SessionRef;
+    readonly batch: TraceLiveBatch;
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.report';
+    readonly event: 'report';
+    readonly generatedAt: string;
+    readonly session: TraceStreamSession;
+    readonly ref: SessionRef;
+    readonly report: PipelineReport;
+    readonly loops: readonly TraceLiveLoop[];
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.finding';
+    readonly event: 'finding';
+    readonly generatedAt: string;
+    readonly finding: TraceLiveFinding;
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: 'traces.stream.tick';
+    readonly event: 'tick';
+    readonly generatedAt: string;
+    readonly sessions: number;
+    readonly newSpans: number;
+    readonly findings: number;
+};
+interface LiveBatchOptions {
+    readonly generatedAt?: string;
+    readonly session?: Partial<TraceStreamSession>;
+    readonly newSpanCount?: number;
+    /** Replaces the built-in deterministic live analysts. */
+    readonly analysts?: readonly TraceLiveAnalyst[];
+    /** Adds custom live analysts after the built-ins. */
+    readonly extraAnalysts?: readonly TraceLiveAnalyst[];
+}
+interface TraceStreamReplayOptions extends LiveBatchOptions {
+    readonly ref?: SessionRef;
+    readonly includeSpans?: boolean;
+    readonly includeFindings?: boolean;
+}
+interface TraceStreamOptions extends ScanOptions {
+    /** Observe sessions active within this window. Default 30 min. */
+    readonly windowMs?: number;
+    /** Poll interval. Default 5s. */
+    readonly intervalMs?: number;
+    /** Stop after one scan, useful for replay or tests. */
+    readonly once?: boolean;
+    /** Emit one JSON event per new span. Default true. */
+    readonly includeSpans?: boolean;
+    /** Emit live semantic findings. Default true. */
+    readonly includeFindings?: boolean;
+    /** Emit session and analysis-batch events. Default true. */
+    readonly includeBatches?: boolean;
+    /** Emit deterministic pipeline report events. Default false. */
+    readonly includeReports?: boolean;
+    /** Minimum repeated identical calls for report loop detection. Default 3. */
+    readonly minLoopOccurrences?: number;
+    /** Adds custom live analysts after the built-ins. */
+    readonly extraAnalysts?: readonly TraceLiveAnalyst[];
+    readonly onEvent: (event: TraceStreamEvent) => void | Promise<void>;
+}
+declare function classifyLiveActions(spans: readonly OtlpSpan[]): TraceLiveAction[];
+declare const defaultTraceLiveAnalysts: readonly TraceLiveAnalyst[];
+declare function analyzeLiveBatch(spans: readonly OtlpSpan[], opts?: LiveBatchOptions): TraceLiveBatch;
+declare function traceStreamEventsFromSpans(spans: readonly OtlpSpan[], opts?: TraceStreamReplayOptions): TraceStreamEvent[];
+declare function serializeTraceStreamEvent(event: TraceStreamEvent): string;
+declare function streamSessions(opts: TraceStreamOptions): Promise<void>;
+
 interface TracesConfig {
     readonly registry?: AnalystRegistry;
     readonly analysts?: readonly Analyst[];
+    readonly liveAnalysts?: readonly TraceLiveAnalyst[];
     readonly externalAnalyzers?: readonly ExternalAnalyzer[];
     readonly improvementAdapter?: ImprovementAdapter;
 }
@@ -1276,139 +1442,15 @@ declare function writeTraceImprovementArtifacts(result: Pick<TraceImprovementRes
 declare function runTraceImprovementLoop(opts: TraceImprovementOptions): Promise<TraceImprovementResult>;
 declare function saveReport(path: string, report: string): Promise<void>;
 
-type TraceLiveSeverity = 'info' | 'low' | 'medium' | 'high';
-interface TraceLiveEvidence {
-    readonly kind: 'metric' | 'span' | 'pattern';
-    readonly label: string;
-    readonly value: string;
-    readonly spanIds?: readonly string[];
-}
-interface TraceLiveFinding {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.live_finding';
-    readonly id: string;
-    readonly ruleId: string;
-    readonly fingerprint: string;
-    readonly severity: TraceLiveSeverity;
-    readonly title: string;
-    readonly claim: string;
-    readonly action: string;
-    readonly check: string;
-    readonly evidence: readonly TraceLiveEvidence[];
-    readonly session: TraceStreamSession;
-    readonly observedAt: string;
-}
-interface TraceStreamSession {
-    readonly harness: string;
-    readonly sessionId: string;
-    readonly cwd: string | null;
-    readonly path?: string;
-}
-interface TraceLiveBatch {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.live_batch';
-    readonly generatedAt: string;
-    readonly session: TraceStreamSession;
-    readonly spanCount: number;
-    readonly newSpanCount: number;
-    readonly toolCallCount: number;
-    readonly erroredToolCallCount: number;
-    readonly verificationCallCount: number;
-    readonly changeCallCount: number;
-    readonly findingCount: number;
-    readonly findings: readonly TraceLiveFinding[];
-}
-type TraceStreamEvent = {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.stream.session';
-    readonly event: 'session';
-    readonly generatedAt: string;
-    readonly session: TraceStreamSession;
-    readonly spanCount: number;
-    readonly startedAt: string | null;
-    readonly endedAt: string | null;
-} | {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.stream.span';
-    readonly event: 'span';
-    readonly generatedAt: string;
-    readonly session: TraceStreamSession;
-    readonly span: OtlpSpan;
-} | {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.stream.batch';
-    readonly event: 'analysis_batch';
-    readonly generatedAt: string;
-    readonly batch: TraceLiveBatch;
-} | {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.stream.finding';
-    readonly event: 'finding';
-    readonly generatedAt: string;
-    readonly finding: TraceLiveFinding;
-} | {
-    readonly schemaVersion: 1;
-    readonly kind: 'traces.stream.tick';
-    readonly event: 'tick';
-    readonly generatedAt: string;
-    readonly sessions: number;
-    readonly newSpans: number;
-    readonly findings: number;
-};
-interface LiveBatchOptions {
-    readonly generatedAt?: string;
-    readonly session?: Partial<TraceStreamSession>;
-    readonly newSpanCount?: number;
-}
-interface TraceStreamReplayOptions extends LiveBatchOptions {
-    readonly ref?: SessionRef;
-    readonly includeSpans?: boolean;
-    readonly includeFindings?: boolean;
-}
-interface TraceStreamOptions extends ScanOptions {
-    /** Observe sessions active within this window. Default 30 min. */
-    readonly windowMs?: number;
-    /** Poll interval. Default 5s. */
-    readonly intervalMs?: number;
-    /** Stop after one scan, useful for replay or tests. */
-    readonly once?: boolean;
-    /** Emit one JSON event per new span. Default true. */
-    readonly includeSpans?: boolean;
-    /** Emit live semantic findings. Default true. */
-    readonly includeFindings?: boolean;
-    /** Emit session and analysis-batch events. Default true. */
-    readonly includeBatches?: boolean;
-    readonly onEvent: (event: TraceStreamEvent) => void | Promise<void>;
-}
-declare function analyzeLiveBatch(spans: readonly OtlpSpan[], opts?: LiveBatchOptions): TraceLiveBatch;
-declare function traceStreamEventsFromSpans(spans: readonly OtlpSpan[], opts?: TraceStreamReplayOptions): TraceStreamEvent[];
-declare function serializeTraceStreamEvent(event: TraceStreamEvent): string;
-declare function streamSessions(opts: TraceStreamOptions): Promise<void>;
-
 /**
- * Live trace observer — the reusable, event-driven core behind `traces watch`.
+ * Live trace observer — compatibility wrapper behind `traces watch`.
  *
- * `watchSessions` tails active coding-agent sessions across harnesses and emits
- * structured events as it goes: every session's pipeline report each tick
- * (`onReport`), and a deduped signal whenever a stuck loop first appears or
- * grows (`onLoop`). It's read-only (never touches the agent or its harness) and
- * cancellable via an `AbortSignal`, so a third party can subscribe to the live
- * findings stream and feed it into any system — a dashboard, an alerter, a
- * steering layer, or another agent — without shelling out to the CLI.
+ * `streamSessions` is the single live scanner. `watchSessions` keeps the
+ * callback-oriented SDK surface for existing users while consuming stream
+ * events instead of running a second polling loop.
  */
 
-/** A newly-observed (or grown) stuck loop in a live session. */
-interface ObservedLoop {
-    harness: string;
-    sessionId: string;
-    cwd: string | null;
-    toolName: string;
-    argHash: string;
-    /** Identical repeated calls observed so far. */
-    occurrences: number;
-    /** Milliseconds between the first and last call in the loop. */
-    windowMs: number;
-}
+type ObservedLoop = TraceLiveLoop;
 interface ObserverOptions {
     /** Harness ids/aliases to observe. Omit (or pass `all: true`) → every harness. */
     harnesses?: string[];
@@ -1443,11 +1485,6 @@ interface ObserverOptions {
         sessions: number;
     }) => void;
 }
-/**
- * Observe active sessions until `opts.signal` aborts. Returns a promise that
- * resolves on abort. Errors in a single session are routed to `onError` and
- * never stop the loop.
- */
 declare function watchSessions(opts: ObserverOptions): Promise<void>;
 
 /**
@@ -1602,4 +1639,4 @@ interface ExecuteOptions {
 /** Send the NEW items (or, on dryRun, write the redacted OTLP that would send). */
 declare function executeUpload(plan: UploadPlan, opts?: ExecuteOptions): Promise<UploadResult>;
 
-export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalyzeOptions, type AnalyzeResult, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, CORRECTIVE_REACTIONS, ClaudeAdapter, CodexAdapter, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, CopilotAdapter, DEFAULT_HARNESS, type ExecuteOptions, type ExternalAnalysisResult, type ExternalAnalyzer, FactoryAdapter, type FindingStore, ForgeAdapter, GeminiAdapter, type HarnessTraceAdapter, INGEST_SOURCE_CLI, type ImprovementAdapter, type ImprovementAdapterInput, type ImprovementProposal, type InspectSessionIndexOptions, type LiveBatchOptions, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, QwenAdapter, REACTIONS, type Reaction, type ReactionReport, type ReactionSessionReport, type RecommendationWriter, type Redactor, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type RunResult, type RuntimeTrace, type ScanOptions, type ScannedSession, type SessionBatch, type SessionRef, type SpanInput, type SpanRedaction, TRACES_REDACTION_RULES, type TraceClaim, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveSeverity, type TraceRecommendation, type TraceReplayProof, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UploadBackend, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeReactions, analyzeSpans, applyRedactor, buildPolicyEvidenceRecord, buildSessionIndex, buildSessionIndexFromRows, buildTraceFindingPacket, capText, classifyReaction, claudeActor, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessions, commandAnalyzer, commandRedactor, countSkillRunsJsonl, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, haloAnalyzer, inspectSessionIndex, knownHarnesses, listAdapters, loadState, loadTracesConfig, looksLikeAgentPrompt, mergeTracesConfig, normalizeRemote, parseIsoToEpochMs, parseSession, parseSince, planUpload, readSessionIndexFile, redactSpans, renderInspectionReport, resolveAdapter, resolveRepoAttrs, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runPipelines, runTraceImprovementLoop, runTraceInvestigation, runTraceStoreInvestigation, saveReport, saveState, scanSessions, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, span, stampRepoAttrs, streamSessions, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, traceStreamEventsFromSpans, uploadKey, userPromptSpan, watchSessions, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts };
+export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalyzeOptions, type AnalyzeResult, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, CORRECTIVE_REACTIONS, ClaudeAdapter, CodexAdapter, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, CopilotAdapter, DEFAULT_HARNESS, type ExecuteOptions, type ExternalAnalysisResult, type ExternalAnalyzer, FactoryAdapter, type FindingStore, ForgeAdapter, GeminiAdapter, type HarnessTraceAdapter, INGEST_SOURCE_CLI, type ImprovementAdapter, type ImprovementAdapterInput, type ImprovementProposal, type InspectSessionIndexOptions, type LiveBatchOptions, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, QwenAdapter, REACTIONS, type Reaction, type ReactionReport, type ReactionSessionReport, type RecommendationWriter, type Redactor, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type RunResult, type RuntimeTrace, type ScanOptions, type ScannedSession, type SessionBatch, type SessionRef, type SpanInput, type SpanRedaction, TRACES_REDACTION_RULES, type TraceClaim, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveAction, type TraceLiveActionKind, type TraceLiveAnalysisContext, type TraceLiveAnalyst, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveLoop, type TraceLiveSeverity, type TraceRecommendation, type TraceReplayProof, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UploadBackend, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeReactions, analyzeSpans, applyRedactor, buildPolicyEvidenceRecord, buildSessionIndex, buildSessionIndexFromRows, buildTraceFindingPacket, capText, classifyLiveActions, classifyReaction, claudeActor, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessions, commandAnalyzer, commandRedactor, countSkillRunsJsonl, defaultTraceLiveAnalysts, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, haloAnalyzer, inspectSessionIndex, knownHarnesses, listAdapters, loadState, loadTracesConfig, looksLikeAgentPrompt, mergeTracesConfig, normalizeRemote, parseIsoToEpochMs, parseSession, parseSince, planUpload, readSessionIndexFile, redactSpans, renderInspectionReport, resolveAdapter, resolveRepoAttrs, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runPipelines, runTraceImprovementLoop, runTraceInvestigation, runTraceStoreInvestigation, saveReport, saveState, scanSessions, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, span, stampRepoAttrs, streamSessions, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, traceStreamEventsFromSpans, uploadKey, userPromptSpan, watchSessions, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts };

package/dist/index.js

@@ -29,6 +29,7 @@ import {
   buildSessionIndexFromRows,
   buildTraceFindingPacket,
   capText,
+  classifyLiveActions,
   classifyReaction,
   claudeActor,
   codexActor,
@@ -37,6 +38,7 @@ import {
   commandAnalyzer,
   commandRedactor,
   countSkillRunsJsonl,
+  defaultTraceLiveAnalysts,
   executeUpload,
   exportTraceEvidenceFile,
   exportTraceEvidenceRows,
@@ -93,7 +95,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-G3OBZSWY.js";
+} from "./chunk-FCTZLWP7.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {
@@ -151,6 +153,7 @@ export {
   buildSessionIndexFromRows,
   buildTraceFindingPacket,
   capText,
+  classifyLiveActions,
   classifyReaction,
   claudeActor,
   codexActor,
@@ -161,6 +164,7 @@ export {
   commandRedactor,
   countSkillRunsJsonl,
   createHostedClient,
+  defaultTraceLiveAnalysts,
   executeUpload,
   exportTraceEvidenceFile,
   exportTraceEvidenceRows,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.8.18",
+  "version": "0.8.19",
   "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, …) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite — observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
   "type": "module",
   "license": "MIT",