@tangle-network/traces 0.8.18 → 0.8.20

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;
@@ -212,7 +215,7 @@ async function buildAxService() {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) {
     throw new Error(
-      "--llm needs OPENAI_API_KEY \u2014 an OpenAI key, or a router/gateway key with OPENAI_BASE_URL set to an OpenAI-compatible endpoint (e.g. the Tangle router). Deterministic analysis needs no key."
+      "--llm needs OPENAI_API_KEY: an OpenAI key, or a router/gateway key with OPENAI_BASE_URL set to an OpenAI-compatible endpoint (e.g. the Tangle router). Deterministic analysis needs no key."
     );
   }
   const apiURL = process.env.OPENAI_BASE_URL || void 0;
@@ -223,7 +226,7 @@ async function cmdList(args) {
   const groups = await discover({ ...args, last: args.last || 20 });
   for (const { adapter, refs } of groups) {
     console.log(`
-${adapter.harness} \u2014 ${refs.length} session(s)`);
+${adapter.harness}: ${refs.length} session(s)`);
     for (const r of refs) {
       console.log(`  ${new Date(r.mtimeMs).toISOString()}  ${r.sessionId}  ${r.cwd ?? ""}`);
     }
@@ -513,16 +516,32 @@ function formatLiveFinding(finding) {
   const where = `[${finding.session.harness}] ${finding.session.sessionId.slice(0, 8)}`;
   const cwd = finding.session.cwd ? ` \xB7 ${finding.session.cwd}` : "";
   return [
-    `${ts} ${finding.severity.toUpperCase()} ${where} \u2014 ${finding.title}${cwd}`,
+    `${ts} ${finding.severity.toUpperCase()} ${where}: ${finding.title}${cwd}`,
     `  evidence: ${summarizeFindingEvidence(finding)}`,
     `  action: ${finding.action}`,
     `  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: ${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));
@@ -598,7 +624,7 @@ async function cmdWatch(args) {
   const controller = new AbortController();
   process.once("SIGINT", () => controller.abort());
   process.stderr.write(
-    `traces watch \u2014 observing ${all ? "all harnesses" : args.harness}, sessions active in the last ${args.window}m, every ${args.interval}s. Loop + semantic live findings; read-only; Ctrl-C to stop.
+    `traces watch: observing ${all ? "all harnesses" : args.harness}, sessions active in the last ${args.window}m, every ${args.interval}s. Loop + semantic live findings; read-only; Ctrl-C to stop.
 `
   );
   await watchSessions({
@@ -612,7 +638,7 @@ async function cmdWatch(args) {
     onLoop: (l) => {
       const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
       process.stdout.write(
-        `${ts} LOOP [${l.harness}] ${l.sessionId.slice(0, 8)} \u2014 \`${l.toolName}\` repeated \xD7${l.occurrences} with identical args (${(l.windowMs / 1e3).toFixed(0)}s)${l.cwd ? ` \xB7 ${l.cwd}` : ""}
+        `${ts} LOOP [${l.harness}] ${l.sessionId.slice(0, 8)}: \`${l.toolName}\` repeated \xD7${l.occurrences} with identical args (${(l.windowMs / 1e3).toFixed(0)}s)${l.cwd ? ` \xB7 ${l.cwd}` : ""}
 `
       );
     },
@@ -660,7 +686,7 @@ Window: since ${new Date(sinceMs).toISOString()}
   }
   if (args.dryRun) {
     const res2 = await executeUpload(plan, { dryRun: true, otlpOut: args.otlp, stripContent: args.noContent, redactor });
-    console.log(`dry run \u2014 ${newItems.length} session(s), ${totalRedactions} redaction(s). Redacted OTLP \u2192 ${res2.otlpPath}`);
+    console.log(`dry run: ${newItems.length} session(s), ${totalRedactions} redaction(s). Redacted OTLP -> ${res2.otlpPath}`);
     console.log("No upload performed. Set TANGLE_INGEST_URL / TANGLE_INGEST_API_KEY / TANGLE_TENANT_ID and drop --dry-run to send.");
     return;
   }
@@ -678,7 +704,7 @@ Window: since ${new Date(sinceMs).toISOString()}
   );
 }
 function usageExport() {
-  console.log(`traces export \u2014 convert trace evidence files to OpenInference JSONL
+  console.log(`traces export: convert trace evidence files to OpenInference JSONL
 
 Usage:
   traces export <input.jsonl|input.json> --out <spans.jsonl> [--format auto]
@@ -688,7 +714,7 @@ Usage:
 
 Input formats:
   policy-evidence  Compact JSONL rows from \`traces evidence --out policy-evidence.jsonl\`
-  sandbox-events   Sandbox/OpenCode event arrays with start/raw/result/done/error events
+  sandbox-events   JSON arrays with start/raw/result/done/error events
   openinference    Existing OpenInference JSONL; rewrites through traces redaction
   intelligence-spans  JSONL rows exported from Tangle Intelligence trace spans
   auto             Detect the format from the file contents (default)
@@ -706,7 +732,7 @@ Safety:
   --metadata must be a JSON object; --attr key=value is repeatable and overrides matching metadata keys.`);
 }
 function usage() {
-  console.log(`traces \u2014 analyze, observe & upload coding-agent sessions
+  console.log(`traces: analyze, observe & upload coding-agent sessions
 
 Commands:
   list      List discovered sessions
@@ -728,27 +754,28 @@ Options:
   --last <n>       Most-recent N sessions
   --session <path> Analyze/stream one explicit harness session file
   --cwd <dir>      Filter sessions by working directory
-  --since <t>      upload: window \u2014 30m / 2h / 7d or an ISO date (default 24h); analyze: ISO cutoff
+  --since <t>      upload: window, 30m / 2h / 7d or an ISO date (default 24h); analyze: ISO cutoff
   --out <path>     Write report to a file
   --dir <path>     improve: write artifacts to this directory
   --otlp <path>    OTLP artifact path (also evidence provenance / dry-run upload preview)
   --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)
-  --interval <s>   watch: poll interval seconds (default 5)
-  --window <m>     watch: only sessions active in the last N minutes (default 30)
+  --interval <s>   watch/stream: poll interval seconds (default 5)
+  --window <m>     watch/stream: only sessions active in the last N minutes (default 30)
   --min-loop <n>   Min identical repeated calls to flag a loop (default 3)
   --dry-run        upload: redact + dedup + preview, write OTLP, but do NOT send
-  --no-content     upload: strip prompt/response text \u2014 send metadata only
+  --no-content     upload: strip prompt/response text; send metadata only
   --redactor <cmd> upload: external PII scrubber (JSON array stdin\u2192stdout) after the regex pass
   --yes, -y        upload: skip the confirmation prompt
   --version, -v    Print the installed traces version

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.20",
   "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",