@tangle-network/traces 0.9.11 → 0.9.13

package/dist/cli.js

@@ -6,11 +6,14 @@ import {
   appendAll,
   buildPolicyEvidenceRecord,
   buildSessionIndexFromRows,
+  collectSessionSelection,
   commandAnalyzer,
   commandRedactor,
+  describeSessionRelationship,
   executeUpload,
   exportTraceEvidenceFile,
   haloAnalyzer,
+  hodoscopeAnalyzer,
   indexSessionIdsByTrace,
   inspectSessionIndex,
   knownHarnesses,
@@ -40,11 +43,10 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-ELWOJS65.js";
+} from "./chunk-H47X6QWV.js";
 
 // src/cli.ts
-import { createHash } from "crypto";
-import { createReadStream, readFileSync } from "fs";
+import { readFileSync } from "fs";
 import { readFile, stat } from "fs/promises";
 import { basename, resolve } from "path";
 import {
@@ -55,6 +57,8 @@ import {
   renderSupervisorRunMarkdown,
   rollupSupervisorRuns
 } from "@tangle-network/agent-eval/supervisor-run";
+import { createAnalystAi } from "@tangle-network/agent-eval/analyst";
+var DEFAULT_ANALYST_MODEL = "gpt-5-mini";
 function packageVersion() {
   const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
   if (typeof pkg.version !== "string" || !pkg.version) throw new Error("package.json is missing version");
@@ -68,6 +72,10 @@ function parseArgs(argv) {
     harnessExplicit: false,
     all: false,
     last: 0,
+    current: false,
+    latestTurn: false,
+    workflow: false,
+    maxWorkflowSessions: 100,
     llm: false,
     interval: 5,
     window: 30,
@@ -95,6 +103,18 @@ function parseArgs(argv) {
       case "--last":
         a.last = Number(next());
         break;
+      case "--current":
+        a.current = true;
+        break;
+      case "--latest-turn":
+        a.latestTurn = true;
+        break;
+      case "--workflow":
+        a.workflow = true;
+        break;
+      case "--max-workflow-sessions":
+        a.maxWorkflowSessions = Number(next());
+        break;
       case "--session":
         a.session = next();
         break;
@@ -194,6 +214,57 @@ function parseArgs(argv) {
   }
   return a;
 }
+var CURRENT_SESSION_COMMANDS = /* @__PURE__ */ new Set([
+  "analyze",
+  "investigate",
+  "improve",
+  "convert",
+  "index",
+  "evidence",
+  "stream"
+]);
+var WORKFLOW_COMMANDS = /* @__PURE__ */ new Set([
+  "analyze",
+  "investigate",
+  "improve",
+  "convert",
+  "index",
+  "evidence"
+]);
+function applyCurrentSessionSelection(args) {
+  if (!args.current) return args;
+  if (!CURRENT_SESSION_COMMANDS.has(args.command)) {
+    throw new Error(`--current is not supported by ${args.command}`);
+  }
+  if (args.input) throw new Error("--current cannot be combined with an input file");
+  if (args.supervisorRunDir) throw new Error("--current cannot be combined with --supervisor-run-dir");
+  if (args.session) throw new Error("--current cannot be combined with --session");
+  if (args.last > 0) throw new Error("--current cannot be combined with --last");
+  if (args.all) throw new Error("--current cannot be combined with --all");
+  const adapter = resolveAdapter(args.harness);
+  if (adapter?.harness !== "codex") {
+    throw new Error("--current uses CODEX_THREAD_ID and requires --harness codex");
+  }
+  const sessionId = process.env.CODEX_THREAD_ID?.trim();
+  if (!sessionId) throw new Error("--current requires CODEX_THREAD_ID from the active Codex session");
+  return { ...args, session: sessionId };
+}
+function validateWorkflowSelection(args) {
+  if (!args.workflow && !args.latestTurn) return args;
+  if (!WORKFLOW_COMMANDS.has(args.command)) {
+    throw new Error(`${args.workflow ? "--workflow" : "--latest-turn"} is not supported by ${args.command}`);
+  }
+  if (args.input) throw new Error("--workflow and --latest-turn cannot be combined with an input file");
+  if (args.supervisorRunDir) {
+    throw new Error("--workflow and --latest-turn cannot be combined with --supervisor-run-dir");
+  }
+  const selected = resolveAdapter(args.harness);
+  const supportsTaskTurns = selected?.harness === "codex" || selected?.harness === "claude-code";
+  if (args.latestTurn && (args.all || !supportsTaskTurns)) {
+    throw new Error("--latest-turn requires --harness codex or claude-code");
+  }
+  return args;
+}
 async function confirm(question) {
   if (!process.stdin.isTTY) return false;
   const rl = (await import("readline/promises")).createInterface({
@@ -239,7 +310,7 @@ async function resolveSelectedSession(args) {
         sessionId: args.session,
         path: args.session,
         // --session is an explicit file; honor --cwd so adoption can find the
-        // project's .evolve/skill-runs.jsonl (locate() infers cwd in the scan path).
+        // project's current or legacy skill-run log (locate() infers cwd in the scan path).
         cwd: args.cwd ?? null,
         mtimeMs: st.mtimeMs
       }
@@ -264,7 +335,7 @@ async function resolveSelectedSession(args) {
     `session ID "${args.session}" is ambiguous across ${matches.length} files; select one harness or pass its explicit session path`
   );
 }
-async function buildAxService() {
+async function buildAxService(model) {
   const apiKey = process.env.OPENAI_API_KEY;
   if (!apiKey) {
     throw new Error(
@@ -272,8 +343,7 @@ async function buildAxService() {
     );
   }
   const apiURL = process.env.OPENAI_BASE_URL || void 0;
-  const { AxAI } = await import("@ax-llm/ax");
-  return AxAI.create({ name: "openai", apiKey, ...apiURL ? { apiURL } : {} });
+  return createAnalystAi({ apiKey, baseUrl: apiURL, model });
 }
 async function cmdList(args) {
   const groups = await discover({ ...args, last: args.last || 20 });
@@ -297,6 +367,7 @@ function selectedSessionSource(ref, spans, sessionIdOverride) {
   const subject = firstLine.length > 240 ? `${firstLine.slice(0, 240)}\u2026 [+${firstLine.length - 240} chars]` : firstLine;
   const role = root?.attributes["traces.session.role"];
   const parentSessionId = root?.attributes["traces.parent_session_id"];
+  const relationship = describeSessionRelationship(ref, spans);
   const corruptionDigest = root?.attributes[ATTR.CORRUPTION_DIGEST];
   const sessionId = [
     sessionIdOverride,
@@ -310,6 +381,13 @@ function selectedSessionSource(ref, spans, sessionIdOverride) {
     subject,
     role: role === "operator" || role === "child" ? role : "unknown",
     ...typeof parentSessionId === "string" ? { parentSessionId } : {},
+    childSessionIds: relationship.childSessionIds,
+    ...relationship.depth !== void 0 ? { depth: relationship.depth } : {},
+    ...relationship.agentNickname ? { agentNickname: relationship.agentNickname } : {},
+    ...relationship.agentRole ? { agentRole: relationship.agentRole } : {},
+    ...relationship.agentPath ? { agentPath: relationship.agentPath } : {},
+    ...relationship.taskScope ? { taskScope: relationship.taskScope } : {},
+    ...relationship.turnId ? { turnId: relationship.turnId } : {},
     integrity: ref.integrity?.status ?? "complete",
     ...ref.integrity ? {
       corruptionCount: ref.integrity.corruptions.length,
@@ -319,66 +397,67 @@ function selectedSessionSource(ref, spans, sessionIdOverride) {
   };
 }
 async function collectSpans(args) {
-  if (args.input) return collectImportedSpans(args);
-  if (args.session) {
-    const { adapter, ref } = await resolveSelectedSession(args);
-    const spans2 = await parseSession(adapter, ref);
-    return {
-      spans: spans2,
-      harness: adapter.harness,
-      cwds: ref.cwd ? [ref.cwd] : [],
-      sources: [selectedSessionSource(ref, spans2)]
-    };
+  if (args.input) {
+    if (args.workflow) throw new Error("--workflow reads discovered sessions and cannot be combined with an input file");
+    return collectImportedSpans(args);
   }
-  const groups = await discover({ ...args, last: args.last || 1 });
+  const selection = await collectSessionRows(args, false, args.last || 1);
   const spans = [];
-  const harnesses = [];
+  const harnesses = /* @__PURE__ */ new Set();
   const cwds = [];
   const sources = [];
-  for (const { adapter, refs } of groups) {
-    if (refs.length > 0) harnesses.push(adapter.harness);
-    for (const ref of refs) {
-      const parsed = await parseSession(adapter, ref);
-      appendAll(spans, parsed);
-      sources.push(selectedSessionSource(ref, parsed));
-      if (ref.cwd) cwds.push(ref.cwd);
-    }
+  for (const row of selection.rows) {
+    harnesses.add(row.adapter.harness);
+    appendAll(spans, row.spans);
+    sources.push(selectedSessionSource(row.ref, row.spans));
+    if (row.ref.cwd) cwds.push(row.ref.cwd);
   }
-  return { spans, harness: harnesses.join("+") || args.harness, cwds, sources };
+  return {
+    spans,
+    harness: [...harnesses].join("+") || args.harness,
+    cwds,
+    sources,
+    ...selection.workflow ? { workflow: selection.workflow } : {}
+  };
 }
 async function cmdConvert(args) {
-  const { spans } = await collectSpans(args);
+  const { spans, workflow } = await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
+  warnIncompleteWorkflow(workflow);
   const path = await writeOtlpFile(spans, args.otlp);
   console.log(`wrote ${spans.length} spans \u2192 ${path}`);
 }
-async function sourceSha256(path) {
-  const hash = createHash("sha256");
-  for await (const chunk of createReadStream(path)) hash.update(chunk);
-  return hash.digest("hex");
-}
-async function collectSessionRows(args, bindExplicitSource = false) {
-  if (args.session) {
-    const { adapter, ref } = await resolveSelectedSession(args);
-    if (!bindExplicitSource) return [{ ref, spans: await parseSession(adapter, ref) }];
-    const before = await sourceSha256(ref.path);
-    const spans = await parseSession(adapter, ref);
-    const after = await sourceSha256(ref.path);
-    if (before !== after) {
-      throw new Error(`session source changed while parsing; refusing unbound evidence: ${ref.path}`);
-    }
-    return [{ ref, spans, sourceSha256: after }];
+function workflowIssueText(issue) {
+  if (issue.kind === "cycle") return `cycle: ${issue.sessionIds.join(" -> ")}`;
+  if (issue.kind === "unresolved-parent-task") {
+    return `cannot resolve parent task for child ${issue.childSessionId} in ${issue.parentSessionId}: ${issue.reason}`;
   }
-  const groups = await discover({ ...args, last: args.last || 20 });
-  const rows = [];
-  for (const { adapter, refs } of groups) {
-    for (const ref of refs) rows.push({ ref, spans: await parseSession(adapter, ref) });
+  if (issue.kind === "parent-conflict") {
+    return `parent conflict for ${issue.sessionId}: declared ${issue.declaredParentSessionId ?? "none"}, referenced by ${issue.referencedParentSessionIds.join(", ") || "none"}`;
   }
-  return rows;
+  return `${issue.kind} ${issue.sessionId}, referenced as ${issue.relation} by ${issue.referencedBySessionId}`;
+}
+function warnIncompleteWorkflow(workflow) {
+  if (!workflow || workflow.complete) return;
+  process.stderr.write(
+    `warning: session workflow is incomplete (${workflow.issues.length} issue(s)): ${workflow.issues.map(workflowIssueText).join("; ")}
+`
+  );
+}
+async function collectSessionRows(args, bindExplicitSource = false, defaultLast = 20) {
+  const groups = args.session ? [await resolveSelectedSession(args).then(({ adapter, ref }) => ({ adapter, refs: [ref] }))] : await discover({ ...args, last: args.last || defaultLast });
+  return collectSessionSelection(groups, {
+    workflow: args.workflow,
+    maxWorkflowSessions: args.maxWorkflowSessions,
+    taskScope: args.latestTurn ? "latest" : "all",
+    bindSources: bindExplicitSource && Boolean(args.session)
+  });
 }
 async function cmdEvidence(args) {
-  const rows = (await collectSessionRows(args, true)).filter((row) => row.spans.length > 0);
+  const selection = await collectSessionRows(args, true);
+  const rows = selection.rows.filter((row) => row.spans.length > 0);
   if (rows.length === 0) throw new Error("no spans found for the given selection");
+  warnIncompleteWorkflow(selection.workflow);
   const otlpPath = args.otlp ? await writeOtlpFile(rows.flatMap((row) => row.spans), args.otlp) : void 0;
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const records = await Promise.all(rows.map(
@@ -398,8 +477,10 @@ async function cmdEvidence(args) {
   }
 }
 async function cmdIndex(args) {
-  const rows = (await collectSessionRows(args)).filter((row) => row.spans.length > 0);
+  const selection = await collectSessionRows(args);
+  const rows = selection.rows.filter((row) => row.spans.length > 0);
   if (rows.length === 0) throw new Error("no spans found for the given selection");
+  warnIncompleteWorkflow(selection.workflow);
   const index = await buildSessionIndexFromRows(rows, {
     minLoopOccurrences: args.minLoop,
     selection: {
@@ -409,7 +490,9 @@ async function cmdIndex(args) {
       last: args.last || void 0,
       session: args.session,
       cwd: args.cwd,
-      since: args.since
+      since: args.since,
+      latestTurn: args.latestTurn || void 0,
+      ...selection.workflow ? { workflow: selection.workflow } : {}
     }
   });
   if (args.out) {
@@ -447,8 +530,8 @@ async function cmdExport(args) {
 }
 function traceEvidenceFormat(raw) {
   const format = raw ?? "auto";
-  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference" && format !== "intelligence-spans") {
-    throw new Error("--format must be auto, policy-evidence, sandbox-events, openinference, or intelligence-spans");
+  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference" && format !== "intelligence-spans" && format !== "chat-trajectory") {
+    throw new Error("--format must be auto, policy-evidence, sandbox-events, openinference, intelligence-spans, or chat-trajectory");
   }
   return format;
 }
@@ -546,7 +629,7 @@ async function collectImportedSpans(args) {
 }
 function externalAnalyzersFromArgs(args) {
   return args.analyzers.map(
-    (spec) => spec === "halo" ? haloAnalyzer({ defaultPrompt: args.analyzerPrompt, model: args.model }) : commandAnalyzer({ name: spec, command: spec, args: (p, prompt) => prompt ? [p, prompt] : [p] })
+    (spec) => spec === "halo" ? haloAnalyzer({ defaultPrompt: args.analyzerPrompt, model: args.model }) : spec === "hodoscope" ? hodoscopeAnalyzer({ summarizeModel: args.model }) : commandAnalyzer({ name: spec, command: spec, args: (p, prompt) => prompt ? [p, prompt] : [p] })
   );
 }
 async function cmdInvestigate(args) {
@@ -559,18 +642,20 @@ async function cmdInvestigate(args) {
   }
 }
 async function investigate(args, options = {}) {
-  const { spans, harness, cwds, sources } = await collectSpans(args);
+  const { spans, harness, cwds, sources, workflow } = await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const config = args.config !== void 0 || options.loadDefaultConfig !== false ? await loadTracesConfig(args.config) : void 0;
-  const ai = args.llm ? await buildAxService() : void 0;
+  const analystModel = args.model ?? process.env.TRACES_ANALYST_MODEL ?? DEFAULT_ANALYST_MODEL;
+  const ai = args.llm ? await buildAxService(analystModel) : void 0;
   return runTraceInvestigation(mergeTracesConfig({
     spans,
     harness,
     sources,
+    workflow,
     cwds,
     minLoopOccurrences: args.minLoop,
     ai,
-    model: args.model,
+    model: args.llm ? analystModel : args.model,
     budgetUsd: args.budget,
     otlpOutPath: args.otlp,
     externalAnalyzers: externalAnalyzersFromArgs(args),
@@ -580,19 +665,21 @@ async function investigate(args, options = {}) {
   }, config));
 }
 async function cmdImprove(args) {
-  const { spans, harness, cwds, sources } = await collectSpans(args);
+  const { spans, harness, cwds, sources, workflow } = await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const config = await loadTracesConfig(args.config);
-  const ai = args.llm ? await buildAxService() : void 0;
+  const analystModel = args.model ?? process.env.TRACES_ANALYST_MODEL ?? DEFAULT_ANALYST_MODEL;
+  const ai = args.llm ? await buildAxService(analystModel) : void 0;
   const result = await runTraceImprovement({
     ...mergeTracesConfig({
       spans,
       harness,
       sources,
+      workflow,
       cwds,
       minLoopOccurrences: args.minLoop,
       ai,
-      model: args.model,
+      model: args.llm ? analystModel : args.model,
       budgetUsd: args.budget,
       otlpOutPath: args.otlp,
       externalAnalyzers: externalAnalyzersFromArgs(args),
@@ -819,6 +906,7 @@ Input formats:
   sandbox-events   JSON arrays with start/raw/result/done/error events
   openinference    Existing OpenInference JSONL; rewrites through traces redaction
   intelligence-spans  JSONL rows exported from Tangle Intelligence trace spans
+  chat-trajectory  A message array or objects with a messages array
   auto             Detect the format from the file contents (default)
 
 Examples:
@@ -855,7 +943,12 @@ Options:
   --harness <id>   Harness or alias (default: claude-code). Known: ${knownHarnesses().join(", ")}
   --all            Sweep every known harness
   --last <n>       Most-recent N sessions
+  --current        Analyze the active Codex session named by CODEX_THREAD_ID
+  --latest-turn    Limit a resumed Codex or Claude Code session to its latest task turn
   --session <id|path> Analyze one listed session ID or one explicit harness session file
+  --workflow       Expand selected sessions through stable parent/child session IDs
+  --max-workflow-sessions <n>
+                   Stop workflow expansion before parsing more than N files (default 100)
   --cwd <dir>      Filter sessions by working directory
   --supervisor-run-dir <dir>
                    analyze: report a SUPERVISION TREE instead of harness sessions \u2014
@@ -865,7 +958,7 @@ Options:
   --out <path>     Write report to a file
   --dir <path>     improve: write artifacts to this directory
   --otlp <path>    OTLP artifact path (also evidence provenance / dry-run upload preview)
-  --format <kind>  analyze/export file: auto | policy-evidence | sandbox-events | openinference | intelligence-spans
+  --format <kind>  analyze/export: auto | policy-evidence | sandbox-events | openinference | intelligence-spans | chat-trajectory
   --metadata <json> analyze/export file: attach JSON object fields as span attributes
   --attr <k=v>     analyze/export file: attach one span attribute (repeatable)
   --mode <kind>    stream: visualizer | findings | agent (default visualizer)
@@ -873,10 +966,10 @@ Options:
   --no-spans       stream: omit per-span pulse events
   --no-findings    stream: omit semantic live-finding events
   --llm            Enable agentic RLM analysts (needs OPENAI_API_KEY / OPENAI_BASE_URL)
-  --model <id>     --llm model id (e.g. a router model like glm-5.2); default is agent-eval's
+  --model <id>     Model for --llm, HALO, and Hodoscope (default for --llm: ${DEFAULT_ANALYST_MODEL})
   --config <path>  investigate/improve/stream: JS config with analysts, liveAnalysts, or external analyzers
   --budget <usd>   USD cap for agentic analysts
-  --analyzer <cmd> analyze: also run an external engine over the OTLP (repeatable; "halo" or any command)
+  --analyzer <id>  analyze: also run halo, hodoscope, or an installed command (repeatable)
   --analyzer-prompt <p>  analyze: prompt passed to external analyzers (default: diagnose)
   --interval <s>   watch/stream: poll interval seconds (default 5)
   --window <m>     watch/stream: only sessions active in the last N minutes (default 30)
@@ -896,12 +989,13 @@ async function main() {
     console.log(`traces ${packageVersion()}`);
     return;
   }
-  const args = parseArgs(rawArgs);
-  if (args.help) {
-    if (args.command === "export" || args.command === "help" && args.input === "export") usageExport();
+  const parsedArgs = parseArgs(rawArgs);
+  if (parsedArgs.help) {
+    if (parsedArgs.command === "export" || parsedArgs.command === "help" && parsedArgs.input === "export") usageExport();
     else usage();
     return;
   }
+  const args = validateWorkflowSelection(applyCurrentSessionSelection(parsedArgs));
   switch (args.command) {
     case "help":
       if (args.input === "export") usageExport();