@tangle-network/traces 0.17.0 → 0.17.1

package/dist/{chunk-4QY4U4XW.js → chunk-SGQOMHZP.js}

@@ -2448,7 +2448,10 @@ function distinctClaudeEvent(event, seen, sourcePath, fallbackUid) {
       if (previous.fingerprint !== fingerprint) {
         throw new ClaudeEventConflictError(sourcePath, uid);
       }
-      if (previous.originKind === null && originKind !== null) return { originEnrichment: originKind, uid };
+      if (previous.originKind === null && originKind !== null) {
+        seen.set(uid, { fingerprint, originKind });
+        return { originEnrichment: originKind, uid };
+      }
       if (previous.originKind !== null && originKind !== null && previous.originKind !== originKind) {
         throw new ClaudeEventConflictError(sourcePath, uid);
       }
@@ -15478,7 +15481,10 @@ var FILE_DELIVERY_CONTRACT_LINES = [
   '     "confidence": number 0..1}',
   "Do NOT include a rationale field. Keep every string SHORT \u2014 long strings get corrupted in transport and void your work.",
   `Report at most ${MAX_FINDINGS} findings; a finding cites 1..${MAX_SPAN_IDS_PER_FINDING} span_ids, each copied VERBATIM from a span in ${TRAJECTORY_FILE_NAME}.`,
-  '"findings" is [] only for a clean trajectory.'
+  '"findings" is [] only for a clean trajectory.',
+  "FINAL MESSAGE RULE: after your REPL work is done, send ONE last message that contains NOTHING BUT the",
+  "fenced ```json block above \u2014 no preamble, no summary, no code identifiers around it. A reply whose last",
+  "message is prose or a partial block is discarded unread."
 ];
 function buildPrompt(question, projection) {
   if (projection.delivery.mode === "file-cwd") {
@@ -15499,16 +15505,23 @@ function buildPrompt(question, projection) {
     projection.rendered
   ].join("\n");
 }
-function buildRepairPrompt(parseDefect, previousReply) {
+function replyWasTruncated(previousReply, finishReason) {
+  if (finishReason === "length") return true;
+  if (finishReason !== null) return false;
+  return extractJsonObject(previousReply) === null;
+}
+function buildRepairPrompt(parseDefect, previousReply, finishReason) {
+  const truncated = replyWasTruncated(previousReply, finishReason);
   return [
     "Your previous reply to a trace-analysis task was structurally malformed and could not be parsed",
-    `(${parseDefect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON \u2014 one`,
-    "fenced ```json block, no other text, no tools. The JSON object has exactly two fields:",
+    `(${parseDefect}${truncated ? "; it was cut off by the output limit" : ""}). Below is your previous reply verbatim.`,
+    "Re-emit ONLY the corrected JSON \u2014 one fenced ```json block, no other text, no tools. The JSON object has exactly two fields:",
     '  "answer": string (ONE short sentence, max 300 chars)',
     '  "findings": array (possibly empty) of {"span_ids": [string, ...],',
     '   "severity": "critical"|"high"|"medium"|"low"|"info", "area": string (max 40 chars),',
     '   "claim": string (max 200 chars), "action": string (optional, max 200 chars), "confidence": number 0..1}',
-    "No rationale field. Keep every string SHORT. Preserve the span ids and verdicts of your previous reply exactly; shorten prose freely.",
+    "No rationale field. Keep every string SHORT.",
+    truncated ? "Your previous reply was cut off by the output limit, so re-emit at most 3 findings \u2014 your strongest \u2014 with terse strings (claim and action under 120 chars each); do not reproduce the whole cut-off list." : "Preserve the span ids and verdicts of your previous reply exactly; shorten prose freely.",
     "",
     "PREVIOUS REPLY:",
     previousReply
@@ -15675,7 +15688,12 @@ async function callBridge(transport, url, model, content, timeoutMs, callerSigna
   if (typeof replyContent !== "string" || replyContent.length === 0) {
     throw new PrimeBridgeError(`${turn}bridge reply carries no message content`);
   }
-  return { content: replyContent, usage: normalizeUsage(record2.usage) };
+  const finishReason = record2.choices?.[0]?.finish_reason;
+  return {
+    content: replyContent,
+    usage: normalizeUsage(record2.usage),
+    finishReason: typeof finishReason === "string" && finishReason.length > 0 ? finishReason : null
+  };
 }
 function failure(output, error) {
   return { analyzer: ANALYST_ID, kind: "report", ok: false, output, error };
@@ -15748,7 +15766,7 @@ function primeAnalyzer(opts = {}) {
             transport,
             url,
             model,
-            buildRepairPrompt(parseDefect, reply.content),
+            buildRepairPrompt(parseDefect, reply.content, reply.finishReason),
             timeoutMs,
             analyzeOpts.signal,
             "repair-turn "

package/dist/cli.js

@@ -83,7 +83,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceQuestionsArtifacts
-} from "./chunk-4QY4U4XW.js";
+} from "./chunk-SGQOMHZP.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";

package/dist/index.js

@@ -270,7 +270,7 @@ import {
   writeTraceQuestionsArtifacts,
   zaiChatCaller,
   zeroPricedCost
-} from "./chunk-4QY4U4XW.js";
+} from "./chunk-SGQOMHZP.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {

package/docs/trace-analysts.md

@@ -389,6 +389,47 @@ Output expectations:
 
 The scored prime-vs-dspy comparison — same trajectories, same scoring — lives in `@tangle-network/agent-eval`'s analyst benchmark (`runAnalystBenchmark`); this engine is the capture-side entry point, not the scoreboard.
 
+### Verifying against a real prime
+
+The suite above runs against a scripted bridge over real HTTP. A full real run — real
+prime-agent, real model, real REPL — is a manual, credentials-on-the-host affair:
+
+1. **Install prime-agent the way cli-bridge pins it.** It is a hard fork of pi that reuses
+   pi's npm name, so `npm i` gives you the WRONG agent: clone
+   `PrimeIntellect-ai/prime-agent`, `git checkout <the commit src/backends/prime.ts names>`
+   (be9e2fa0 at the time of writing), build, and expose the bundle as `prime-agent`
+   (cli-bridge's `pnpm install:harness prime` does exactly this).
+2. **Start cli-bridge with the prime backend**: `BRIDGE_BACKENDS=prime
+   PRIME_MODELS_JSON=<operator models.json> BRIDGE_PORT=4181 pnpm start`. The
+   models.json names an `apiKey` as an exported ENV VAR (not a literal — prime
+   resolves env-var-first, so an unforwarded name becomes the literal key), and the
+   bridge forwards exactly the names the file names into prime's neutral child env.
+   Mind which endpoint a key is funded on: a coding-plan GLM key only works on the
+   coding endpoint, and the same key 402s on the general one.
+3. **Give the kernel a persistent interpreter.** Prime's Python kernel bootstraps a
+   venv under its HOME, and the bridge gives every run an isolated one — a
+   uv-managed interpreter installed inside an ephemeral HOME dies with it. Pre-provision
+   a venv (ipykernel + the default rlm extras + an editable
+   `prime-agent-runtime`) from a system Python and export
+   `PRIME_AGENT_KERNEL_PYTHON=<that venv's python>` to the bridge; prime skips
+   auto-bootstrap when the named interpreter already passes its checks.
+4. Run with `TRACES_PRIME_BRIDGE_URL=http://localhost:4181 TRACES_PRIME_MODEL=prime/<provider>/<model>`.
+   The opt-in suite (`TRACES_PRIME_REAL_E2E=1` in `tests/analyst-engine-prime.test.ts`)
+   exercises the same path from vitest.
+
+What real runs have shown (GLM-5.3 via a coding-plan endpoint, fork at the pinned commit):
+
+- **Inline, small session:** clean single-call success — one fenced JSON block, five findings,
+  all grounded, exit 0.
+- **File, ~121 spans / 788 KB artifact:** the RLM loads and pages the file (14 calls, ~156k input
+  tokens); its first reply gets cut by the endpoint's output limit mid-JSON, and the
+  truncation-aware repair turn (re-emit at most 3 findings, terse strings) recovers it — ok:true,
+  findings grounded, exit 0.
+- **File, ~794 spans / 2.1 MB artifact:** ~2.2M input tokens of genuine REPL inspection, but the
+  reply never survives the endpoint's output cap even after repair — the run fails honestly
+  (exit 1, raw reply preserved, no findings invented). At that trajectory size, a model with a
+  larger output budget — or a paged finalization — is the next step, not silence about it.
+
 ## Write one analyst
 
 An analyst receives a paged trace store and returns typed findings.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.17.0",
-  "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, \u2026) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite \u2014 observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
+  "version": "0.17.1",
+  "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, …) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite — observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
   "type": "module",
   "license": "MIT",
   "repository": {