@tangle-network/traces 0.2.1 → 0.3.0

package/dist/{chunk-YYVPAOOD.js → chunk-6NILXLUI.js}

@@ -70,6 +70,25 @@ async function analyzeSpans(spans, opts = {}) {
   return { otlpPath, result };
 }
 
+// src/time.ts
+function parseIsoToEpochMs(ts) {
+  if (!ts) return 0;
+  if (/^\d+$/.test(ts)) return Number(ts);
+  const n = Date.parse(ts);
+  return Number.isNaN(n) ? 0 : n;
+}
+function parseSince(value) {
+  const m = value.match(/^(\d+)\s*([mhd])$/i);
+  if (m) {
+    const unit = m[2].toLowerCase();
+    const ms = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+    return Date.now() - Number(m[1]) * ms;
+  }
+  const t = Date.parse(value);
+  if (Number.isNaN(t)) throw new Error(`--since: expected 30m / 2h / 7d or an ISO date, got "${value}"`);
+  return t;
+}
+
 // src/runtime-store.ts
 import { InMemoryTraceStore } from "@tangle-network/agent-eval";
 var KIND = {
@@ -79,10 +98,6 @@ var KIND = {
   CHAIN: "custom",
   SPAN: "custom"
 };
-function ms(iso2) {
-  const n = Date.parse(iso2);
-  return Number.isNaN(n) ? 0 : n;
-}
 async function toRuntimeStore(spans) {
   const store = new InMemoryTraceStore();
   const runIds = /* @__PURE__ */ new Set();
@@ -97,8 +112,8 @@ async function toRuntimeStore(spans) {
       parentSpanId: s.parent_span_id ?? void 0,
       runId: s.trace_id,
       name: s.name,
-      startedAt: ms(s.start_time),
-      endedAt: ms(s.end_time),
+      startedAt: parseIsoToEpochMs(s.start_time),
+      endedAt: parseIsoToEpochMs(s.end_time),
       status: s.status.code === "ERROR" ? "error" : "ok",
       error: s.status.message,
       attributes: s.attributes
@@ -1141,8 +1156,8 @@ import { readdir as readdir8, readFile as readFile8, stat as stat8 } from "fs/pr
 import { homedir as homedir8 } from "os";
 import { join as join8 } from "path";
 var SERVICE7 = "opencode";
-function isoOf(ms2) {
-  return new Date(ms2 ?? 0).toISOString();
+function isoOf(ms) {
+  return new Date(ms ?? 0).toISOString();
 }
 var OpencodeAdapter = class {
   harness = "opencode";
@@ -1585,9 +1600,45 @@ function resolveAdapter(harness) {
 function knownHarnesses() {
   return [...BY_NAME.keys()].sort();
 }
+function selectAdapters(opts) {
+  if (opts.adapters && opts.adapters.length > 0) return [...opts.adapters];
+  if (opts.all || !opts.harnesses || opts.harnesses.length === 0) return [...ADAPTERS];
+  return opts.harnesses.map((h) => {
+    const a = resolveAdapter(h);
+    if (!a) throw new Error(`unknown harness "${h}". Known: ${knownHarnesses().join(", ")}`);
+    return a;
+  });
+}
+
+// src/session-source.ts
+async function* scanSessions(opts) {
+  for (const adapter of selectAdapters(opts)) {
+    if (opts.signal?.aborted) return;
+    let refs;
+    try {
+      refs = await adapter.locate({ cwd: opts.cwd, sinceMs: opts.sinceMs });
+    } catch (err) {
+      opts.onError?.(err);
+      continue;
+    }
+    if (opts.last && opts.last > 0) refs = refs.slice(0, opts.last);
+    for (const ref of refs) {
+      if (opts.signal?.aborted) return;
+      let spans;
+      try {
+        spans = await adapter.parse(ref);
+      } catch (err) {
+        opts.onError?.(err, ref);
+        continue;
+      }
+      if (spans.length === 0) continue;
+      yield { adapter, ref, spans };
+    }
+  }
+}
 
 // src/observer.ts
-var sleep = (ms2, signal) => new Promise((resolve) => {
+var sleep = (ms, signal) => new Promise((resolve) => {
   const onAbort = () => {
     clearTimeout(t);
     resolve();
@@ -1595,19 +1646,9 @@ var sleep = (ms2, signal) => new Promise((resolve) => {
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
     resolve();
-  }, ms2);
+  }, ms);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
-function adaptersFor(opts) {
-  if (opts.adapters && opts.adapters.length > 0) return opts.adapters;
-  if (opts.all || !opts.harnesses || opts.harnesses.length === 0) return [...listAdapters()];
-  const out = [];
-  for (const h of opts.harnesses) {
-    const a = resolveAdapter(h);
-    if (a && !out.includes(a)) out.push(a);
-  }
-  return out;
-}
 function loopKey(sessionId, toolName, argHash) {
   return `${sessionId}\0${toolName}\0${argHash}`;
 }
@@ -1615,57 +1656,50 @@ async function watchSessions(opts) {
   const windowMs = opts.windowMs ?? 30 * 6e4;
   const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
   const minLoop = opts.minLoopOccurrences ?? 3;
-  const adapters = adaptersFor(opts);
   const seen = /* @__PURE__ */ new Map();
   while (!opts.signal?.aborted) {
-    const sinceMs = Date.now() - windowMs;
     let sessionCount = 0;
-    for (const adapter of adapters) {
-      if (opts.signal?.aborted) break;
-      let refs;
+    for await (const { adapter, ref, spans } of scanSessions({
+      adapters: opts.adapters,
+      all: opts.all,
+      harnesses: opts.harnesses,
+      cwd: opts.cwd,
+      sinceMs: Date.now() - windowMs,
+      signal: opts.signal,
+      onError: opts.onError
+    })) {
+      let report;
       try {
-        refs = await adapter.locate({ cwd: opts.cwd, sinceMs });
+        report = await runPipelines(spans, { minLoopOccurrences: minLoop });
       } catch (err) {
-        opts.onError?.(err);
+        opts.onError?.(err, ref);
         continue;
       }
-      for (const ref of refs) {
-        if (opts.signal?.aborted) break;
-        let report;
+      sessionCount += 1;
+      if (opts.onReport) {
         try {
-          const spans = await adapter.parse(ref);
-          if (spans.length === 0) continue;
-          report = await runPipelines(spans, { minLoopOccurrences: minLoop });
+          await opts.onReport(ref, report);
         } catch (err) {
           opts.onError?.(err, ref);
-          continue;
         }
-        sessionCount += 1;
-        if (opts.onReport) {
-          try {
-            await opts.onReport(ref, report);
-          } catch (err) {
-            opts.onError?.(err, ref);
-          }
-        }
-        for (const f of report.stuckLoops.findings) {
-          const key = loopKey(ref.sessionId, f.toolName, f.argHash);
-          if (f.occurrences > (seen.get(key) ?? 0)) {
-            seen.set(key, f.occurrences);
-            if (opts.onLoop) {
-              try {
-                await opts.onLoop({
-                  harness: adapter.harness,
-                  sessionId: ref.sessionId,
-                  cwd: ref.cwd,
-                  toolName: f.toolName,
-                  argHash: f.argHash,
-                  occurrences: f.occurrences,
-                  windowMs: f.windowMs
-                });
-              } catch (err) {
-                opts.onError?.(err, ref);
-              }
+      }
+      for (const f of report.stuckLoops.findings) {
+        const key = loopKey(ref.sessionId, f.toolName, f.argHash);
+        if (f.occurrences > (seen.get(key) ?? 0)) {
+          seen.set(key, f.occurrences);
+          if (opts.onLoop) {
+            try {
+              await opts.onLoop({
+                harness: adapter.harness,
+                sessionId: ref.sessionId,
+                cwd: ref.cwd,
+                toolName: f.toolName,
+                argHash: f.argHash,
+                occurrences: f.occurrences,
+                windowMs: f.windowMs
+              });
+            } catch (err) {
+              opts.onError?.(err, ref);
             }
           }
         }
@@ -1681,6 +1715,28 @@ async function watchSessions(opts) {
   }
 }
 
+// src/attributes.ts
+var ATTR = {
+  /** = the trace/session id. Wire contract (dedup linkage). */
+  SESSION_ID: "tangle.sessionId",
+  /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
+   *  that also streamed live. Wire contract. */
+  INGEST_SOURCE: "tangle.ingest_source",
+  HARNESS: "tangle.harness",
+  CWD: "tangle.cwd",
+  GIT_BRANCH: "tangle.git_branch",
+  HOST: "tangle.host",
+  /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
+   *  which collided with `tangle.ingest_source`.) */
+  SESSION_FILE: "tangle.session_file",
+  UPLOADED_AT: "tangle.uploaded_at",
+  UPLOADER: "tangle.uploader",
+  REDACTION_VERSION: "redaction.version",
+  REDACTION_COUNT: "redaction.count"
+};
+var INGEST_SOURCE_CLI = "cli";
+var DEFAULT_HARNESS = "claude-code";
+
 // src/redact.ts
 import { DEFAULT_REDACTION_RULES, redactValue } from "@tangle-network/agent-eval/traces";
 var CODING_REDACTION_RULES = [
@@ -1759,42 +1815,19 @@ import { hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { REDACTION_VERSION } from "@tangle-network/agent-eval/traces";
 var require2 = createRequire(import.meta.url);
 var TRACES_VERSION = require2("../package.json").version;
-function adaptersFor2(opts) {
-  if (opts.all) return [...listAdapters()];
-  const a = resolveAdapter(opts.harness ?? "claude-code");
-  if (!a) throw new Error(`unknown harness "${opts.harness}"`);
-  return [a];
-}
-async function planUpload(opts) {
+async function planUpload(opts = {}) {
   const state = await loadState();
   const items = [];
-  for (const adapter of adaptersFor2(opts)) {
-    let refs;
-    try {
-      refs = await adapter.locate({ cwd: opts.cwd, sinceMs: opts.sinceMs });
-    } catch (err) {
-      opts.onError?.(err);
-      continue;
-    }
-    for (const ref of refs) {
-      let raw;
-      try {
-        raw = await adapter.parse(ref);
-      } catch (err) {
-        opts.onError?.(err, ref);
-        continue;
-      }
-      if (raw.length === 0) continue;
-      const { spans, report } = redactSpans(raw);
-      const hash = sessionHash(spans);
-      items.push({
-        ref,
-        spans,
-        redaction: report,
-        hash,
-        isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash)
-      });
-    }
+  for await (const { ref, spans: raw } of scanSessions(opts)) {
+    const { spans, report } = redactSpans(raw);
+    const hash = sessionHash(spans);
+    items.push({
+      ref,
+      spans,
+      redaction: report,
+      hash,
+      isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash)
+    });
   }
   return { items, state, sinceMs: opts.sinceMs };
 }
@@ -1810,26 +1843,20 @@ async function gitBranch(cwd) {
 }
 async function sessionMeta(item, uploadedAt) {
   const meta = {
-    "tangle.harness": item.ref.harness,
-    "tangle.source": basename8(item.ref.path),
-    "tangle.host": hostname(),
-    "tangle.uploaded_at": uploadedAt,
-    "tangle.uploader": `tangle-traces@${TRACES_VERSION}`,
-    "redaction.version": REDACTION_VERSION,
-    "redaction.count": item.redaction.redactionCount
+    [ATTR.HARNESS]: item.ref.harness,
+    [ATTR.SESSION_FILE]: basename8(item.ref.path),
+    [ATTR.HOST]: hostname(),
+    [ATTR.UPLOADED_AT]: uploadedAt,
+    [ATTR.UPLOADER]: `tangle-traces@${TRACES_VERSION}`,
+    [ATTR.REDACTION_VERSION]: REDACTION_VERSION,
+    [ATTR.REDACTION_COUNT]: item.redaction.redactionCount
   };
-  if (item.ref.cwd) meta["tangle.cwd"] = item.ref.cwd;
+  if (item.ref.cwd) meta[ATTR.CWD] = item.ref.cwd;
   const branch = await gitBranch(item.ref.cwd);
-  if (branch) meta["tangle.git_branch"] = branch;
+  if (branch) meta[ATTR.GIT_BRANCH] = branch;
   return meta;
 }
-function epochMs(ts) {
-  if (!ts) return 0;
-  if (/^\d+$/.test(ts)) return Number(ts);
-  const n = Date.parse(ts);
-  return Number.isNaN(n) ? 0 : n;
-}
-var msToNano = (iso2) => epochMs(iso2) * 1e6;
+var msToNano = (iso2) => parseIsoToEpochMs(iso2) * 1e6;
 function toTraceSpanEvents(spans, rootMeta) {
   return spans.map((s) => {
     const attributes = {};
@@ -1837,6 +1864,8 @@ function toTraceSpanEvents(spans, rootMeta) {
       if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") attributes[k] = v;
       else if (v != null) attributes[k] = JSON.stringify(v);
     }
+    attributes[ATTR.SESSION_ID] = s.trace_id;
+    attributes[ATTR.INGEST_SOURCE] = INGEST_SOURCE_CLI;
     if (s.parent_span_id === null) Object.assign(attributes, rootMeta);
     const startNano = msToNano(s.start_time);
     return {
@@ -1905,6 +1934,8 @@ export {
   serializeSpans,
   writeOtlpFile,
   analyzeSpans,
+  parseIsoToEpochMs,
+  parseSince,
   toRuntimeStore,
   runPipelines,
   AmpAdapter,
@@ -1920,7 +1951,12 @@ export {
   listAdapters,
   resolveAdapter,
   knownHarnesses,
+  selectAdapters,
+  scanSessions,
   watchSessions,
+  ATTR,
+  INGEST_SOURCE_CLI,
+  DEFAULT_HARNESS,
   CODING_REDACTION_RULES,
   TRACES_REDACTION_RULES,
   redactSpans,

package/dist/cli.js

@@ -3,13 +3,14 @@ import {
   analyzeSpans,
   executeUpload,
   knownHarnesses,
-  listAdapters,
+  parseSince,
   planUpload,
   resolveAdapter,
   runPipelines,
+  selectAdapters,
   watchSessions,
   writeOtlpFile
-} from "./chunk-YYVPAOOD.js";
+} from "./chunk-6NILXLUI.js";
 
 // src/cli.ts
 import { stat, writeFile } from "fs/promises";
@@ -163,18 +164,6 @@ function parseArgs(argv) {
   }
   return a;
 }
-function parseSince(s) {
-  if (!s) return Date.now() - 24 * 60 * 60 * 1e3;
-  const m = s.match(/^(\d+)\s*([mhd])$/i);
-  if (m) {
-    const unit = m[2].toLowerCase();
-    const ms = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
-    return Date.now() - Number(m[1]) * ms;
-  }
-  const t = Date.parse(s);
-  if (Number.isNaN(t)) throw new Error(`--since: expected 30m / 2h / 7d or an ISO date, got "${s}"`);
-  return t;
-}
 async function confirm(question) {
   if (!process.stdin.isTTY) return false;
   const rl = (await import("readline/promises")).createInterface({
@@ -189,12 +178,7 @@ async function confirm(question) {
   }
 }
 function adaptersFor(args) {
-  if (args.all) return [...listAdapters()];
-  const adapter = resolveAdapter(args.harness);
-  if (!adapter) {
-    throw new Error(`unknown harness "${args.harness}". Known: ${knownHarnesses().join(", ")}`);
-  }
-  return [adapter];
+  return selectAdapters({ all: args.all, harnesses: [args.harness] });
 }
 async function discover(args) {
   const sinceMs = args.since ? Date.parse(args.since) : void 0;
@@ -304,9 +288,14 @@ async function cmdWatch(args) {
   });
 }
 async function cmdUpload(args) {
-  const sinceMs = parseSince(args.since);
+  const sinceMs = args.since ? parseSince(args.since) : Date.now() - 24 * 60 * 60 * 1e3;
   const all = args.all || !args.harnessExplicit;
-  const plan = await planUpload({ all, harness: args.harness, cwd: args.cwd, sinceMs });
+  const plan = await planUpload({
+    all,
+    harnesses: args.harnessExplicit ? [args.harness] : void 0,
+    cwd: args.cwd,
+    sinceMs
+  });
   const newItems = plan.items.filter((i) => i.isNew);
   const byRule = {};
   let totalRedactions = 0;

package/dist/index.d.ts

@@ -118,6 +118,49 @@ interface HarnessTraceAdapter {
     parse(ref: SessionRef): Promise<OtlpSpan[]>;
 }
 
+/**
+ * Span-attribute keys the upload path stamps. The CLI is the producer; the
+ * Tangle Intelligence Platform is the consumer.
+ *
+ * `SESSION_ID` and `INGEST_SOURCE` are a cross-repo WIRE CONTRACT — the platform
+ * keys its cross-source dedup on them (`session.id`/`tangle.sessionId` linkage +
+ * `tangle.ingest_source === "cli"`). Do NOT change their string VALUES without a
+ * coordinated platform release. The rest are stored-but-not-parsed metadata,
+ * free to evolve.
+ *
+ * `SESSION_ID` stays camelCase because it must match agent-eval's
+ * `parseConversationLinkage` key list; the metadata keys are snake_case.
+ */
+declare const ATTR: {
+    /** = the trace/session id. Wire contract (dedup linkage). */
+    readonly SESSION_ID: "tangle.sessionId";
+    /** "cli" marks a CLI upload so the platform can drop a re-upload of a session
+     *  that also streamed live. Wire contract. */
+    readonly INGEST_SOURCE: "tangle.ingest_source";
+    readonly HARNESS: "tangle.harness";
+    readonly CWD: "tangle.cwd";
+    readonly GIT_BRANCH: "tangle.git_branch";
+    readonly HOST: "tangle.host";
+    /** Basename of the session file. (Renamed from the ambiguous `tangle.source`,
+     *  which collided with `tangle.ingest_source`.) */
+    readonly SESSION_FILE: "tangle.session_file";
+    readonly UPLOADED_AT: "tangle.uploaded_at";
+    readonly UPLOADER: "tangle.uploader";
+    readonly REDACTION_VERSION: "redaction.version";
+    readonly REDACTION_COUNT: "redaction.count";
+};
+/** `tangle.ingest_source` value for CLI-uploaded traces. Wire contract. */
+declare const INGEST_SOURCE_CLI = "cli";
+/** Harness used when none is specified on a single-harness command. */
+declare const DEFAULT_HARNESS = "claude-code";
+
+/** Parse an ISO-8601 timestamp or an epoch-millis string to epoch ms.
+ *  Returns 0 for empty/unparseable input (callers treat 0 as "unknown"). */
+declare function parseIsoToEpochMs(ts: string): number;
+/** Parse a `--since` window: `30m` / `2h` / `7d` (relative to now) or an ISO
+ *  date, → epoch ms. Throws on a malformed value (fail-loud, not silent). */
+declare function parseSince(value: string): number;
+
 /**
  * Harness adapter registry — resolves a harness id (or alias) to the
  * adapter that knows its on-disk session format.
@@ -134,6 +177,41 @@ interface HarnessTraceAdapter {
 declare function listAdapters(): readonly HarnessTraceAdapter[];
 declare function resolveAdapter(harness: string): HarnessTraceAdapter | undefined;
 declare function knownHarnesses(): string[];
+/** Options for selecting which adapters a command/SDK call operates on. */
+interface AdapterSelection {
+    /** Use these adapters verbatim (e.g. a caller's own harness) — wins over all. */
+    adapters?: readonly HarnessTraceAdapter[];
+    /** Every known harness. Implied when no `adapters`/`harnesses` are given. */
+    all?: boolean;
+    /** Specific harness ids/aliases. Unknown ids throw (fail-loud). */
+    harnesses?: readonly string[];
+}
+/** Resolve a selection to the adapters to operate on. Precedence:
+ *  explicit `adapters` → named `harnesses` → everything (`all` or unspecified).
+ *  A named harness that doesn't resolve throws rather than silently dropping. */
+declare function selectAdapters(opts: AdapterSelection): HarnessTraceAdapter[];
+
+interface ScanOptions extends AdapterSelection {
+    /** Filter by working directory (exact/prefix). */
+    cwd?: string;
+    /** Only sessions modified at/after this epoch ms. */
+    sinceMs?: number;
+    /** Cap to the most-recent N sessions per harness. */
+    last?: number;
+    /** Cancel the scan; iteration stops between sessions. */
+    signal?: AbortSignal;
+    /** Per-adapter locate/parse failure (the scan continues). */
+    onError?: (error: unknown, ref?: SessionRef) => void;
+}
+interface ScannedSession {
+    adapter: HarnessTraceAdapter;
+    ref: SessionRef;
+    /** Non-empty parsed spans for the session. */
+    spans: OtlpSpan[];
+}
+/** Yield every non-empty session across the selected adapters. Locate/parse
+ *  errors route to `onError` and skip that adapter/session, never aborting. */
+declare function scanSessions(opts: ScanOptions): AsyncGenerator<ScannedSession>;
 
 /**
  * Claude Code adapter — `~/.claude/projects/<encoded-cwd>/<session>.jsonl`.
@@ -537,22 +615,9 @@ declare function redactSpans(spans: readonly OtlpSpan[], rules?: RedactionRule[]
  * Redaction is ON by default — the safe posture when traces leave the box.
  */
 
-interface CollectOptions {
-    /** Harness ids/aliases. Omit (or `all: true`) → every harness. */
-    harnesses?: string[];
-    all?: boolean;
-    /** Collect from these adapters instead of the built-in registry. */
-    adapters?: HarnessTraceAdapter[];
-    /** Filter by working directory (exact/prefix). */
-    cwd?: string;
-    /** Only sessions modified at/after this epoch ms. */
-    sinceMs?: number;
-    /** Cap to the most-recent N sessions per harness. */
-    last?: number;
+interface CollectOptions extends ScanOptions {
     /** Redact PII/secrets (default true). Set false to get raw spans. */
     redact?: boolean;
-    /** Called on a per-adapter locate/parse failure (collection continues). */
-    onError?: (error: unknown, ref?: SessionRef) => void;
 }
 interface SessionBatch {
     ref: SessionRef;
@@ -617,16 +682,9 @@ interface UploadPlan {
     state: UploadState;
     sinceMs?: number;
 }
-interface PlanOptions {
-    harness?: string;
-    all?: boolean;
-    cwd?: string;
-    sinceMs?: number;
-    /** Called on a per-adapter locate/parse failure (planning continues). */
-    onError?: (error: unknown, ref?: SessionRef) => void;
-}
+type PlanOptions = ScanOptions;
 /** Read-only: select sessions in the window, redact, and mark which are new. */
-declare function planUpload(opts: PlanOptions): Promise<UploadPlan>;
+declare function planUpload(opts?: PlanOptions): Promise<UploadPlan>;
 /** Map redacted OtlpSpan[] → the hosted TraceSpanEvent[] wire shape, attaching
  *  session metadata to the root span(s). */
 declare function toTraceSpanEvents(spans: readonly OtlpSpan[], rootMeta: Record<string, string | number | boolean>): TraceSpanEvent[];
@@ -656,4 +714,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 { AmpAdapter, type AnalyzeOptions, type AnalyzeResult, CODING_REDACTION_RULES, ClaudeAdapter, CodexAdapter, type CollectOptions, CopilotAdapter, type ExecuteOptions, FactoryAdapter, ForgeAdapter, GeminiAdapter, type HarnessTraceAdapter, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, QwenAdapter, type RuntimeTrace, type SessionBatch, type SessionRef, type SpanInput, type SpanRedaction, TRACES_REDACTION_RULES, type UploadBackend, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, alreadyUploaded, analyzeSpans, collectSessions, executeUpload, knownHarnesses, listAdapters, loadState, planUpload, redactSpans, resolveAdapter, runPipelines, saveState, serializeSpans, sessionHash, span, toRuntimeStore, toTraceSpanEvents, uploadKey, watchSessions, writeOtlpFile };
+export { ATTR, AmpAdapter, type AnalyzeOptions, type AnalyzeResult, CODING_REDACTION_RULES, ClaudeAdapter, CodexAdapter, type CollectOptions, CopilotAdapter, DEFAULT_HARNESS, type ExecuteOptions, FactoryAdapter, ForgeAdapter, GeminiAdapter, type HarnessTraceAdapter, INGEST_SOURCE_CLI, type LocateOptions, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpSpan, type OtlpSpanKind, type OtlpStatusCode, PiAdapter, type PipelineOptions, type PipelineReport, type PlanOptions, QwenAdapter, type RuntimeTrace, type ScanOptions, type ScannedSession, type SessionBatch, type SessionRef, type SpanInput, type SpanRedaction, TRACES_REDACTION_RULES, type UploadBackend, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, alreadyUploaded, analyzeSpans, collectSessions, executeUpload, knownHarnesses, listAdapters, loadState, parseIsoToEpochMs, parseSince, planUpload, redactSpans, resolveAdapter, runPipelines, saveState, scanSessions, selectAdapters, serializeSpans, sessionHash, span, toRuntimeStore, toTraceSpanEvents, uploadKey, watchSessions, writeOtlpFile };

package/dist/index.js

@@ -1,12 +1,15 @@
 import {
+  ATTR,
   AmpAdapter,
   CODING_REDACTION_RULES,
   ClaudeAdapter,
   CodexAdapter,
   CopilotAdapter,
+  DEFAULT_HARNESS,
   FactoryAdapter,
   ForgeAdapter,
   GeminiAdapter,
+  INGEST_SOURCE_CLI,
   OpencodeAdapter,
   PiAdapter,
   QwenAdapter,
@@ -17,11 +20,15 @@ import {
   knownHarnesses,
   listAdapters,
   loadState,
+  parseIsoToEpochMs,
+  parseSince,
   planUpload,
   redactSpans,
   resolveAdapter,
   runPipelines,
   saveState,
+  scanSessions,
+  selectAdapters,
   serializeSpans,
   sessionHash,
   span,
@@ -30,45 +37,17 @@ import {
   uploadKey,
   watchSessions,
   writeOtlpFile
-} from "./chunk-YYVPAOOD.js";
+} from "./chunk-6NILXLUI.js";
 
 // src/collect.ts
-function adaptersFor(opts) {
-  if (opts.adapters && opts.adapters.length > 0) return opts.adapters;
-  if (opts.all || !opts.harnesses || opts.harnesses.length === 0) return [...listAdapters()];
-  const out = [];
-  for (const h of opts.harnesses) {
-    const a = resolveAdapter(h);
-    if (a && !out.includes(a)) out.push(a);
-  }
-  return out;
-}
 async function collectSessions(opts = {}) {
   const out = [];
-  for (const adapter of adaptersFor(opts)) {
-    let refs;
-    try {
-      refs = await adapter.locate({ cwd: opts.cwd, sinceMs: opts.sinceMs });
-    } catch (err) {
-      opts.onError?.(err);
-      continue;
-    }
-    if (opts.last && opts.last > 0) refs = refs.slice(0, opts.last);
-    for (const ref of refs) {
-      let spans;
-      try {
-        spans = await adapter.parse(ref);
-      } catch (err) {
-        opts.onError?.(err, ref);
-        continue;
-      }
-      if (spans.length === 0) continue;
-      if (opts.redact === false) {
-        out.push({ ref, spans });
-      } else {
-        const r = redactSpans(spans);
-        out.push({ ref, spans: r.spans, redaction: r.report });
-      }
+  for await (const { ref, spans } of scanSessions(opts)) {
+    if (opts.redact === false) {
+      out.push({ ref, spans });
+    } else {
+      const r = redactSpans(spans);
+      out.push({ ref, spans: r.spans, redaction: r.report });
     }
   }
   return out;
@@ -83,16 +62,19 @@ import {
 import { createHostedClient, hostedClientFromEnv } from "@tangle-network/agent-eval/hosted";
 import { DEFAULT_REDACTION_RULES, redactString, redactValue } from "@tangle-network/agent-eval/traces";
 export {
+  ATTR,
   AmpAdapter,
   AnalystRegistry,
   CODING_REDACTION_RULES,
   ClaudeAdapter,
   CodexAdapter,
   CopilotAdapter,
+  DEFAULT_HARNESS,
   DEFAULT_REDACTION_RULES,
   FactoryAdapter,
   ForgeAdapter,
   GeminiAdapter,
+  INGEST_SOURCE_CLI,
   OpencodeAdapter,
   PiAdapter,
   QwenAdapter,
@@ -108,6 +90,8 @@ export {
   listAdapters,
   loadState,
   makeFinding,
+  parseIsoToEpochMs,
+  parseSince,
   planUpload,
   redactSpans,
   redactString,
@@ -115,6 +99,8 @@ export {
   resolveAdapter,
   runPipelines,
   saveState,
+  scanSessions,
+  selectAdapters,
   serializeSpans,
   sessionHash,
   span,

package/package.json

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