@tangle-network/traces 0.8.17 → 0.8.19

package/dist/{chunk-QM4QAG3V.js → chunk-FCTZLWP7.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
@@ -3235,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 };
@@ -3435,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
   };
@@ -3456,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")}
@@ -3926,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
   })));
 }
@@ -4006,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("");
@@ -4242,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();
@@ -4254,72 +4262,460 @@ 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);
 }
-async function watchSessions(opts) {
-  const windowMs = opts.windowMs ?? 30 * 6e4;
+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 isRead(span2) {
+  if (!isTool(span2)) return false;
+  return /\b(read|cat|less|grep|rg|sed -n|nl|ls|find|git show|git diff)\b/i.test(`${toolName2(span2)} ${span2.name} ${spanContent(span2)}`);
+}
+function actionKind(span2) {
+  if (isVerification(span2)) return "verify";
+  if (isChange(span2)) return "edit";
+  if (isRead(span2)) return "read";
+  if (isTool(span2)) return "tool";
+  if (isTextSpan(span2) && CLAIM_DONE_RE.test(spanContent(span2))) return "claim";
+  return "other";
+}
+function classifyLiveActions(spans) {
+  return orderSpans(spans).map((span2) => {
+    const tool = isTool(span2) ? toolName2(span2) : void 0;
+    return {
+      kind: actionKind(span2),
+      spanId: span2.span_id,
+      span: span2,
+      ...tool ? { toolName: tool } : {},
+      signature: toolSignature(span2),
+      errored: span2.status.code === "ERROR"
+    };
+  });
+}
+function actionCounts(actions) {
+  const counts = { tool: 0, read: 0, edit: 0, verify: 0, claim: 0, other: 0 };
+  for (const action of actions) counts[action.kind] += 1;
+  return counts;
+}
+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
+  };
+}
+var sameFailingCommandAnalyst = {
+  id: "same-failing-command",
+  analyze(context) {
+    const findings = [];
+    const failedBySignature = /* @__PURE__ */ new Map();
+    for (const action of context.actions) {
+      if (!action.toolName || !action.errored) continue;
+      failedBySignature.set(action.signature, [...failedBySignature.get(action.signature) ?? [], action.span]);
+    }
+    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: context.session,
+        observedAt: context.generatedAt,
+        signature: [signature, String(rows.length)]
+      }));
+    }
+    return findings;
+  }
+};
+var verificationWithoutChangeAnalyst = {
+  id: "verification-without-change",
+  analyze(context) {
+    let verificationSinceChange = 0;
+    const verificationSpanIds = [];
+    for (const action of context.actions) {
+      if (action.kind === "edit") {
+        verificationSinceChange = 0;
+        verificationSpanIds.length = 0;
+      } else if (action.kind === "verify") {
+        verificationSinceChange += 1;
+        verificationSpanIds.push(action.spanId);
+      }
+    }
+    if (verificationSinceChange < 2) return [];
+    return [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(context.changeActions.length))
+      ],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [String(verificationSinceChange), verificationSpanIds.join(",")]
+    })];
+  }
+};
+var completionClaimWithoutVerificationAnalyst = {
+  id: "completion-claim-without-verification",
+  analyze(context) {
+    const lastClaim = [...context.actions].reverse().find((action) => action.kind === "claim");
+    if (!lastClaim) return [];
+    const claimTime = timeOf(lastClaim.span);
+    const verificationAfterClaim = context.verificationActions.some((action) => timeOf(action.span) > claimTime);
+    if (verificationAfterClaim) return [];
+    return [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.span).slice(0, 240), [lastClaim.spanId]),
+        evidence2("metric", "verification_after_claim", "0")
+      ],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [lastClaim.spanId, spanContent(lastClaim.span).slice(0, 120)]
+    })];
+  }
+};
+var highToolErrorRateAnalyst = {
+  id: "high-tool-error-rate",
+  analyze(context) {
+    if (context.tools.length < 4 || context.erroredTools.length / context.tools.length < 0.5) return [];
+    return [finding({
+      ruleId: "high-tool-error-rate",
+      severity: context.erroredTools.length / context.tools.length >= 0.75 ? "high" : "medium",
+      title: "Tool calls are mostly failing",
+      claim: `${context.erroredTools.length}/${context.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", `${context.erroredTools.length}/${context.tools.length}`, context.erroredTools.map((span2) => span2.span_id))
+      ],
+      session: context.session,
+      observedAt: context.generatedAt,
+      signature: [String(context.erroredTools.length), String(context.tools.length)]
+    })];
+  }
+};
+var defaultTraceLiveAnalysts = [
+  sameFailingCommandAnalyst,
+  verificationWithoutChangeAnalyst,
+  completionClaimWithoutVerificationAnalyst,
+  highToolErrorRateAnalyst
+];
+function liveAnalysts(opts) {
+  return [...opts.analysts ?? defaultTraceLiveAnalysts, ...opts.extraAnalysts ?? []];
+}
+function analyzeLiveBatch(spans, opts = {}) {
+  const ordered2 = orderSpans(spans);
+  const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const session = sessionFrom(ordered2, opts);
+  const actions = classifyLiveActions(ordered2);
+  const tools = ordered2.filter(isTool);
+  const erroredTools = tools.filter((span2) => span2.status.code === "ERROR");
+  const verificationActions = actions.filter((action) => action.kind === "verify");
+  const changeActions = actions.filter((action) => action.kind === "edit");
+  const context = {
+    spans: ordered2,
+    actions,
+    tools,
+    erroredTools,
+    verificationActions,
+    changeActions,
+    session,
+    generatedAt,
+    newSpanCount: opts.newSpanCount ?? ordered2.length
+  };
+  const findings = liveAnalysts(opts).flatMap((analyst) => [...analyst.analyze(context)]);
+  return {
+    schemaVersion: 1,
+    kind: "traces.live_batch",
+    generatedAt,
+    session,
+    spanCount: ordered2.length,
+    newSpanCount: opts.newSpanCount ?? ordered2.length,
+    toolCallCount: tools.length,
+    erroredToolCallCount: erroredTools.length,
+    verificationCallCount: verificationActions.length,
+    changeCallCount: changeActions.length,
+    actionCounts: actionCounts(actions),
+    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,
+    analysts: opts.analysts,
+    extraAnalysts: opts.extraAnalysts
+  });
+  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, ref: opts.ref, 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)}
+`;
+}
+function loopsFromReport(session, report) {
+  return report.stuckLoops.findings.map((loop) => ({
+    harness: session.harness,
+    sessionId: session.sessionId,
+    cwd: session.cwd,
+    toolName: loop.toolName,
+    argHash: loop.argHash,
+    occurrences: loop.occurrences,
+    windowMs: loop.windowMs
+  }));
+}
+async function streamSessions(opts) {
   const intervalMs = Math.max(250, opts.intervalMs ?? 5e3);
-  const minLoop = opts.minLoopOccurrences ?? 3;
-  const seen = /* @__PURE__ */ new Map();
+  const windowMs = opts.windowMs ?? 30 * 6e4;
+  const includeSpans = opts.includeSpans !== false;
+  const includeFindings = opts.includeFindings !== false;
+  const includeBatches = opts.includeBatches !== false;
+  const includeReports = opts.includeReports === true;
+  const seenSessions = /* @__PURE__ */ new Set();
+  const seenSpans = /* @__PURE__ */ new Set();
+  const seenFindings = /* @__PURE__ */ new Set();
   while (!opts.signal?.aborted) {
-    let sessionCount = 0;
+    let sessions = 0;
+    let newSpans = 0;
+    let findings = 0;
     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
+      ...opts,
+      sinceMs: opts.sinceMs ?? Date.now() - windowMs,
+      signal: opts.signal
     })) {
-      let report;
-      try {
-        report = await runPipelines(spans, { minLoopOccurrences: minLoop });
-      } catch (err) {
-        opts.onError?.(err, ref);
-        continue;
+      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,
+        extraAnalysts: opts.extraAnalysts
+      });
+      if (includeBatches) {
+        await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, ref, batch });
       }
-      sessionCount += 1;
-      if (opts.onReport) {
+      if (includeReports) {
         try {
-          await opts.onReport(ref, report);
+          const report = await runPipelines(ordered2, { minLoopOccurrences: opts.minLoopOccurrences });
+          await opts.onEvent({
+            schemaVersion: 1,
+            kind: "traces.stream.report",
+            event: "report",
+            generatedAt,
+            session,
+            ref,
+            report,
+            loops: loopsFromReport(session, 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);
-            }
-          }
+      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 });
         }
       }
     }
-    try {
-      opts.onTick?.({ sessions: sessionCount });
-    } catch (err) {
-      opts.onError?.(err);
-    }
-    if (opts.signal?.aborted) break;
+    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
+function loopKey(loop) {
+  return `${loop.sessionId}:${loop.toolName}:${loop.argHash}`;
+}
+async function callSafely(ref, onError, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    onError?.(err, ref);
+  }
+}
+async function watchSessions(opts) {
+  const seenLoops = /* @__PURE__ */ new Map();
+  await streamSessions({
+    adapters: opts.adapters,
+    all: opts.all,
+    harnesses: opts.harnesses,
+    cwd: opts.cwd,
+    windowMs: opts.windowMs,
+    intervalMs: opts.intervalMs,
+    minLoopOccurrences: opts.minLoopOccurrences,
+    signal: opts.signal,
+    includeSpans: false,
+    includeBatches: Boolean(opts.onBatch),
+    includeFindings: Boolean(opts.onFinding),
+    includeReports: Boolean(opts.onReport || opts.onLoop),
+    onError: opts.onError,
+    onEvent: async (event) => {
+      if (event.event === "analysis_batch") {
+        if (event.ref) {
+          await callSafely(event.ref, opts.onError, () => opts.onBatch?.(event.ref, event.batch));
+        }
+      } else if (event.event === "finding") {
+        await callSafely(void 0, opts.onError, () => opts.onFinding?.(event.finding));
+      } else if (event.event === "report") {
+        await callSafely(event.ref, opts.onError, () => opts.onReport?.(event.ref, event.report));
+        for (const loop of event.loops) {
+          const key = loopKey(loop);
+          if (loop.occurrences <= (seenLoops.get(key) ?? 0)) continue;
+          seenLoops.set(key, loop.occurrences);
+          await callSafely(event.ref, opts.onError, () => opts.onLoop?.(loop));
+        }
+      } else if (event.event === "tick") {
+        await callSafely(void 0, opts.onError, () => opts.onTick?.({ sessions: event.sessions }));
+      }
+    }
+  });
+}
+
 // src/session-index.ts
 import { mkdtemp as mkdtemp5, readdir as readdir11, readFile as readFile14, stat as stat12, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
@@ -4543,7 +4939,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";
@@ -4555,7 +4951,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}
 `);
@@ -4575,8 +4971,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
@@ -4593,13 +4989,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 };
@@ -4796,6 +5192,12 @@ export {
   writeTraceImprovementArtifacts,
   runTraceImprovementLoop,
   saveReport,
+  classifyLiveActions,
+  defaultTraceLiveAnalysts,
+  analyzeLiveBatch,
+  traceStreamEventsFromSpans,
+  serializeTraceStreamEvent,
+  streamSessions,
   watchSessions,
   buildSessionIndex,
   buildSessionIndexFromRows,