@tangle-network/traces 0.8.17 → 0.8.19

package/dist/cli.js

@@ -33,18 +33,22 @@ import {
   serializePolicyEvidence,
   serializeSessionIndex,
   serializeSpans,
+  serializeTraceStreamEvent,
+  streamSessions,
   summarizeDeterministicSignals,
+  traceStreamEventsFromSpans,
   watchSessions,
   writeInspectionReportFile,
   writeOtlpFile,
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-QM4QAG3V.js";
+} from "./chunk-FCTZLWP7.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
 import { readFile, stat, writeFile } from "fs/promises";
+import { basename, resolve } from "path";
 function packageVersion() {
   const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version) throw new Error("package.json is missing version");
@@ -66,6 +70,9 @@ function parseArgs(argv) {
     yes: false,
     noContent: false,
     analyzers: [],
+    replay: false,
+    noSpans: false,
+    noFindings: false,
     attrs: []
   };
   for (let i = 1; i < argv.length; i++) {
@@ -112,6 +119,9 @@ function parseArgs(argv) {
       case "--config":
         a.config = next();
         break;
+      case "--mode":
+        a.mode = next();
+        break;
       case "--metadata":
         a.metadata = next();
         break;
@@ -135,6 +145,16 @@ function parseArgs(argv) {
       case "--no-content":
         a.noContent = true;
         break;
+      case "--replay":
+      case "--once":
+        a.replay = true;
+        break;
+      case "--no-spans":
+        a.noSpans = true;
+        break;
+      case "--no-findings":
+        a.noFindings = true;
+        break;
       case "--analyzer": {
         const v = next();
         if (v) a.analyzers.push(v);
@@ -486,12 +506,125 @@ async function cmdImprove(args) {
     `improvement artifacts \u2192 ${dir}  (${result.findings.length} findings, ${result.recommendations.length} recommendations, ${result.proposals.length} proposal(s), OTLP: ${result.otlpPath})`
   );
 }
+function summarizeFindingEvidence(finding) {
+  const first = finding.evidence[0];
+  if (!first) return "no evidence";
+  return `${first.label}: ${first.value}`;
+}
+function formatLiveFinding(finding) {
+  const ts = new Date(finding.observedAt).toISOString().slice(11, 19);
+  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}`,
+    `  evidence: ${summarizeFindingEvidence(finding)}`,
+    `  action: ${finding.action}`,
+    `  check: ${finding.check}`
+  ].join("\n");
+}
+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,
+    sessionId: basename(args.session),
+    path: resolve(args.session),
+    cwd: args.cwd ?? null,
+    mtimeMs: st.mtimeMs
+  };
+  const spans = await parseSession(adapter, ref);
+  for (const event of traceStreamEventsFromSpans(spans, {
+    ref,
+    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 = {
+      harness,
+      sessionId: basename(args.input),
+      path: resolve(args.input),
+      cwd: args.cwd ?? null,
+      mtimeMs: Date.now()
+    };
+    for (const event of traceStreamEventsFromSpans(spans, {
+      ref,
+      includeSpans: preset.includeSpans,
+      includeFindings: preset.includeFindings,
+      extraAnalysts: config?.liveAnalysts
+    })) {
+      process.stdout.write(serializeTraceStreamEvent(event));
+    }
+    return;
+  }
+  if (args.session) {
+    await streamExplicitSession(args, config?.liveAnalysts);
+    return;
+  }
+  const all = args.all || !args.harnessExplicit && !args.cwd;
+  const controller = new AbortController();
+  process.once("SIGINT", () => controller.abort());
+  if (!args.replay) {
+    process.stderr.write(
+      `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.
+`
+    );
+  }
+  await streamSessions({
+    all,
+    harnesses: all ? void 0 : [args.harness],
+    cwd: args.cwd,
+    last: args.last > 0 ? args.last : args.replay ? 1 : void 0,
+    windowMs: args.window * 6e4,
+    intervalMs: args.interval * 1e3,
+    once: args.replay,
+    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));
+    },
+    onError: (err, ref) => {
+      const where = ref ? ` [${ref.harness}] ${ref.sessionId}` : "";
+      process.stderr.write(`stream error${where}: ${err instanceof Error ? err.message : String(err)}
+`);
+    }
+  });
+}
 async function cmdWatch(args) {
   const all = args.all || !args.harnessExplicit && !args.cwd;
   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. Read-only; Ctrl-C to stop.
+    `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.
 `
   );
   await watchSessions({
@@ -505,9 +638,13 @@ async function cmdWatch(args) {
     onLoop: (l) => {
       const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
       process.stdout.write(
-        `\u26A0\uFE0F  ${ts} [${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)} \u2014 \`${l.toolName}\` repeated \xD7${l.occurrences} with identical args (${(l.windowMs / 1e3).toFixed(0)}s)${l.cwd ? ` \xB7 ${l.cwd}` : ""}
 `
       );
+    },
+    onFinding: (finding) => {
+      process.stdout.write(`${formatLiveFinding(finding)}
+`);
     }
   });
 }
@@ -607,14 +744,15 @@ Commands:
   inspect   Read a session index and print ranked improvement findings
   export    Convert evidence/events files to OpenInference JSONL for HALO
   evidence  Emit compact session-evidence JSONL for downstream policy miners
-  watch     Online observer: tail active sessions, notify on stuck loops (read-only)
+  stream    Emit JSONL trace stream events for live visualizers or replay
+  watch     Online observer: tail active sessions, notify on loops + semantic findings
   upload    Redact + upload sessions in a time window to the Tangle Intelligence Platform
 
 Options:
   --harness <id>   Harness or alias (default: claude-code). Known: ${knownHarnesses().join(", ")}
   --all            Sweep every known harness
   --last <n>       Most-recent N sessions
-  --session <path> Analyze one explicit session file
+  --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
   --out <path>     Write report to a file
@@ -623,9 +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)
@@ -685,6 +827,9 @@ async function main() {
     case "evidence":
       await cmdEvidence(args);
       break;
+    case "stream":
+      await cmdStream(args);
+      break;
     case "watch":
       await cmdWatch(args);
       break;

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;
 }
@@ -1277,29 +1443,14 @@ declare function runTraceImprovementLoop(opts: TraceImprovementOptions): Promise
 declare function saveReport(path: string, report: string): 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[];
@@ -1323,6 +1474,10 @@ interface ObserverOptions {
     /** Fired for every observed session each tick, with its full pipeline report
      *  (stuck loops + tool-use metrics) — react to anything, not just loops. */
     onReport?: (ref: SessionRef, report: PipelineReport) => void | Promise<void>;
+    /** Fired for every observed session each tick, after semantic live analysis. */
+    onBatch?: (ref: SessionRef, batch: TraceLiveBatch) => void | Promise<void>;
+    /** Fired once for each newly-observed live semantic finding. */
+    onFinding?: (finding: TraceLiveFinding) => void | Promise<void>;
     /** Per-session parse/pipeline error (the observer keeps going). */
     onError?: (error: unknown, ref?: SessionRef) => void;
     /** Fired after each poll cycle. */
@@ -1330,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>;
 
 /**
@@ -1489,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 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 TraceRecommendation, type TraceReplayProof, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TracesConfig, type TriggerPair, type UploadBackend, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, alreadyUploaded, analyzeAdoption, 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, sessionHash, span, stampRepoAttrs, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, 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

@@ -20,6 +20,7 @@ import {
   TRACES_REDACTION_RULES,
   alreadyUploaded,
   analyzeAdoption,
+  analyzeLiveBatch,
   analyzeReactions,
   analyzeSpans,
   applyRedactor,
@@ -28,6 +29,7 @@ import {
   buildSessionIndexFromRows,
   buildTraceFindingPacket,
   capText,
+  classifyLiveActions,
   classifyReaction,
   claudeActor,
   codexActor,
@@ -36,6 +38,7 @@ import {
   commandAnalyzer,
   commandRedactor,
   countSkillRunsJsonl,
+  defaultTraceLiveAnalysts,
   executeUpload,
   exportTraceEvidenceFile,
   exportTraceEvidenceRows,
@@ -73,13 +76,16 @@ import {
   serializePolicyEvidence,
   serializeSessionIndex,
   serializeSpans,
+  serializeTraceStreamEvent,
   sessionHash,
   span,
   stampRepoAttrs,
+  streamSessions,
   textIsSynthetic,
   toOpenInferenceSpan,
   toRuntimeStore,
   toTraceSpanEvents,
+  traceStreamEventsFromSpans,
   uploadKey,
   userPromptSpan,
   watchSessions,
@@ -89,7 +95,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-QM4QAG3V.js";
+} from "./chunk-FCTZLWP7.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {
@@ -137,6 +143,7 @@ export {
   TRACES_REDACTION_RULES,
   alreadyUploaded,
   analyzeAdoption,
+  analyzeLiveBatch,
   analyzeReactions,
   analyzeSpans,
   applyRedactor,
@@ -146,6 +153,7 @@ export {
   buildSessionIndexFromRows,
   buildTraceFindingPacket,
   capText,
+  classifyLiveActions,
   classifyReaction,
   claudeActor,
   codexActor,
@@ -156,6 +164,7 @@ export {
   commandRedactor,
   countSkillRunsJsonl,
   createHostedClient,
+  defaultTraceLiveAnalysts,
   executeUpload,
   exportTraceEvidenceFile,
   exportTraceEvidenceRows,
@@ -197,13 +206,16 @@ export {
   serializePolicyEvidence,
   serializeSessionIndex,
   serializeSpans,
+  serializeTraceStreamEvent,
   sessionHash,
   span,
   stampRepoAttrs,
+  streamSessions,
   textIsSynthetic,
   toOpenInferenceSpan,
   toRuntimeStore,
   toTraceSpanEvents,
+  traceStreamEventsFromSpans,
   uploadKey,
   userPromptSpan,
   watchSessions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.8.17",
+  "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",