@tangle-network/traces 0.8.27 → 0.9.0

package/dist/cli.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 import {
+  ACTOR_ATTR,
+  ATTR,
+  CORRUPTION_RECEIPT_DISPLAY_LIMIT,
   analyzeAdoption,
   analyzeReactions,
   analyzeSpans,
@@ -10,6 +13,7 @@ import {
   executeUpload,
   exportTraceEvidenceFile,
   haloAnalyzer,
+  indexSessionIdsByTrace,
   inspectSessionIndex,
   knownHarnesses,
   loadTracesConfig,
@@ -27,7 +31,7 @@ import {
   resolveAdapter,
   runExternalAnalyzers,
   runPipelines,
-  runTraceImprovementLoop,
+  runTraceImprovement,
   runTraceInvestigation,
   saveReport,
   selectAdapters,
@@ -35,6 +39,7 @@ import {
   serializeSessionIndex,
   serializeSpans,
   serializeTraceStreamEvent,
+  sessionIdFromAttributes,
   streamSessions,
   summarizeDeterministicSignals,
   traceStreamEventsFromSpans,
@@ -44,7 +49,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-EZDMNNW4.js";
+} from "./chunk-5SBXL62V.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
@@ -233,7 +238,41 @@ ${adapter.harness}: ${refs.length} session(s)`);
     }
   }
 }
+function selectedSessionSource(ref, spans, sessionIdOverride) {
+  const root = spans.find((item) => item.parent_span_id === null) ?? spans[0];
+  const prompt = spans.find(
+    (item) => item.name === "user.prompt" && item.attributes[ACTOR_ATTR] === "human"
+  ) ?? spans.find((item) => item.name === "user.prompt") ?? spans.find(
+    (item) => item.attributes["span.type"] === "interaction" && typeof item.attributes.content === "string"
+  );
+  const content = typeof prompt?.attributes.content === "string" ? prompt.attributes.content : "";
+  const firstLine = content.split(/\r?\n/, 1)[0].trim();
+  const subject = firstLine.length > 240 ? `${firstLine.slice(0, 240)}\u2026 [+${firstLine.length - 240} chars]` : firstLine;
+  const role = root?.attributes["traces.session.role"];
+  const parentSessionId = root?.attributes["traces.parent_session_id"];
+  const corruptionDigest = root?.attributes[ATTR.CORRUPTION_DIGEST];
+  const sessionId = [
+    sessionIdOverride,
+    root ? sessionIdFromAttributes(root.attributes) : void 0,
+    root?.trace_id,
+    ref.sessionId
+  ].find((value) => typeof value === "string" && value.length > 0);
+  return {
+    sessionId,
+    path: ref.path,
+    subject,
+    role: role === "operator" || role === "child" ? role : "unknown",
+    ...typeof parentSessionId === "string" ? { parentSessionId } : {},
+    integrity: ref.integrity?.status ?? "complete",
+    ...ref.integrity ? {
+      corruptionCount: ref.integrity.corruptions.length,
+      ...typeof corruptionDigest === "string" ? { corruptionDigest } : {},
+      corruptions: ref.integrity.corruptions.slice(0, CORRUPTION_RECEIPT_DISPLAY_LIMIT)
+    } : {}
+  };
+}
 async function collectSpans(args) {
+  if (args.input) return collectImportedSpans(args);
   if (args.session) {
     const adapter = resolveAdapter(args.harness);
     if (!adapter) throw new Error(`unknown harness "${args.harness}"`);
@@ -248,22 +287,28 @@ async function collectSpans(args) {
       mtimeMs: st.mtimeMs
     };
     const spans2 = await parseSession(adapter, ref);
-    return { spans: spans2, harness: adapter.harness, sessionCount: 1, cwds: ref.cwd ? [ref.cwd] : [] };
+    return {
+      spans: spans2,
+      harness: adapter.harness,
+      cwds: ref.cwd ? [ref.cwd] : [],
+      sources: [selectedSessionSource(ref, spans2)]
+    };
   }
   const groups = await discover({ ...args, last: args.last || 1 });
   const spans = [];
-  let sessionCount = 0;
   const harnesses = [];
   const cwds = [];
+  const sources = [];
   for (const { adapter, refs } of groups) {
     if (refs.length > 0) harnesses.push(adapter.harness);
     for (const ref of refs) {
-      spans.push(...await parseSession(adapter, ref));
+      const parsed = await parseSession(adapter, ref);
+      spans.push(...parsed);
+      sources.push(selectedSessionSource(ref, parsed));
       if (ref.cwd) cwds.push(ref.cwd);
-      sessionCount += 1;
     }
   }
-  return { spans, harness: harnesses.join("+") || args.harness, sessionCount, cwds };
+  return { spans, harness: harnesses.join("+") || args.harness, cwds, sources };
 }
 async function cmdConvert(args) {
   const { spans } = await collectSpans(args);
@@ -393,10 +438,10 @@ async function loadExportAttributes(args) {
   return attributes;
 }
 async function cmdAnalyze(args) {
-  const { spans, harness, sessionCount, cwds } = args.input ? await collectImportedSpans(args) : await collectSpans(args);
+  const { spans, harness, cwds, sources } = 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, {
+  const { otlpPath, execution, result } = await analyzeSpans(spans, {
     ai,
     model: args.model,
     budgetUsd: args.budget,
@@ -408,7 +453,16 @@ async function cmdAnalyze(args) {
   const reactions = analyzeReactions(spans);
   const adoption = await analyzeAdoption(spans, { cwds });
   const deterministic = summarizeDeterministicSignals(pipelines, reactions);
-  let report = `${renderReport(result, { harness, sessionCount, spanCount: spans.length, otlpPath, deterministic })}
+  let report = `${renderReport(result, {
+    harness,
+    sessionCount: adoption.identifiedSessionCount,
+    unassignedTraceCount: adoption.unassignedTraceCount,
+    spanCount: spans.length,
+    otlpPath,
+    execution,
+    deterministic,
+    sources
+  })}
 ${renderPipelines(pipelines)}
 ${renderReactions(reactions)}
 ${renderAdoption(adoption)}`;
@@ -425,24 +479,40 @@ ${r.ok ? r.output || "(no output)" : `failed: ${r.error}`}`;
   }
   if (args.out) {
     await writeFile(args.out, report, "utf8");
-    console.log(`report \u2192 ${args.out}  (${result.findings.length} findings, ${pipelines.stuckLoops.findings.length} loops, OTLP: ${otlpPath})`);
+    console.log(
+      `report \u2192 ${args.out}  (${result.findings.length} findings, ${pipelines.stuckLoops.findings.length} loops, OTLP: ${otlpPath})`
+    );
   } else {
     console.log(report);
   }
 }
 async function collectImportedSpans(args) {
-  if (!args.input) throw new Error("analyze input missing");
+  if (!args.input) throw new Error("input file 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));
+  const { sessionByTrace } = indexSessionIdsByTrace(result.spans);
+  const sessions = /* @__PURE__ */ new Map();
+  for (const span of result.spans) {
+    const sessionId = sessionByTrace.get(span.trace_id);
+    if (!sessionId) continue;
+    const grouped = sessions.get(sessionId) ?? [];
+    grouped.push(span);
+    sessions.set(sessionId, grouped);
+  }
   return {
     spans: result.spans,
     harness: result.format,
-    sessionCount: traceIds.size || 1,
-    cwds: []
+    cwds: [],
+    sources: [...sessions].map(([sessionId, spans]) => selectedSessionSource({
+      harness: result.format,
+      sessionId,
+      path: args.input,
+      cwd: null,
+      mtimeMs: 0
+    }, spans, sessionId))
   };
 }
 function externalAnalyzersFromArgs(args) {
@@ -451,14 +521,14 @@ function externalAnalyzersFromArgs(args) {
   );
 }
 async function cmdInvestigate(args) {
-  const { spans, harness, sessionCount, cwds } = await collectSpans(args);
+  const { spans, harness, cwds, sources } = await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const config = await loadTracesConfig(args.config);
   const ai = args.llm ? await buildAxService() : void 0;
   const result = await runTraceInvestigation(mergeTracesConfig({
     spans,
     harness,
-    sessionCount,
+    sources,
     cwds,
     minLoopOccurrences: args.minLoop,
     ai,
@@ -472,21 +542,21 @@ async function cmdInvestigate(args) {
   }, config));
   if (args.out) {
     await saveReport(args.out, result.report);
-    console.log(`investigation report \u2192 ${args.out}  (${result.findings.length} findings, ${result.recommendations.length} recommendations, OTLP: ${result.otlpPath})`);
+    console.log(`investigation report \u2192 ${args.out}  (${result.findings.length} findings with actions, OTLP: ${result.otlpPath})`);
   } else {
     console.log(result.report);
   }
 }
 async function cmdImprove(args) {
-  const { spans, harness, sessionCount, cwds } = await collectSpans(args);
+  const { spans, harness, cwds, sources } = await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const config = await loadTracesConfig(args.config);
   const ai = args.llm ? await buildAxService() : void 0;
-  const result = await runTraceImprovementLoop({
+  const result = await runTraceImprovement({
     ...mergeTracesConfig({
       spans,
       harness,
-      sessionCount,
+      sources,
       cwds,
       minLoopOccurrences: args.minLoop,
       ai,
@@ -498,13 +568,12 @@ async function cmdImprove(args) {
       log: (msg) => process.stderr.write(`${msg}
 `)
     }, config),
-    adapter: config?.improvementAdapter,
     outDir: args.dir ?? args.out
   });
   const dir = result.artifacts?.directory;
   if (!dir) throw new Error("improve did not produce an artifact directory");
   console.log(
-    `improvement artifacts \u2192 ${dir}  (${result.findings.length} findings, ${result.recommendations.length} recommendations, ${result.proposals.length} proposal(s), OTLP: ${result.otlpPath})`
+    `improvement artifacts \u2192 ${dir}  (${result.findings.length} findings with actions and checks, OTLP: ${result.otlpPath})`
   );
 }
 function summarizeFindingEvidence(finding) {
@@ -660,10 +729,10 @@ async function cmdUpload(args) {
   });
   const redactorParts = args.redactorCmd?.split(/\s+/).filter(Boolean) ?? [];
   const redactor = redactorParts[0] ? commandRedactor({ command: redactorParts[0], args: redactorParts.slice(1) }) : void 0;
-  const newItems = plan.items.filter((i) => i.isNew);
+  const candidates = plan.items;
   const byRule = {};
   let totalRedactions = 0;
-  for (const i of newItems) {
+  for (const i of candidates) {
     totalRedactions += i.redaction.redactionCount;
     for (const [r, n] of Object.entries(i.redaction.byRule)) byRule[r] = (byRule[r] ?? 0) + n;
   }
@@ -671,28 +740,28 @@ async function cmdUpload(args) {
   w(`
 Window: since ${new Date(sinceMs).toISOString()}
 `);
-  w(`Sessions found: ${plan.items.length}  \xB7  new: ${newItems.length}  \xB7  already uploaded: ${plan.items.length - newItems.length}
+  w(`Sessions found: ${plan.items.length}  \xB7  final privacy-mode dedup runs before upload
 `);
   w(`PII/secrets redacted: ${totalRedactions}${Object.keys(byRule).length ? ` (${Object.entries(byRule).map(([r, n]) => `${r}:${n}`).join(", ")})` : ""}
 `);
-  for (const i of newItems.slice(0, 25)) {
+  for (const i of candidates.slice(0, 25)) {
     w(`  + [${i.ref.harness}] ${i.ref.sessionId.slice(0, 8)}  ${i.spans.length} spans  ${i.redaction.redactionCount} redacted  ${i.ref.cwd ?? ""}
 `);
   }
-  if (newItems.length > 25) w(`  \u2026 and ${newItems.length - 25} more
+  if (candidates.length > 25) w(`  \u2026 and ${candidates.length - 25} more
 `);
-  if (newItems.length === 0) {
-    console.log("Nothing new to upload.");
+  if (candidates.length === 0) {
+    console.log("No sessions found to upload.");
     return;
   }
   if (args.dryRun) {
     const res2 = await executeUpload(plan, { dryRun: true, otlpOut: args.otlp, stripContent: args.noContent, redactor });
-    console.log(`dry run: ${newItems.length} session(s), ${totalRedactions} redaction(s). Redacted OTLP -> ${res2.otlpPath}`);
+    console.log(`dry run: ${candidates.length - res2.skippedSessions} 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;
   }
   if (!args.yes) {
-    const ok = await confirm(`Upload ${newItems.length} redacted session(s) to the Tangle Intelligence Platform?`);
+    const ok = await confirm(`Process ${candidates.length} redacted session(s) for upload to the Tangle Intelligence Platform?`);
     if (!ok) {
       console.log("Aborted (use --yes to skip the prompt, or --dry-run to preview).");
       return;
@@ -738,8 +807,8 @@ function usage() {
 Commands:
   list      List discovered sessions
   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
+  investigate Run typed investigation flow, including BYO config + evidence-backed actions
+  improve   Write findings, evidence, report, and canonical trace artifacts
   convert   Emit OTLP-JSONL only (HALO: use analyze --analyzer halo)
   index     Emit a reusable session index JSON for later investigation
   inspect   Read a session index and print ranked improvement findings
@@ -768,7 +837,7 @@ Options:
   --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/stream: JS config with analysts, liveAnalysts, external analyzers, or proposal adapter
+  --config <path>  investigate/improve/stream: JS config with analysts, liveAnalysts, or external analyzers
   --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)