@tangle-network/traces 0.8.18 → 0.8.20

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

@@ -4297,6 +4297,36 @@ 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;
@@ -4339,54 +4369,52 @@ function finding(input) {
     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);
+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;
   }
-  if (verificationSinceChange >= 2) {
-    findings.push(finding({
+};
+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",
@@ -4395,51 +4423,89 @@ function analyzeLiveBatch(spans, opts = {}) {
       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))
+        evidence2("metric", "change_calls", String(context.changeActions.length))
       ],
-      session,
-      observedAt: generatedAt,
+      session: context.session,
+      observedAt: context.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)]
-      }));
-    }
+};
+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)]
+    })];
   }
-  if (tools.length >= 4 && erroredTools.length / tools.length >= 0.5) {
-    findings.push(finding({
+};
+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: erroredTools.length / tools.length >= 0.75 ? "high" : "medium",
+      severity: context.erroredTools.length / context.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.`,
+      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", `${erroredTools.length}/${tools.length}`, erroredTools.map((span2) => span2.span_id))
+        evidence2("metric", "errored_tool_calls", `${context.erroredTools.length}/${context.tools.length}`, context.erroredTools.map((span2) => span2.span_id))
       ],
-      session,
-      observedAt: generatedAt,
-      signature: [String(erroredTools.length), String(tools.length)]
-    }));
+      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",
@@ -4449,8 +4515,9 @@ function analyzeLiveBatch(spans, opts = {}) {
     newSpanCount: opts.newSpanCount ?? ordered2.length,
     toolCallCount: tools.length,
     erroredToolCallCount: erroredTools.length,
-    verificationCallCount: verificationCalls.length,
-    changeCallCount: changeCalls.length,
+    verificationCallCount: verificationActions.length,
+    changeCallCount: changeActions.length,
+    actionCounts: actionCounts(actions),
     findingCount: findings.length,
     findings
   };
@@ -4475,14 +4542,20 @@ function traceStreamEventsFromSpans(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 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, batch });
+  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 });
@@ -4494,12 +4567,24 @@ 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 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();
@@ -4533,9 +4618,31 @@ async function streamSessions(opts) {
           await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.span", event: "span", generatedAt, session, span: span2 });
         }
       }
-      const batch = analyzeLiveBatch(ordered2, { generatedAt, session, newSpanCount: unseen.length });
+      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, batch });
+        await opts.onEvent({ schemaVersion: 1, kind: "traces.stream.batch", event: "analysis_batch", generatedAt, ref, batch });
+      }
+      if (includeReports) {
+        try {
+          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);
+        }
       }
       if (includeFindings) {
         for (const liveFinding of batch.findings) {
@@ -4561,107 +4668,52 @@ async function streamSessions(opts) {
 }
 
 // src/observer.ts
-var sleep2 = (ms, signal) => new Promise((resolve2) => {
-  if (signal?.aborted) {
-    resolve2();
-    return;
+function loopKey(loop) {
+  return `${loop.sessionId}:${loop.toolName}:${loop.argHash}`;
+}
+async function callSafely(ref, onError, fn) {
+  try {
+    await fn();
+  } catch (err) {
+    onError?.(err, ref);
   }
-  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({
-      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 {
-        report = await runPipelines(spans, { minLoopOccurrences: minLoop });
-      } catch (err) {
-        opts.onError?.(err, ref);
-        continue;
-      }
-      sessionCount += 1;
-      if (opts.onReport) {
-        try {
-          await opts.onReport(ref, report);
-        } catch (err) {
-          opts.onError?.(err, ref);
+  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));
         }
-      }
-      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)) {
-          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);
-            }
-          }
+      } 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 }));
       }
     }
-    try {
-      opts.onTick?.({ sessions: sessionCount });
-    } catch (err) {
-      opts.onError?.(err);
-    }
-    if (opts.signal?.aborted) break;
-    await sleep2(intervalMs, opts.signal);
-  }
+  });
 }
 
 // src/session-index.ts
@@ -5140,6 +5192,8 @@ export {
   writeTraceImprovementArtifacts,
   runTraceImprovementLoop,
   saveReport,
+  classifyLiveActions,
+  defaultTraceLiveAnalysts,
   analyzeLiveBatch,
   traceStreamEventsFromSpans,
   serializeTraceStreamEvent,