@tangle-network/traces 0.8.16 → 0.8.18

package/dist/cli.js

@@ -33,18 +33,22 @@ import {
   serializePolicyEvidence,
   serializeSessionIndex,
   serializeSpans,
+  serializeTraceStreamEvent,
+  streamSessions,
   summarizeDeterministicSignals,
+  traceStreamEventsFromSpans,
   watchSessions,
   writeInspectionReportFile,
   writeOtlpFile,
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-EOQY2RIK.js";
+} from "./chunk-G3OBZSWY.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++) {
@@ -135,6 +142,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);
@@ -326,10 +343,7 @@ async function cmdInspect(args) {
 }
 async function cmdExport(args) {
   if (!args.input) throw new Error("export needs an input file; run `traces export --help` for examples");
-  const format = args.format ?? "auto";
-  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference") {
-    throw new Error("--format must be auto, policy-evidence, sandbox-events, or openinference");
-  }
+  const format = traceEvidenceFormat(args.format);
   const attributes = await loadExportAttributes(args);
   const outPath = args.out ?? args.otlp;
   if (outPath) {
@@ -342,6 +356,13 @@ async function cmdExport(args) {
   const result = await exportTraceEvidenceFile(args.input, { format, attributes });
   process.stdout.write(serializeSpans(result.spans));
 }
+function traceEvidenceFormat(raw) {
+  const format = raw ?? "auto";
+  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference" && format !== "intelligence-spans") {
+    throw new Error("--format must be auto, policy-evidence, sandbox-events, openinference, or intelligence-spans");
+  }
+  return format;
+}
 function parseAttributeValue(raw) {
   if (raw === "true") return true;
   if (raw === "false") return false;
@@ -368,7 +389,7 @@ async function loadExportAttributes(args) {
   return attributes;
 }
 async function cmdAnalyze(args) {
-  const { spans, harness, sessionCount, cwds } = await collectSpans(args);
+  const { spans, harness, sessionCount, cwds } = args.input ? await collectImportedSpans(args) : await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const ai = args.llm ? await buildAxService() : void 0;
   const { otlpPath, result } = await analyzeSpans(spans, {
@@ -405,6 +426,21 @@ ${r.ok ? r.output || "(no output)" : `failed: ${r.error}`}`;
     console.log(report);
   }
 }
+async function collectImportedSpans(args) {
+  if (!args.input) throw new Error("analyze input missing");
+  const attributes = await loadExportAttributes(args);
+  const result = await exportTraceEvidenceFile(args.input, {
+    format: traceEvidenceFormat(args.format),
+    attributes
+  });
+  const traceIds = new Set(result.spans.map((s) => s.trace_id).filter(Boolean));
+  return {
+    spans: result.spans,
+    harness: result.format,
+    sessionCount: traceIds.size || 1,
+    cwds: []
+  };
+}
 function externalAnalyzersFromArgs(args) {
   return args.analyzers.map(
     (spec) => spec === "halo" ? haloAnalyzer({ defaultPrompt: args.analyzerPrompt, model: args.model }) : commandAnalyzer({ name: spec, command: spec, args: (p, prompt) => prompt ? [p, prompt] : [p] })
@@ -467,12 +503,102 @@ 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");
+}
+async function streamExplicitSession(args) {
+  if (!args.session) throw new Error("streamExplicitSession needs --session");
+  const adapter = resolveAdapter(args.harness);
+  if (!adapter) throw new Error(`unknown harness "${args.harness}"`);
+  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: !args.noSpans,
+    includeFindings: !args.noFindings
+  })) {
+    process.stdout.write(serializeTraceStreamEvent(event));
+  }
+}
+async function cmdStream(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: !args.noSpans,
+      includeFindings: !args.noFindings
+    })) {
+      process.stdout.write(serializeTraceStreamEvent(event));
+    }
+    return;
+  }
+  if (args.session) {
+    await streamExplicitSession(args);
+    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 JSONL live 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: !args.noSpans,
+    includeFindings: !args.noFindings,
+    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({
@@ -486,9 +612,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)}
+`);
     }
   });
 }
@@ -560,12 +690,14 @@ 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
   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)
 
 Examples:
   traces evidence --all --since 24h --out policy-evidence.jsonl
   traces export policy-evidence.jsonl --out spans.openinference.jsonl
   traces export sandbox-events.json --format sandbox-events --out spans.openinference.jsonl
+  traces export intelligence-spans.jsonl --out spans.openinference.jsonl
   traces export sandbox-events.json --attr task.id=aec-001 --attr outcome.score=1 --out spans.openinference.jsonl
   halo spans.openinference.jsonl --prompt "Analyze this trace slice" --max-turns 1
 
@@ -578,7 +710,7 @@ function usage() {
 
 Commands:
   list      List discovered sessions
-  analyze   Run analyst suite + loop/waste pipelines, write a markdown report
+  analyze   Run analyst suite + loop/waste pipelines over sessions or an input file
   investigate Run typed investigation flow, including BYO config + recommendations
   improve   Write a full improvement artifact directory for review/apply/rerun
   convert   Emit OTLP-JSONL only (HALO: use analyze --analyzer halo)
@@ -586,22 +718,26 @@ 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
   --dir <path>     improve: write artifacts to this directory
   --otlp <path>    OTLP artifact path (also evidence provenance / dry-run upload preview)
-  --format <kind>  export: auto | policy-evidence | sandbox-events | openinference
-  --metadata <json> export: attach JSON object fields as span attributes
-  --attr <k=v>     export: attach one span attribute (repeatable)
+  --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)
+  --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
@@ -664,6 +800,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

@@ -998,7 +998,7 @@ declare function readSessionIndexFile(path: string): Promise<TraceSessionIndex>;
 declare function writeInspectionReportFile(report: TraceInspectionReport, outPath?: string): Promise<string>;
 
 type JsonObject = Record<string, unknown>;
-type TraceEvidenceInputFormat = 'policy-evidence' | 'sandbox-events' | 'openinference';
+type TraceEvidenceInputFormat = 'policy-evidence' | 'sandbox-events' | 'openinference' | 'intelligence-spans';
 type TraceEvidenceFormatOption = TraceEvidenceInputFormat | 'auto';
 interface TraceEvidenceExportOptions {
     readonly format?: TraceEvidenceFormatOption;
@@ -1276,6 +1276,115 @@ 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`.
  *
@@ -1323,6 +1432,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. */
@@ -1489,4 +1602,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 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 };

package/dist/index.js

@@ -20,6 +20,7 @@ import {
   TRACES_REDACTION_RULES,
   alreadyUploaded,
   analyzeAdoption,
+  analyzeLiveBatch,
   analyzeReactions,
   analyzeSpans,
   applyRedactor,
@@ -73,13 +74,16 @@ import {
   serializePolicyEvidence,
   serializeSessionIndex,
   serializeSpans,
+  serializeTraceStreamEvent,
   sessionHash,
   span,
   stampRepoAttrs,
+  streamSessions,
   textIsSynthetic,
   toOpenInferenceSpan,
   toRuntimeStore,
   toTraceSpanEvents,
+  traceStreamEventsFromSpans,
   uploadKey,
   userPromptSpan,
   watchSessions,
@@ -89,7 +93,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-EOQY2RIK.js";
+} from "./chunk-G3OBZSWY.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {
@@ -137,6 +141,7 @@ export {
   TRACES_REDACTION_RULES,
   alreadyUploaded,
   analyzeAdoption,
+  analyzeLiveBatch,
   analyzeReactions,
   analyzeSpans,
   applyRedactor,
@@ -197,13 +202,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.16",
+  "version": "0.8.18",
   "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",