@tangle-network/traces 0.8.16 → 0.8.18

package/dist/{chunk-EOQY2RIK.js → chunk-G3OBZSWY.js}

@@ -751,10 +751,10 @@ var ClaudeAdapter = class {
     let step = main.nextStep;
     for (const f of files) {
       if (!f.endsWith(".jsonl")) continue;
-      const hash = basename2(f, ".jsonl");
+      const hash2 = basename2(f, ".jsonl");
       let meta = {};
       try {
-        meta = JSON.parse(await readFile3(join3(subDir, `${hash}.meta.json`), "utf8"));
+        meta = JSON.parse(await readFile3(join3(subDir, `${hash2}.meta.json`), "utf8"));
       } catch {
       }
       const parent = meta.toolUseId && main.toolSpanByUseId.get(meta.toolUseId)?.span_id || `root:${traceId}`;
@@ -768,7 +768,7 @@ var ClaudeAdapter = class {
         traceId,
         agent: meta.agentType ? `subagent:${meta.agentType}` : "subagent",
         startStep: step,
-        idPrefix: `${hash}:`,
+        idPrefix: `${hash2}:`,
         rootParent: parent
       });
       out.push(...parsed.spans);
@@ -2286,13 +2286,13 @@ function extractAbsolutePaths(spans) {
   let scannedChars = 0;
   for (const span2 of spans) {
     for (const value of [span2.name, span2.status.message, ...Object.values(span2.attributes)]) {
-      for (const evidence2 of pathsFromUnknown(value)) {
-        scannedChars += evidence2.path.length;
+      for (const evidence3 of pathsFromUnknown(value)) {
+        scannedChars += evidence3.path.length;
         if (scannedChars > MAX_SPAN_TEXT_CHARS) return paths;
-        const key = `${evidence2.source}:${evidence2.path}`;
+        const key = `${evidence3.source}:${evidence3.path}`;
         if (seen.has(key)) continue;
         seen.add(key);
-        paths.push(evidence2);
+        paths.push(evidence3);
         if (paths.length >= MAX_SPAN_PATH_CANDIDATES) return paths;
       }
     }
@@ -2346,8 +2346,8 @@ async function resolveSessionRepoAttrs(cwd, spans) {
     add(await repairDashedPath(cwd), "repaired-cwd");
     add(cwd, "ref-cwd");
   }
-  for (const evidence2 of extractAbsolutePaths(spans)) {
-    add(await repoCandidateForPath(evidence2.path), evidence2.source, evidence2.weight);
+  for (const evidence3 of extractAbsolutePaths(spans)) {
+    add(await repoCandidateForPath(evidence3.path), evidence3.source, evidence3.weight);
   }
   const resolved = [];
   for (const candidate of candidates.values()) {
@@ -2492,9 +2492,9 @@ async function buildPolicyEvidenceRecord(ref, spans, opts = {}) {
     signals: {
       stuckLoopCount: loopFindings.length,
       affectedRunRatio: pipelines.stuckLoops.affectedRunRatio,
-      stuckLoops: loopFindings.slice(0, loopLimit).map((finding) => ({
-        toolName: finding.toolName,
-        occurrences: finding.occurrences
+      stuckLoops: loopFindings.slice(0, loopLimit).map((finding2) => ({
+        toolName: finding2.toolName,
+        occurrences: finding2.occurrences
       })),
       stuckLoopsOmitted: Math.max(0, loopFindings.length - loopLimit),
       toolErrorRate: toolSpans.length === 0 ? 0 : erroredToolCallCount / toolSpans.length
@@ -2726,7 +2726,9 @@ function hashId(value, chars = 16) {
 }
 function isoTime(value) {
   if (typeof value === "string") {
-    const ms = Date.parse(value);
+    const trimmed = value.trim();
+    const normalized = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed) ? `${trimmed.replace(" ", "T")}Z` : trimmed;
+    const ms = Date.parse(normalized);
     return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
   }
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -2768,14 +2770,19 @@ function parseJsonRows(text) {
   const trimmed = text.trim();
   if (!trimmed) throw new Error("input file is empty");
   if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
-    const parsed = JSON.parse(trimmed);
-    if (Array.isArray(parsed)) return { rows: parsed };
-    if (isObject(parsed)) {
-      const events = parsed.events;
-      if (Array.isArray(events)) return { rows: events, wrapper: parsed };
-      return { rows: [parsed] };
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return { rows: parsed };
+      if (isObject(parsed)) {
+        const events = parsed.events;
+        if (Array.isArray(events)) return { rows: events, wrapper: parsed };
+        return { rows: [parsed] };
+      }
+      throw new Error("input JSON must be an object, array, or JSONL rows");
+    } catch (error) {
+      const hasMultipleRows = /\r?\n/.test(trimmed);
+      if (!hasMultipleRows) throw error;
     }
-    throw new Error("input JSON must be an object, array, or JSONL rows");
   }
   return {
     rows: trimmed.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line))
@@ -2788,6 +2795,10 @@ function isOpenInferenceRow(row) {
   if (!isObject(row)) return false;
   return typeof row.trace_id === "string" && typeof row.span_id === "string" && typeof row.name === "string" && typeof row.start_time === "string" && typeof row.end_time === "string" && isObject(row.status) && isObject(row.attributes) && isObject(row.resource) && isObject(row.scope);
 }
+function isIntelligenceSpanRow(row) {
+  if (!isObject(row)) return false;
+  return typeof row.trace_id === "string" && typeof row.name === "string" && isObject(row.attributes) && (row.start_unix_nano != null || row.start_time != null || row.received_at != null);
+}
 function eventType(row) {
   return stringValue(row.type) ?? stringValue(row.event) ?? stringValue(row.name) ?? stringValue(row.kind);
 }
@@ -2801,8 +2812,9 @@ function detectFormat(rows, requested) {
   if (rows.length === 0) throw new Error("input contains no rows");
   if (rows.every(isPolicyEvidenceRow)) return "policy-evidence";
   if (rows.every(isOpenInferenceRow)) return "openinference";
+  if (rows.every(isIntelligenceSpanRow)) return "intelligence-spans";
   if (rows.some(looksLikeSandboxEvent)) return "sandbox-events";
-  throw new Error("could not detect input format; use --format policy-evidence, sandbox-events, or openinference");
+  throw new Error("could not detect input format; use --format policy-evidence, sandbox-events, openinference, or intelligence-spans");
 }
 function requirePolicyEvidenceRows(rows) {
   if (!rows.every(isPolicyEvidenceRow)) throw new Error("policy-evidence input must contain only traces.policy_evidence.session rows");
@@ -2812,6 +2824,10 @@ function requireOpenInferenceRows(rows) {
   if (!rows.every(isOpenInferenceRow)) throw new Error("openinference input must contain only complete OpenInference span rows");
   return rows;
 }
+function requireIntelligenceSpanRows(rows) {
+  if (!rows.every(isIntelligenceSpanRow)) throw new Error("intelligence-spans input must contain only Intelligence span rows");
+  return rows;
+}
 function requireObjectRows(rows) {
   if (!rows.every(isObject)) throw new Error("sandbox-events input must contain only JSON object events");
   return rows;
@@ -3008,6 +3024,112 @@ function sandboxEventsToSpans(rows, wrapper) {
 function statusCode(value) {
   return value === "OK" || value === "ERROR" || value === "UNSET" ? value : "UNSET";
 }
+function numberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function unixNanoTime(value) {
+  if (value == null) return void 0;
+  try {
+    const ns = typeof value === "bigint" ? value : BigInt(String(value));
+    return new Date(Number(ns / 1000000n)).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function firstNumber(row, attrs, keys) {
+  for (const key of keys) {
+    const value = numberValue(row[key]) ?? numberValue(attrs[key]);
+    if (value != null) return value;
+  }
+  return void 0;
+}
+var COMPUTED_SPAN_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "openinference.span.kind",
+  "service.name",
+  "agent.name",
+  "llm.model_name",
+  "tool.name",
+  "llm.input_tokens",
+  "llm.output_tokens",
+  "step",
+  "content"
+]);
+function preserveRawAttributes(attrs) {
+  const preserved = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (COMPUTED_SPAN_ATTRIBUTES.has(key)) {
+      preserved[`traces.raw_attribute.${key}`] = value;
+    } else {
+      preserved[key] = value;
+    }
+  }
+  return preserved;
+}
+function intelligenceSpanKind(name, attrs) {
+  const lowered = name.toLowerCase();
+  const spanType = stringValue(attrs["span.type"])?.toLowerCase();
+  if (spanType === "llm_request" || lowered.includes("llm")) return "LLM";
+  if (spanType === "tool" || lowered.includes("tool") || attrs["tool.name"] != null || attrs.tool_name != null || attrs["mcp.tool.name"] != null || attrs["tool.input"] != null || attrs["tool.output"] != null) {
+    return "TOOL";
+  }
+  if (spanType === "interaction" || lowered.includes("interaction") || lowered.includes("agent")) return "AGENT";
+  return "CHAIN";
+}
+function intelligenceSpansToSpans(rows) {
+  return rows.map((row, index) => {
+    const attrs = { ...objectValue(row.attributes) ?? {} };
+    const name = stringValue(row.name) ?? "intelligence.span";
+    const startTime = unixNanoTime(row.start_unix_nano) ?? isoTime(row.start_time) ?? stringValue(row.start_time) ?? isoTime(row.received_at) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    const endTime = unixNanoTime(row.end_unix_nano) ?? isoTime(row.end_time) ?? stringValue(row.end_time) ?? startTime;
+    const model = stringValue(row.model) ?? stringValue(attrs["llm.model_name"]) ?? stringValue(attrs.model) ?? stringValue(attrs["gen_ai.request.model"]);
+    const tool = stringValue(attrs["tool.name"]) ?? stringValue(attrs.tool_name) ?? stringValue(attrs["mcp.tool.name"]);
+    const sessionId = stringValue(row.session_id) ?? stringValue(attrs["session.id"]);
+    const extra = {
+      ...preserveRawAttributes(attrs),
+      "traces.source_format": "intelligence-spans",
+      "traces.row.index": index
+    };
+    copyDefined(extra, {
+      "traces.row.id": stringValue(row.id),
+      [ATTR.SESSION_ID]: sessionId,
+      "session.id": sessionId,
+      "run.id": stringValue(row.run_id),
+      "thread.id": stringValue(row.thread_id),
+      "scenario.id": stringValue(row.scenario_id),
+      "generation.id": stringValue(row.generation),
+      "cell.id": stringValue(row.cell_id),
+      "project.key": stringValue(row.project_key),
+      "llm.cost_usd": numberValue(row.cost_usd),
+      "redaction.version": stringValue(row.redaction_version),
+      "traces.received_at": isoTime(row.received_at)
+    });
+    return span({
+      traceId: stringValue(row.trace_id) ?? hashId(row, 32),
+      spanId: stringValue(row.id) ?? hashId({ row, field: "span" }),
+      parentSpanId: stringValue(row.parent_span_id) ?? null,
+      name,
+      kind: intelligenceSpanKind(name, attrs),
+      startTime,
+      endTime,
+      status: statusCode(row.status_code),
+      statusMessage: stringValue(row.status_message),
+      service: stringValue(attrs["service.name"]) ?? stringValue(attrs.service_name) ?? "tangle-intelligence",
+      agent: stringValue(attrs["agent.name"]) ?? stringValue(attrs["service.name"]) ?? null,
+      model,
+      tool,
+      inputTokens: firstNumber(row, attrs, ["input_tokens", "llm.input_tokens"]),
+      outputTokens: firstNumber(row, attrs, ["output_tokens", "llm.output_tokens"]),
+      step: numberValue(attrs["interaction.sequence"]) ?? index,
+      content: stringValue(attrs.user_prompt) ?? stringValue(attrs["gen_ai.prompt.messages"]) ?? stringValue(attrs["log.content.task"]) ?? null,
+      extra
+    });
+  });
+}
 function openInferenceToSpans(rows) {
   return rows.map((row) => {
     const attrs = isObject(row.attributes) ? { ...row.attributes } : {};
@@ -3053,7 +3175,7 @@ function withExportAttributes(spans, attributes) {
 }
 function exportTraceEvidenceRows(rows, opts = {}, wrapper) {
   const format = detectFormat(rows, opts.format ?? "auto");
-  const converted = format === "policy-evidence" ? policyEvidenceToSpans(requirePolicyEvidenceRows(rows)) : format === "openinference" ? openInferenceToSpans(requireOpenInferenceRows(rows)) : sandboxEventsToSpans(requireObjectRows(rows), wrapper);
+  const converted = format === "policy-evidence" ? policyEvidenceToSpans(requirePolicyEvidenceRows(rows)) : format === "openinference" ? openInferenceToSpans(requireOpenInferenceRows(rows)) : format === "intelligence-spans" ? intelligenceSpansToSpans(requireIntelligenceSpanRows(rows)) : sandboxEventsToSpans(requireObjectRows(rows), wrapper);
   const spans = withExportAttributes(converted, opts.attributes);
   if (spans.length === 0) throw new Error(`no spans exported from ${format} input`);
   const redacted = redactSpans(spans);
@@ -3113,12 +3235,12 @@ function topLoopTools(row) {
     current.maxOccurrences = Math.max(current.maxOccurrences, loop.occurrences);
     byTool.set(loop.toolName, current);
   }
-  const loops = [...byTool.entries()].sort(([, a], [, b]) => b.groups - a.groups || b.maxOccurrences - a.maxOccurrences).slice(0, 3).map(([toolName2, stats]) => `${toolName2} ${stats.groups} group(s), max x${stats.maxOccurrences}`);
+  const loops = [...byTool.entries()].sort(([, a], [, b]) => b.groups - a.groups || b.maxOccurrences - a.maxOccurrences).slice(0, 3).map(([toolName3, stats]) => `${toolName3} ${stats.groups} group(s), max x${stats.maxOccurrences}`);
   const suffix = row.signals.stuckLoopsOmitted > 0 ? `, +${row.signals.stuckLoopsOmitted} omitted` : "";
   return loops.length > 0 ? `${loops.join(", ")}${suffix}` : `${row.signals.stuckLoopCount} loop(s)`;
 }
 function sortFindings(findings) {
-  return findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.impact - a.impact || a.id.localeCompare(b.id)).map((finding) => ({ ...finding }));
+  return findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] || b.impact - a.impact || a.id.localeCompare(b.id)).map((finding2) => ({ ...finding2 }));
 }
 function contextSourceCounts(index) {
   return { contextFiles: allContextFiles(index).length };
@@ -3313,9 +3435,9 @@ function inspectSessionIndex(index, opts = {}) {
     },
     totals: {
       findings: ranked.length,
-      high: ranked.filter((finding) => finding.severity === "high").length,
-      medium: ranked.filter((finding) => finding.severity === "medium").length,
-      low: ranked.filter((finding) => finding.severity === "low").length
+      high: ranked.filter((finding2) => finding2.severity === "high").length,
+      medium: ranked.filter((finding2) => finding2.severity === "medium").length,
+      low: ranked.filter((finding2) => finding2.severity === "low").length
     },
     findings: ranked
   };
@@ -3334,16 +3456,16 @@ function renderInspectionReport(report) {
     return `${lines.join("\n")}
 `;
   }
-  report.findings.forEach((finding, i) => {
+  report.findings.forEach((finding2, i) => {
     lines.push("");
-    lines.push(`## ${i + 1}. [${finding.severity}] ${finding.title}`);
-    lines.push(`Area: ${finding.area}  Impact: ${finding.impact}`);
+    lines.push(`## ${i + 1}. [${finding2.severity}] ${finding2.title}`);
+    lines.push(`Area: ${finding2.area}  Impact: ${finding2.impact}`);
     lines.push("Evidence:");
-    for (const item of finding.evidence) lines.push(`- ${item}`);
-    lines.push(`Next: ${finding.next}`);
-    if (finding.refs && finding.refs.length > 0) {
+    for (const item of finding2.evidence) lines.push(`- ${item}`);
+    lines.push(`Next: ${finding2.next}`);
+    if (finding2.refs && finding2.refs.length > 0) {
       lines.push("Refs:");
-      for (const ref of finding.refs.slice(0, 5)) lines.push(`- ${ref}`);
+      for (const ref of finding2.refs.slice(0, 5)) lines.push(`- ${ref}`);
     }
   });
   return `${lines.join("\n")}
@@ -3804,55 +3926,55 @@ function normalizeExternalFindings(results) {
   for (const result of results) {
     if (result.findings) out.push(...result.findings);
     externalRows(result.output).forEach((row, index) => {
-      const finding = coerceExternalFinding(result.analyzer, row, index);
-      if (finding) out.push(finding);
+      const finding2 = coerceExternalFinding(result.analyzer, row, index);
+      if (finding2) out.push(finding2);
     });
   }
   return out;
 }
-function sourceOf(finding) {
-  if (finding.analyst_id.startsWith("external:")) return "external";
-  if (finding.analyst_id === "traces-deterministic") return "deterministic";
+function sourceOf(finding2) {
+  if (finding2.analyst_id.startsWith("external:")) return "external";
+  if (finding2.analyst_id === "traces-deterministic") return "deterministic";
   return "analyst";
 }
-function recommendationTitle(finding) {
-  if (finding.recommended_action) return finding.recommended_action.replace(/\.$/, "");
-  return `Investigate ${finding.area}: ${finding.claim}`.replace(/\.$/, "");
+function recommendationTitle(finding2) {
+  if (finding2.recommended_action) return finding2.recommended_action.replace(/\.$/, "");
+  return `Investigate ${finding2.area}: ${finding2.claim}`.replace(/\.$/, "");
 }
 function buildRecommendations(findings) {
-  return [...findings].filter((finding) => finding.severity !== "info").sort((a, b) => severityRank2[a.severity] - severityRank2[b.severity] || b.confidence - a.confidence || a.finding_id.localeCompare(b.finding_id)).slice(0, 20).map((finding, index) => ({
+  return [...findings].filter((finding2) => finding2.severity !== "info").sort((a, b) => severityRank2[a.severity] - severityRank2[b.severity] || b.confidence - a.confidence || a.finding_id.localeCompare(b.finding_id)).slice(0, 20).map((finding2, index) => ({
     schemaVersion: 1,
-    id: `rec-${index + 1}-${slug(finding.area)}`,
-    severity: finding.severity,
-    title: recommendationTitle(finding),
-    action: finding.recommended_action ?? `Review and fix: ${finding.claim}`,
-    rationale: finding.rationale ?? finding.claim,
-    evidenceRefs: finding.evidence_refs,
-    findingIds: [finding.finding_id],
-    validationPlan: finding.validation_plan ?? "Rerun `traces improve` on a fresh comparable session window and confirm this finding disappears or drops in severity.",
-    source: sourceOf(finding)
+    id: `rec-${index + 1}-${slug(finding2.area)}`,
+    severity: finding2.severity,
+    title: recommendationTitle(finding2),
+    action: finding2.recommended_action ?? `Review and fix: ${finding2.claim}`,
+    rationale: finding2.rationale ?? finding2.claim,
+    evidenceRefs: finding2.evidence_refs,
+    findingIds: [finding2.finding_id],
+    validationPlan: finding2.validation_plan ?? "Rerun `traces improve` on a fresh comparable session window and confirm this finding disappears or drops in severity.",
+    source: sourceOf(finding2)
   }));
 }
 function buildClaims(findings) {
-  return findings.map((finding, index) => ({
+  return findings.map((finding2, index) => ({
     schemaVersion: 1,
-    id: `claim-${index + 1}-${slug(finding.area)}`,
-    severity: finding.severity,
-    text: finding.claim,
-    area: finding.area,
-    sourceFindingId: finding.finding_id,
-    evidenceRefs: finding.evidence_refs,
-    validationPlan: finding.validation_plan
+    id: `claim-${index + 1}-${slug(finding2.area)}`,
+    severity: finding2.severity,
+    text: finding2.claim,
+    area: finding2.area,
+    sourceFindingId: finding2.finding_id,
+    evidenceRefs: finding2.evidence_refs,
+    validationPlan: finding2.validation_plan
   }));
 }
 function buildEvidenceRows(findings) {
-  return findings.flatMap((finding) => finding.evidence_refs.map((ref) => ({
+  return findings.flatMap((finding2) => finding2.evidence_refs.map((ref) => ({
     schemaVersion: 1,
     kind: "traces.improvement_evidence",
-    findingId: finding.finding_id,
-    severity: finding.severity,
-    area: finding.area,
-    claim: finding.claim,
+    findingId: finding2.finding_id,
+    severity: finding2.severity,
+    area: finding2.area,
+    claim: finding2.claim,
     evidence: ref
   })));
 }
@@ -3884,14 +4006,14 @@ function renderFindingPacket(packet, title = "Trace finding packet") {
   if (packet.findings.length > 0) {
     lines.push("## findings");
     lines.push("");
-    for (const finding of [...packet.findings].sort((a, b) => severityRank2[a.severity] - severityRank2[b.severity] || a.area.localeCompare(b.area) || a.claim.localeCompare(b.claim))) {
-      lines.push(`### ${finding.severity.toUpperCase()} \u2014 ${finding.claim}`);
+    for (const finding2 of [...packet.findings].sort((a, b) => severityRank2[a.severity] - severityRank2[b.severity] || a.area.localeCompare(b.area) || a.claim.localeCompare(b.claim))) {
+      lines.push(`### ${finding2.severity.toUpperCase()} \u2014 ${finding2.claim}`);
       lines.push("");
-      lines.push(`- **Area:** ${finding.area}`);
-      lines.push(`- **Analyst:** ${finding.analyst_id}`);
-      if (finding.recommended_action) lines.push(`- **Action:** ${finding.recommended_action}`);
-      if (finding.validation_plan) lines.push(`- **Check:** ${finding.validation_plan}`);
-      for (const ref of finding.evidence_refs.slice(0, 3)) {
+      lines.push(`- **Area:** ${finding2.area}`);
+      lines.push(`- **Analyst:** ${finding2.analyst_id}`);
+      if (finding2.recommended_action) lines.push(`- **Action:** ${finding2.recommended_action}`);
+      if (finding2.validation_plan) lines.push(`- **Check:** ${finding2.validation_plan}`);
+      for (const ref of finding2.evidence_refs.slice(0, 3)) {
         lines.push(`- **Evidence:** ${ref.kind} ${ref.uri}${ref.excerpt ? ` \u2014 \`${ref.excerpt.slice(0, 180)}\`` : ""}`);
       }
       lines.push("");
@@ -4120,8 +4242,16 @@ async function saveReport(path, report) {
   await writeFile4(path, report, "utf8");
 }
 
-// src/observer.ts
+// src/live.ts
+import { createHash as createHash2 } from "crypto";
+var VERIFY_RE = /\b(test|tests|vitest|jest|pytest|go test|cargo test|tsc|typecheck|lint|biome|eslint|build|check:invariants|preflight)\b/i;
+var CHANGE_RE = /\b(apply_patch|edit|write|create|delete|rename|replace|update|git apply|sed -i|perl -pi|tee\s|cat\s+>)/i;
+var CLAIM_DONE_RE = /\b(done|fixed|complete|completed|implemented|merged|verified|all green|tests pass|ready|works now)\b/i;
 var sleep = (ms, signal) => new Promise((resolve2) => {
+  if (signal?.aborted) {
+    resolve2();
+    return;
+  }
   const onAbort = () => {
     clearTimeout(t);
     resolve2();
@@ -4132,14 +4262,329 @@ var sleep = (ms, signal) => new Promise((resolve2) => {
   }, ms);
   signal?.addEventListener("abort", onAbort, { once: true });
 });
-function loopKey(sessionId, toolName2, argHash) {
-  return `${sessionId}\0${toolName2}\0${argHash}`;
+function hash(parts) {
+  return createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, 16);
+}
+function asString(value) {
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return void 0;
+}
+function spanKind2(span2) {
+  return asString(span2.attributes["openinference.span.kind"])?.toUpperCase() ?? "SPAN";
+}
+function spanContent(span2) {
+  return asString(span2.attributes.content) ?? asString(span2.attributes["input.value"]) ?? asString(span2.attributes["llm.input"]) ?? asString(span2.attributes["gen_ai.prompt"]) ?? "";
+}
+function toolName2(span2) {
+  return asString(span2.attributes["tool.name"]) ?? span2.name.replace(/^tool\./, "");
+}
+function toolSignature(span2) {
+  const content = spanContent(span2).replace(/\s+/g, " ").trim();
+  return `${toolName2(span2)}:${content || span2.name}`;
+}
+function isTool(span2) {
+  return spanKind2(span2) === "TOOL" || span2.attributes["tool.name"] != null || span2.name.startsWith("tool.");
+}
+function isTextSpan(span2) {
+  return !isTool(span2) && spanContent(span2).length > 0;
+}
+function isVerification(span2) {
+  if (!isTool(span2)) return false;
+  return VERIFY_RE.test(`${toolName2(span2)} ${span2.name} ${spanContent(span2)}`);
+}
+function isChange(span2) {
+  if (!isTool(span2)) return false;
+  return CHANGE_RE.test(`${toolName2(span2)} ${span2.name} ${spanContent(span2)}`);
+}
+function timeOf(span2) {
+  const parsed = Date.parse(span2.start_time);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function orderSpans(spans) {
+  return [...spans].sort((a, b) => {
+    const stepA = typeof a.attributes.step === "number" ? a.attributes.step : void 0;
+    const stepB = typeof b.attributes.step === "number" ? b.attributes.step : void 0;
+    if (stepA != null && stepB != null && stepA !== stepB) return stepA - stepB;
+    return timeOf(a) - timeOf(b);
+  });
+}
+function sessionFrom(spans, opts) {
+  const first = spans[0];
+  return {
+    harness: opts.session?.harness ?? asString(first?.attributes["service.name"]) ?? "unknown",
+    sessionId: opts.session?.sessionId ?? first?.trace_id ?? "unknown",
+    cwd: opts.session?.cwd ?? asString(first?.attributes["tangle.cwd"]) ?? null,
+    ...opts.session?.path ? { path: opts.session.path } : {}
+  };
+}
+function evidence2(kind, label, value, spanIds) {
+  return { kind, label, value, ...spanIds && spanIds.length > 0 ? { spanIds } : {} };
+}
+function finding(input) {
+  const fingerprint = hash([input.ruleId, ...input.signature]);
+  return {
+    schemaVersion: 1,
+    kind: "traces.live_finding",
+    id: `live.${input.ruleId}.${fingerprint}`,
+    fingerprint,
+    ruleId: input.ruleId,
+    severity: input.severity,
+    title: input.title,
+    claim: input.claim,
+    action: input.action,
+    check: input.check,
+    evidence: input.evidence,
+    session: input.session,
+    observedAt: input.observedAt
+  };
+}
+function analyzeLiveBatch(spans, opts = {}) {
+  const ordered2 = orderSpans(spans);
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const session = sessionFrom(ordered2, opts);
+  const tools = ordered2.filter(isTool);
+  const erroredTools = tools.filter((span2) => span2.status.code === "ERROR");
+  const verificationCalls = tools.filter(isVerification);
+  const changeCalls = tools.filter(isChange);
+  const findings = [];
+  const failedBySignature = /* @__PURE__ */ new Map();
+  for (const span2 of erroredTools) {
+    const signature = toolSignature(span2);
+    failedBySignature.set(signature, [...failedBySignature.get(signature) ?? [], span2]);
+  }
+  for (const [signature, rows] of failedBySignature) {
+    if (rows.length < 2) continue;
+    findings.push(finding({
+      ruleId: "same-failing-command",
+      severity: rows.length >= 3 ? "high" : "medium",
+      title: "Same failing command is repeating",
+      claim: `${rows.length} failed tool call(s) repeated the same command or arguments.`,
+      action: "Stop rerunning it; inspect the first failure, change state, or choose a different diagnostic path before another retry.",
+      check: "The next action should read the failing file, inspect the stack/output, or edit code before this command runs again.",
+      evidence: [
+        evidence2("pattern", "command", signature, rows.map((span2) => span2.span_id)),
+        evidence2("metric", "failed_repeats", String(rows.length))
+      ],
+      session,
+      observedAt: generatedAt,
+      signature: [signature, String(rows.length)]
+    }));
+  }
+  let lastChangeIndex = -1;
+  let verificationSinceChange = 0;
+  const verificationSpanIds = [];
+  for (let i = 0; i < ordered2.length; i++) {
+    const span2 = ordered2[i];
+    if (isChange(span2)) {
+      lastChangeIndex = i;
+      verificationSinceChange = 0;
+      verificationSpanIds.length = 0;
+    } else if (isVerification(span2)) {
+      verificationSinceChange += 1;
+      verificationSpanIds.push(span2.span_id);
+    }
+  }
+  if (verificationSinceChange >= 2) {
+    findings.push(finding({
+      ruleId: "verification-without-change",
+      severity: verificationSinceChange >= 3 ? "high" : "medium",
+      title: "Verification is repeating without a state change",
+      claim: `${verificationSinceChange} verification command(s) ran after the last detected code/config change.`,
+      action: "Do not spend another verification run until the agent either edits state or explains what new signal the rerun will reveal.",
+      check: "The next action should be a code/config edit, targeted file read, or a different narrow diagnostic command.",
+      evidence: [
+        evidence2("metric", "verification_calls_since_change", String(verificationSinceChange), verificationSpanIds),
+        evidence2("metric", "change_calls", String(changeCalls.length))
+      ],
+      session,
+      observedAt: generatedAt,
+      signature: [String(verificationSinceChange), verificationSpanIds.join(",")]
+    }));
+  }
+  const lastClaim = [...ordered2].reverse().find((span2) => isTextSpan(span2) && CLAIM_DONE_RE.test(spanContent(span2)));
+  if (lastClaim) {
+    const claimTime = timeOf(lastClaim);
+    const verificationAfterClaim = verificationCalls.some((span2) => timeOf(span2) > claimTime);
+    if (!verificationAfterClaim) {
+      findings.push(finding({
+        ruleId: "completion-claim-without-verification",
+        severity: "medium",
+        title: "Completion claim has no later verification",
+        claim: "The agent claimed completion, correctness, or verification without a later verification tool call in the observed trace.",
+        action: "Require a concrete check after the claim, or downgrade the claim to an unverified hypothesis.",
+        check: "A later test/build/typecheck/lint/smoke command should appear after the claim.",
+        evidence: [
+          evidence2("span", "claim_span", spanContent(lastClaim).slice(0, 240), [lastClaim.span_id]),
+          evidence2("metric", "verification_after_claim", "0")
+        ],
+        session,
+        observedAt: generatedAt,
+        signature: [lastClaim.span_id, spanContent(lastClaim).slice(0, 120)]
+      }));
+    }
+  }
+  if (tools.length >= 4 && erroredTools.length / tools.length >= 0.5) {
+    findings.push(finding({
+      ruleId: "high-tool-error-rate",
+      severity: erroredTools.length / tools.length >= 0.75 ? "high" : "medium",
+      title: "Tool calls are mostly failing",
+      claim: `${erroredTools.length}/${tools.length} tool call(s) in this live batch ended with ERROR.`,
+      action: "Switch from broad execution to diagnosis: classify the dominant error, then run one targeted command to validate the fix path.",
+      check: "The next batch should reduce the error ratio or show a new targeted diagnostic result.",
+      evidence: [
+        evidence2("metric", "errored_tool_calls", `${erroredTools.length}/${tools.length}`, erroredTools.map((span2) => span2.span_id))
+      ],
+      session,
+      observedAt: generatedAt,
+      signature: [String(erroredTools.length), String(tools.length)]
+    }));
+  }
+  return {
+    schemaVersion: 1,
+    kind: "traces.live_batch",
+    generatedAt,
+    session,
+    spanCount: ordered2.length,
+    newSpanCount: opts.newSpanCount ?? ordered2.length,
+    toolCallCount: tools.length,
+    erroredToolCallCount: erroredTools.length,
+    verificationCallCount: verificationCalls.length,
+    changeCallCount: changeCalls.length,
+    findingCount: findings.length,
+    findings
+  };
+}
+function sessionEvent(session, spans, generatedAt) {
+  const ordered2 = orderSpans(spans);
+  return {
+    schemaVersion: 1,
+    kind: "traces.stream.session",
+    event: "session",
+    generatedAt,
+    session,
+    spanCount: ordered2.length,
+    startedAt: ordered2[0]?.start_time ?? null,
+    endedAt: ordered2.at(-1)?.end_time ?? null
+  };
+}
+function traceStreamEventsFromSpans(spans, opts = {}) {
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const session = sessionFrom(spans, {
+    ...opts,
+    session: opts.ref ? { harness: opts.ref.harness, sessionId: opts.ref.sessionId, cwd: opts.ref.cwd, path: opts.ref.path } : opts.session
+  });
+  const ordered2 = orderSpans(spans);
+  const batch = analyzeLiveBatch(ordered2, { generatedAt, session, newSpanCount: ordered2.length });
+  const events = [sessionEvent(session, ordered2, generatedAt)];
+  if (opts.includeSpans !== false) {
+    for (const span2 of ordered2) {
+      events.push({ schemaVersion: 1, kind: "traces.stream.span", event: "span", generatedAt, session, span: span2 });
+    }
+  }
+  events.push({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, batch });
+  if (opts.includeFindings !== false) {
+    for (const liveFinding of batch.findings) {
+      events.push({ schemaVersion: 1, kind: "traces.stream.finding", event: "finding", generatedAt, finding: liveFinding });
+    }
+  }
+  return events;
+}
+function serializeTraceStreamEvent(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+async function streamSessions(opts) {
+  const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
+  const windowMs = opts.windowMs ?? 30 * 6e4;
+  const includeSpans = opts.includeSpans !== false;
+  const includeFindings = opts.includeFindings !== false;
+  const includeBatches = opts.includeBatches !== false;
+  const seenSessions = /* @__PURE__ */ new Set();
+  const seenSpans = /* @__PURE__ */ new Set();
+  const seenFindings = /* @__PURE__ */ new Set();
+  while (!opts.signal?.aborted) {
+    let sessions = 0;
+    let newSpans = 0;
+    let findings = 0;
+    for await (const { adapter, ref, spans } of scanSessions({
+      ...opts,
+      sinceMs: opts.sinceMs ?? Date.now() - windowMs,
+      signal: opts.signal
+    })) {
+      const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const session = { harness: adapter.harness, sessionId: ref.sessionId, cwd: ref.cwd, path: ref.path };
+      const ordered2 = orderSpans(spans);
+      const sessionKey = `${session.harness}:${session.sessionId}`;
+      const unseen = ordered2.filter((span2) => {
+        const key = `${sessionKey}:${span2.span_id}`;
+        if (seenSpans.has(key)) return false;
+        seenSpans.add(key);
+        return true;
+      });
+      sessions += 1;
+      newSpans += unseen.length;
+      if (!seenSessions.has(sessionKey)) {
+        seenSessions.add(sessionKey);
+        await opts.onEvent(sessionEvent(session, ordered2, generatedAt));
+      }
+      if (includeSpans) {
+        for (const span2 of unseen) {
+          await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.span", event: "span", generatedAt, session, span: span2 });
+        }
+      }
+      const batch = analyzeLiveBatch(ordered2, { generatedAt, session, newSpanCount: unseen.length });
+      if (includeBatches) {
+        await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, batch });
+      }
+      if (includeFindings) {
+        for (const liveFinding of batch.findings) {
+          if (seenFindings.has(liveFinding.id)) continue;
+          seenFindings.add(liveFinding.id);
+          findings += 1;
+          await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.finding", event: "finding", generatedAt, finding: liveFinding });
+        }
+      }
+    }
+    await opts.onEvent({
+      schemaVersion: 1,
+      kind: "traces.stream.tick",
+      event: "tick",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions,
+      newSpans,
+      findings
+    });
+    if (opts.once || opts.signal?.aborted) break;
+    await sleep(intervalMs, opts.signal);
+  }
+}
+
+// src/observer.ts
+var sleep2 = (ms, signal) => new Promise((resolve2) => {
+  if (signal?.aborted) {
+    resolve2();
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(t);
+    resolve2();
+  };
+  const t = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve2();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+function loopKey(sessionId, toolName3, argHash) {
+  return `${sessionId}:${toolName3}:${argHash}`;
 }
 async function watchSessions(opts) {
   const windowMs = opts.windowMs ?? 30 * 6e4;
   const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
   const minLoop = opts.minLoopOccurrences ?? 3;
   const seen = /* @__PURE__ */ new Map();
+  const seenFindings = /* @__PURE__ */ new Set();
   while (!opts.signal?.aborted) {
     let sessionCount = 0;
     for await (const { adapter, ref, spans } of scanSessions({
@@ -4166,6 +4611,27 @@ async function watchSessions(opts) {
           opts.onError?.(err, ref);
         }
       }
+      const batch = analyzeLiveBatch(spans, {
+        session: { harness: adapter.harness, sessionId: ref.sessionId, cwd: ref.cwd, path: ref.path }
+      });
+      if (opts.onBatch) {
+        try {
+          await opts.onBatch(ref, batch);
+        } catch (err) {
+          opts.onError?.(err, ref);
+        }
+      }
+      if (opts.onFinding) {
+        for (const finding2 of batch.findings) {
+          if (seenFindings.has(finding2.id)) continue;
+          seenFindings.add(finding2.id);
+          try {
+            await opts.onFinding(finding2);
+          } 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)) {
@@ -4194,7 +4660,7 @@ async function watchSessions(opts) {
       opts.onError?.(err);
     }
     if (opts.signal?.aborted) break;
-    await sleep(intervalMs, opts.signal);
+    await sleep2(intervalMs, opts.signal);
   }
 }
 
@@ -4421,7 +4887,7 @@ async function writeSessionIndexFile(index, outPath) {
 }
 
 // src/upload-state.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { mkdir as mkdir2, readFile as readFile15, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir11 } from "os";
 import { dirname as dirname4, join as join18 } from "path";
@@ -4433,7 +4899,7 @@ function uploadKey(harness, sessionId) {
   return `${harness}:${sessionId}`;
 }
 function sessionHash(spans) {
-  const h = createHash2("sha256");
+  const h = createHash3("sha256");
   for (const s of spans) {
     h.update(`${s.span_id}\0${s.name}\0${s.start_time}\0${s.status.code}
 `);
@@ -4453,8 +4919,8 @@ async function saveState(state) {
   await writeFile6(f, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
-function alreadyUploaded(state, harness, sessionId, hash) {
-  return state[uploadKey(harness, sessionId)]?.hash === hash;
+function alreadyUploaded(state, harness, sessionId, hash2) {
+  return state[uploadKey(harness, sessionId)]?.hash === hash2;
 }
 
 // src/upload.ts
@@ -4471,13 +4937,13 @@ async function planUpload(opts = {}) {
   const items = [];
   for await (const { ref, spans: raw } of scanSessions(opts)) {
     const { spans, report } = redactSpans(raw);
-    const hash = sessionHash(spans);
+    const hash2 = sessionHash(spans);
     items.push({
       ref,
       spans,
       redaction: report,
-      hash,
-      isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash)
+      hash: hash2,
+      isNew: !alreadyUploaded(state, ref.harness, ref.sessionId, hash2)
     });
   }
   return { items, state, sinceMs: opts.sinceMs };
@@ -4674,6 +5140,10 @@ export {
   writeTraceImprovementArtifacts,
   runTraceImprovementLoop,
   saveReport,
+  analyzeLiveBatch,
+  traceStreamEventsFromSpans,
+  serializeTraceStreamEvent,
+  streamSessions,
   watchSessions,
   buildSessionIndex,
   buildSessionIndexFromRows,