@stackmemoryai/stackmemory 1.6.2 → 1.7.0

package/dist/src/cli/commands/conductor-traces.js

@@ -0,0 +1,314 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+function classifyErrorText(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("lint") || lower.includes("eslint") || lower.includes("prettier"))
+    return "lint_failure";
+  if (lower.includes("test") && (lower.includes("fail") || lower.includes("error")))
+    return "test_failure";
+  if (lower.includes("timeout") || lower.includes("timed out"))
+    return "timeout";
+  if (lower.includes("conflict") || lower.includes("merge"))
+    return "git_conflict";
+  if (lower.includes("429") || lower.includes("rate limit"))
+    return "rate_limit";
+  if (lower.includes("permission") || lower.includes("EACCES") || lower.includes("not found"))
+    return "permission_or_missing";
+  if (lower.includes("build") && lower.includes("error"))
+    return "build_failure";
+  return null;
+}
+function getTracesDbPath() {
+  return join(homedir(), ".stackmemory", "conductor", "traces.db");
+}
+function openTracesDb(dbPath) {
+  const path = dbPath ?? getTracesDbPath();
+  mkdirSync(join(path, ".."), { recursive: true });
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conductor_traces (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      issue_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      attempt INTEGER NOT NULL,
+      turn_number INTEGER NOT NULL,
+      timestamp INTEGER NOT NULL,
+      phase TEXT,
+      tool_names TEXT,
+      tool_count INTEGER DEFAULT 0,
+      files_modified INTEGER DEFAULT 0,
+      input_tokens INTEGER DEFAULT 0,
+      output_tokens INTEGER DEFAULT 0,
+      cache_creation_tokens INTEGER DEFAULT 0,
+      cache_read_tokens INTEGER DEFAULT 0,
+      message_preview TEXT,
+      event_json TEXT NOT NULL,
+      UNIQUE(session_id, turn_number)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_traces_issue
+      ON conductor_traces(issue_id, attempt);
+    CREATE INDEX IF NOT EXISTS idx_traces_session
+      ON conductor_traces(session_id);
+    CREATE INDEX IF NOT EXISTS idx_traces_phase
+      ON conductor_traces(phase);
+    CREATE INDEX IF NOT EXISTS idx_traces_timestamp
+      ON conductor_traces(timestamp DESC);
+  `);
+  return db;
+}
+function withDb(db, fn) {
+  const ownDb = db ?? openTracesDb();
+  try {
+    return fn(ownDb);
+  } finally {
+    if (!db) ownDb.close();
+  }
+}
+class TraceCollector {
+  db;
+  ownsDb;
+  sessionId;
+  issueId;
+  attempt;
+  turnCounter = 0;
+  insertStmt;
+  constructor(opts) {
+    this.issueId = opts.issueId;
+    this.attempt = opts.attempt;
+    this.sessionId = `${opts.issueId}-${opts.attempt}-${randomUUID().slice(0, 8)}`;
+    this.ownsDb = !opts.db;
+    this.db = opts.db ?? openTracesDb();
+    this.insertStmt = this.db.prepare(`
+      INSERT INTO conductor_traces (
+        issue_id, session_id, attempt, turn_number, timestamp,
+        phase, tool_names, tool_count, files_modified,
+        input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+        message_preview, event_json
+      ) VALUES (
+        @issue_id, @session_id, @attempt, @turn_number, @timestamp,
+        @phase, @tool_names, @tool_count, @files_modified,
+        @input_tokens, @output_tokens, @cache_creation_tokens, @cache_read_tokens,
+        @message_preview, @event_json
+      )
+    `);
+  }
+  get session() {
+    return this.sessionId;
+  }
+  /**
+   * Record a turn using pre-extracted data from the orchestrator's stream parser.
+   * Avoids re-iterating content blocks — the caller already did that work.
+   */
+  recordTurn(turnData, phase, eventJson) {
+    this.insertStmt.run({
+      issue_id: this.issueId,
+      session_id: this.sessionId,
+      attempt: this.attempt,
+      turn_number: this.turnCounter++,
+      timestamp: Date.now(),
+      phase: phase ?? null,
+      tool_names: turnData.toolNames.length > 0 ? JSON.stringify(turnData.toolNames) : null,
+      tool_count: turnData.toolCount,
+      files_modified: turnData.filesModified,
+      input_tokens: turnData.inputTokens,
+      output_tokens: turnData.outputTokens,
+      cache_creation_tokens: turnData.cacheCreationTokens,
+      cache_read_tokens: turnData.cacheReadTokens,
+      message_preview: turnData.textPreview,
+      event_json: eventJson
+    });
+  }
+  /** Record a result event (final output) */
+  recordResult(event) {
+    const resultText = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+    this.insertStmt.run({
+      issue_id: this.issueId,
+      session_id: this.sessionId,
+      attempt: this.attempt,
+      turn_number: this.turnCounter++,
+      timestamp: Date.now(),
+      phase: "result",
+      tool_names: null,
+      tool_count: 0,
+      files_modified: 0,
+      input_tokens: 0,
+      output_tokens: 0,
+      cache_creation_tokens: 0,
+      cache_read_tokens: 0,
+      message_preview: (resultText || "").slice(0, 500),
+      event_json: JSON.stringify(event).slice(0, 5e4)
+    });
+  }
+  /** Close the DB connection only if we own it */
+  close() {
+    if (!this.ownsDb) return;
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+}
+function stringifyEventTruncated(event) {
+  return JSON.stringify(event, (_key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const obj = value;
+      if (obj.type === "tool_use" && obj.input) {
+        const inputStr = JSON.stringify(obj.input);
+        if (inputStr.length > 2e3) {
+          return {
+            ...obj,
+            input: { _truncated: true, length: inputStr.length }
+          };
+        }
+      }
+      if (obj.type === "tool_result" && obj.content) {
+        const contentStr = typeof obj.content === "string" ? obj.content : JSON.stringify(obj.content);
+        if (contentStr.length > 2e3) {
+          return { ...obj, content: `[truncated: ${contentStr.length} chars]` };
+        }
+      }
+    }
+    return value;
+  });
+}
+function listSessions(issueId, db) {
+  return withDb(db, (d) => {
+    const rows = d.prepare(
+      `
+      SELECT
+        issue_id,
+        session_id,
+        attempt,
+        COUNT(*) as total_turns,
+        SUM(tool_count) as total_tool_calls,
+        SUM(files_modified) as total_files_modified,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        GROUP_CONCAT(DISTINCT phase) as phases,
+        MIN(timestamp) as started_at,
+        MAX(timestamp) as ended_at
+      FROM conductor_traces
+      WHERE issue_id = ?
+      GROUP BY session_id
+      ORDER BY started_at DESC
+    `
+    ).all(issueId);
+    return rows.map((r) => ({
+      issue_id: r.issue_id,
+      session_id: r.session_id,
+      attempt: r.attempt,
+      total_turns: r.total_turns,
+      total_tool_calls: r.total_tool_calls || 0,
+      total_files_modified: r.total_files_modified || 0,
+      total_input_tokens: r.total_input_tokens || 0,
+      total_output_tokens: r.total_output_tokens || 0,
+      phases: (r.phases || "").split(",").filter(Boolean),
+      started_at: r.started_at,
+      ended_at: r.ended_at,
+      duration_ms: r.ended_at - r.started_at
+    }));
+  });
+}
+function getSessionTurns(sessionId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT * FROM conductor_traces
+      WHERE session_id = ?
+      ORDER BY turn_number ASC
+    `
+    ).all(sessionId)
+  );
+}
+function getPhaseBreakdown(sessionId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT
+        phase,
+        COUNT(*) as turns,
+        SUM(tool_count) as tool_calls,
+        SUM(input_tokens) as input_tokens,
+        SUM(output_tokens) as output_tokens
+      FROM conductor_traces
+      WHERE session_id = ? AND phase IS NOT NULL
+      GROUP BY phase
+      ORDER BY MIN(turn_number) ASC
+    `
+    ).all(sessionId)
+  );
+}
+function getToolFrequencies(issueId, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT j.value as tool_name, COUNT(*) as count
+      FROM conductor_traces, json_each(tool_names) j
+      WHERE issue_id = ? AND tool_names IS NOT NULL
+      GROUP BY j.value
+      ORDER BY count DESC
+    `
+    ).all(issueId)
+  );
+}
+function getFailureTurns(issueId, tailCount = 5, db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT t.* FROM conductor_traces t
+      INNER JOIN (
+        SELECT session_id, MAX(turn_number) as max_turn
+        FROM conductor_traces
+        WHERE issue_id = ?
+        GROUP BY session_id
+      ) latest ON t.session_id = latest.session_id
+        AND t.turn_number > latest.max_turn - ?
+      WHERE t.issue_id = ?
+      ORDER BY t.session_id, t.turn_number ASC
+    `
+    ).all(issueId, tailCount, issueId)
+  );
+}
+function getTraceStats(db) {
+  return withDb(
+    db,
+    (d) => d.prepare(
+      `
+      SELECT
+        COUNT(DISTINCT session_id) as total_sessions,
+        COUNT(*) as total_turns,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        COUNT(DISTINCT issue_id) as issues_traced
+      FROM conductor_traces
+    `
+    ).get()
+  );
+}
+export {
+  TraceCollector,
+  classifyErrorText,
+  getFailureTurns,
+  getPhaseBreakdown,
+  getSessionTurns,
+  getToolFrequencies,
+  getTraceStats,
+  getTracesDbPath,
+  listSessions,
+  openTracesDb,
+  stringifyEventTruncated
+};

package/dist/src/cli/commands/orchestrate.js

@@ -22,6 +22,16 @@ import {
   getAgentStatusDir,
   getOutcomesLogPath
 } from "./orchestrator.js";
+import {
+  openTracesDb,
+  listSessions,
+  getSessionTurns,
+  getPhaseBreakdown,
+  getToolFrequencies,
+  getFailureTurns,
+  getTraceStats,
+  classifyErrorText
+} from "./conductor-traces.js";
 function getGlobalStorePath() {
   const dir = join(homedir(), ".stackmemory", "conductor");
   if (!existsSync(dir)) {
@@ -70,6 +80,17 @@ function fmtTokens(n) {
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
   return String(n);
 }
+function formatTokens(n) {
+  return fmtTokens(n) + " tok";
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
 function budgetBar(pct, width = 30) {
   const filled = Math.min(Math.round(pct / 100 * width), width);
   const empty = width - filled;
@@ -354,6 +375,44 @@ function predictDifficulty(labels, description, priority, outcomes) {
   }
   return { difficulty, confidence, reasons };
 }
+function analyzeErrorsFromTraces(failedIssues) {
+  const patterns = {};
+  const evidence = [];
+  let db;
+  try {
+    db = openTracesDb();
+  } catch {
+    return { patterns, evidence };
+  }
+  try {
+    for (const issueId of failedIssues) {
+      const turns = getFailureTurns(issueId, 3, db);
+      if (turns.length === 0) continue;
+      for (const turn of turns) {
+        const preview = turn.message_preview || "";
+        const tools = turn.tool_names ? JSON.parse(turn.tool_names) : [];
+        const pattern = classifyErrorText(preview);
+        if (pattern) {
+          patterns[pattern] = (patterns[pattern] || 0) + 1;
+        }
+        if (evidence.length < 15) {
+          evidence.push({
+            issue: issueId,
+            phase: turn.phase || "unknown",
+            tools,
+            preview: preview.slice(0, 300)
+          });
+        }
+      }
+    }
+  } finally {
+    db.close();
+  }
+  if (Object.keys(patterns).length === 0 && failedIssues.length > 0) {
+    patterns["unknown"] = failedIssues.length;
+  }
+  return { patterns, evidence };
+}
 function loadOutcomes() {
   const logPath = getOutcomesLogPath();
   if (!existsSync(logPath)) return [];
@@ -465,7 +524,8 @@ async function evolvePromptTemplate(input) {
     errorPatterns,
     recs,
     outcomes,
-    dryRun
+    dryRun,
+    traceEvidence
   } = input;
   let currentTemplate;
   if (existsSync(templatePath)) {
@@ -478,11 +538,24 @@ async function evolvePromptTemplate(input) {
   }
   const failPhaseSummary = Object.entries(failPhases).sort((a, b) => b[1] - a[1]).map(([phase, count]) => `  - ${phase}: ${count} failures`).join("\n");
   const errorSummary = Object.entries(errorPatterns).sort((a, b) => b[1] - a[1]).map(([pattern, count]) => `  - ${pattern}: ${count} occurrences`).join("\n");
-  const failedOutcomes = outcomes.filter((o) => o.outcome === "failure" && o.errorTail).slice(-5);
-  const errorTails = failedOutcomes.map(
-    (o) => `  [${o.issue} attempt ${o.attempt}, phase: ${o.phase}]
+  let failureEvidenceSection;
+  if (traceEvidence && traceEvidence.length > 0) {
+    const evidenceLines = traceEvidence.slice(0, 10).map((ev) => {
+      const tools = ev.tools.length > 0 ? ev.tools.join(", ") : "none";
+      return `  [${ev.issue}, phase: ${ev.phase}, tools: ${tools}]
+  ${ev.preview.slice(0, 200)}`;
+    });
+    failureEvidenceSection = `ACTUAL FAILURE EVIDENCE (from conversation traces):
+${evidenceLines.join("\n\n")}`;
+  } else {
+    const failedOutcomes = outcomes.filter((o) => o.outcome === "failure" && o.errorTail).slice(-5);
+    const errorTails = failedOutcomes.map(
+      (o) => `  [${o.issue} attempt ${o.attempt}, phase: ${o.phase}]
   ${o.errorTail}`
-  ).join("\n\n");
+    ).join("\n\n");
+    failureEvidenceSection = `SAMPLE ERROR TAILS FROM RECENT FAILURES:
+${errorTails || "  (none)"}`;
+  }
   const mutationPrompt = `You are optimizing a prompt template for autonomous AI coding agents managed by a conductor system.
 
 CURRENT PROMPT TEMPLATE:
@@ -500,8 +573,7 @@ ${failPhaseSummary || "  (none)"}
 ERROR PATTERNS:
 ${errorSummary || "  (none)"}
 
-SAMPLE ERROR TAILS FROM RECENT FAILURES:
-${errorTails || "  (none)"}
+${failureEvidenceSection}
 
 RECOMMENDATIONS FROM ANALYSIS:
 ${recs.map((r) => `- ${r}`).join("\n")}
@@ -991,6 +1063,9 @@ function createConductorCommands() {
     "--dry-run",
     "Show evolved template without writing (use with --evolve)",
     false
+  ).option(
+    "--no-evidence",
+    "Disable trace-based evidence display (on by default when traces.db exists)"
   ).option(
     "--predict",
     "Show difficulty predictions alongside actual outcomes",
@@ -1039,22 +1114,23 @@ function createConductorCommands() {
     const retrySuccessRate = retries.length > 0 ? Math.round(
       retries.filter((o) => o.outcome === "success").length / retries.length * 100
     ) : 0;
-    const errorPatterns = {};
-    for (const o of outcomes.filter(
-      (o2) => o2.outcome === "failure" && o2.errorTail
-    )) {
-      const tail = o.errorTail;
-      if (tail.includes("lint"))
-        errorPatterns["lint_failure"] = (errorPatterns["lint_failure"] || 0) + 1;
-      else if (tail.includes("test"))
-        errorPatterns["test_failure"] = (errorPatterns["test_failure"] || 0) + 1;
-      else if (tail.includes("timeout") || tail.includes("timed out"))
-        errorPatterns["timeout"] = (errorPatterns["timeout"] || 0) + 1;
-      else if (tail.includes("conflict"))
-        errorPatterns["git_conflict"] = (errorPatterns["git_conflict"] || 0) + 1;
-      else if (tail.includes("429") || tail.includes("rate"))
-        errorPatterns["rate_limit"] = (errorPatterns["rate_limit"] || 0) + 1;
-      else errorPatterns["unknown"] = (errorPatterns["unknown"] || 0) + 1;
+    const failedIssueIds = [
+      ...new Set(
+        outcomes.filter((o) => o.outcome === "failure").map((o) => o.issue)
+      )
+    ];
+    const traceAnalysis = analyzeErrorsFromTraces(failedIssueIds);
+    let errorPatterns = traceAnalysis.patterns;
+    let traceEvidence = traceAnalysis.evidence;
+    if (Object.keys(errorPatterns).length === 0 || Object.keys(errorPatterns).length === 1 && errorPatterns["unknown"]) {
+      errorPatterns = {};
+      traceEvidence = [];
+      for (const o of outcomes.filter(
+        (o2) => o2.outcome === "failure" && o2.errorTail
+      )) {
+        const pattern = classifyErrorText(o.errorTail) ?? "unknown";
+        errorPatterns[pattern] = (errorPatterns[pattern] || 0) + 1;
+      }
     }
     if (options.export) {
       const analysis = {
@@ -1101,16 +1177,42 @@ function createConductorCommands() {
       }
     }
     if (Object.keys(errorPatterns).length > 0) {
-      console.log(`
-  ${c.b}Error Patterns${c.r}`);
+      const sourceLabel = traceEvidence.length > 0 ? "(from traces)" : "(from errorTail)";
+      console.log(
+        `
+  ${c.b}Error Patterns${c.r} ${c.d}${sourceLabel}${c.r}`
+      );
       const sorted = Object.entries(errorPatterns).sort(
         (a, b) => b[1] - a[1]
       );
       for (const [pattern, count] of sorted) {
         console.log(
-          `    ${c.red}\u25CF${c.r} ${pattern.padEnd(16)} ${c.white}${count}${c.r}`
+          `    ${c.red}\u25CF${c.r} ${pattern.padEnd(20)} ${c.white}${count}${c.r}`
+        );
+      }
+    }
+    if (options.evidence && traceEvidence.length > 0) {
+      console.log(
+        `
+  ${c.b}Failure Evidence${c.r} ${c.d}(from traces)${c.r}`
+      );
+      for (const ev of traceEvidence.slice(0, 15)) {
+        const tools = ev.tools.length > 0 ? ev.tools.join(", ") : "-";
+        console.log(
+          `    ${c.cyan}${ev.issue}${c.r} [${ev.phase}] tools: ${tools}`
         );
+        if (ev.preview) {
+          const lines = ev.preview.split("\n").slice(0, 3);
+          for (const line of lines) {
+            console.log(`      ${c.d}${line.slice(0, 100)}${c.r}`);
+          }
+        }
       }
+    } else if (options.evidence && traceEvidence.length === 0) {
+      console.log(
+        `
+  ${c.d}No trace data available. Run conductor with trace logging enabled to collect evidence.${c.r}`
+      );
     }
     console.log(`
   ${c.b}Recommendations${c.r}`);
@@ -1186,7 +1288,8 @@ function createConductorCommands() {
         errorPatterns,
         recs,
         outcomes,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
+        traceEvidence
       });
     }
     if (options.predict) {
@@ -1704,6 +1807,204 @@ function createConductorCommands() {
       process.on("SIGTERM", cleanup);
     });
   });
+  cmd.command("traces <issue-id>").description("Show conversation traces for an agent run").option("--session <id>", "Show specific session").option("--json", "Output as JSON", false).option("--tools", "Show tool frequency breakdown", false).option("--failures", "Show failure-turn details", false).option("-n, --tail <count>", "Failure tail turns", "5").action(
+    (issueId, options) => {
+      const db = openTracesDb();
+      try {
+        if (options.tools) {
+          const freq = getToolFrequencies(issueId, db);
+          if (freq.length === 0) {
+            console.log(`No traces found for ${issueId}`);
+            return;
+          }
+          console.log(
+            `
+  ${c.b}Tool Frequency${c.r} \u2014 ${c.cyan}${issueId}${c.r}
+`
+          );
+          for (const { tool_name, count } of freq.slice(0, 20)) {
+            const bar = "\u2501".repeat(Math.min(count, 40));
+            console.log(
+              `  ${c.d}${tool_name.padEnd(20)}${c.r} ${bar} ${count}`
+            );
+          }
+          console.log("");
+          return;
+        }
+        if (options.failures) {
+          const turns = getFailureTurns(
+            issueId,
+            parseInt(options.tail, 10),
+            db
+          );
+          if (turns.length === 0) {
+            console.log(`No traces found for ${issueId}`);
+            return;
+          }
+          console.log(
+            `
+  ${c.b}Failure Turns${c.r} \u2014 ${c.cyan}${issueId}${c.r}
+`
+          );
+          for (const t of turns) {
+            const tools = t.tool_names ? JSON.parse(t.tool_names).join(", ") : "-";
+            const ts = new Date(t.timestamp).toISOString().slice(11, 19);
+            console.log(
+              `  ${c.d}[${ts}]${c.r} turn ${t.turn_number} | phase: ${t.phase || "-"} | tools: ${tools}`
+            );
+            if (t.message_preview) {
+              const preview = t.message_preview.slice(0, 200);
+              console.log(`    ${c.d}${preview}${c.r}`);
+            }
+          }
+          console.log("");
+          return;
+        }
+        if (options.session) {
+          const turns = getSessionTurns(options.session, db);
+          if (turns.length === 0) {
+            console.log(`No turns found for session ${options.session}`);
+            return;
+          }
+          if (options.json) {
+            console.log(JSON.stringify(turns, null, 2));
+            return;
+          }
+          const phases = getPhaseBreakdown(options.session, db);
+          console.log(
+            `
+  ${c.b}Session${c.r} ${c.cyan}${options.session}${c.r}`
+          );
+          console.log(`  ${turns.length} turns
+`);
+          if (phases.length > 0) {
+            console.log(`  ${c.b}Phase Breakdown${c.r}`);
+            for (const p of phases) {
+              console.log(
+                `  ${(p.phase || "unknown").padEnd(14)} ${String(p.turns).padStart(3)} turns  ${String(p.tool_calls).padStart(4)} tools  ${formatTokens(p.input_tokens + p.output_tokens)}`
+              );
+            }
+            console.log("");
+          }
+          console.log(`  ${c.b}Turn Log${c.r}`);
+          for (const t of turns) {
+            const tools = t.tool_names ? JSON.parse(t.tool_names).join(", ") : "-";
+            const ts = new Date(t.timestamp).toISOString().slice(11, 19);
+            const tokens = t.input_tokens + t.output_tokens;
+            console.log(
+              `  ${c.d}${String(t.turn_number).padStart(3)}${c.r} [${ts}] ${(t.phase || "-").padEnd(12)} tools: ${tools.padEnd(30)} ${formatTokens(tokens)}`
+            );
+          }
+          console.log("");
+          return;
+        }
+        const sessions = listSessions(issueId, db);
+        if (sessions.length === 0) {
+          console.log(`No traces found for ${issueId}`);
+          return;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(sessions, null, 2));
+          return;
+        }
+        console.log(
+          `
+  ${c.b}Trace Sessions${c.r} \u2014 ${c.cyan}${issueId}${c.r}
+`
+        );
+        for (const s of sessions) {
+          const dur = s.duration_ms > 0 ? formatDuration(s.duration_ms) : "-";
+          const tokens = formatTokens(
+            s.total_input_tokens + s.total_output_tokens
+          );
+          const time = new Date(s.started_at).toISOString().slice(0, 19);
+          console.log(
+            `  ${c.d}attempt ${s.attempt}${c.r}  ${s.total_turns} turns  ${s.total_tool_calls} tools  ${tokens}  ${dur}  ${c.d}${time}${c.r}`
+          );
+          console.log(`    ${c.d}session: ${s.session_id}${c.r}`);
+          console.log(`    phases: ${s.phases.join(" \u2192 ")}`);
+          console.log("");
+        }
+      } finally {
+        db.close();
+      }
+    }
+  );
+  cmd.command("replay <session-id>").description("Replay a full agent conversation from traces").option("-n, --turns <count>", "Show only last N turns").option("--json", "Output raw event JSON", false).action((sessionId, options) => {
+    const db = openTracesDb();
+    try {
+      let turns = getSessionTurns(sessionId, db);
+      if (turns.length === 0) {
+        console.error(`No traces found for session ${sessionId}`);
+        return;
+      }
+      if (options.turns) {
+        const n = parseInt(options.turns, 10);
+        turns = turns.slice(-n);
+      }
+      if (options.json) {
+        for (const t of turns) {
+          console.log(t.event_json);
+        }
+        return;
+      }
+      console.log(
+        `
+  ${c.b}Replay${c.r} ${c.cyan}${sessionId}${c.r} \u2014 ${turns.length} turns
+`
+      );
+      for (const t of turns) {
+        const ts = new Date(t.timestamp).toISOString().slice(11, 19);
+        const tokens = t.input_tokens + t.output_tokens;
+        console.log(
+          `${c.purple}\u2500\u2500 Turn ${t.turn_number} \u2500\u2500${c.r} [${ts}] ${t.phase || ""} ${tokens > 0 ? formatTokens(tokens) : ""}`
+        );
+        if (t.tool_names) {
+          const tools = JSON.parse(t.tool_names);
+          for (const tool of tools) {
+            console.log(`  ${c.cyan}\u25B8 ${tool}${c.r}`);
+          }
+        }
+        if (t.message_preview) {
+          const lines = t.message_preview.split("\n");
+          for (const line of lines.slice(0, 10)) {
+            console.log(`  ${c.d}${line}${c.r}`);
+          }
+          if (lines.length > 10) {
+            console.log(
+              `  ${c.d}... (${lines.length - 10} more lines)${c.r}`
+            );
+          }
+        }
+        console.log("");
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("trace-stats").description("Show aggregate trace statistics").option("--json", "Output as JSON", false).action((options) => {
+    const stats = getTraceStats();
+    if (options.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
+    }
+    console.log(`
+  ${c.b}Conductor Trace Stats${c.r}
+`);
+    console.log(`  Sessions:  ${stats.total_sessions}`);
+    console.log(`  Turns:     ${stats.total_turns}`);
+    console.log(`  Issues:    ${stats.issues_traced}`);
+    console.log(
+      `  Tokens:    ${formatTokens((stats.total_input_tokens || 0) + (stats.total_output_tokens || 0))}`
+    );
+    console.log(
+      `    Input:   ${formatTokens(stats.total_input_tokens || 0)}`
+    );
+    console.log(
+      `    Output:  ${formatTokens(stats.total_output_tokens || 0)}`
+    );
+    console.log("");
+  });
   return cmd;
 }
 export {

package/dist/src/cli/commands/orchestrator.js

@@ -30,6 +30,10 @@ import {
 } from "../../core/worktree/preflight.js";
 import { ContextCapture } from "../../core/worktree/capture.js";
 import { extractKeywords } from "../../core/utils/text.js";
+import {
+  TraceCollector,
+  stringifyEventTruncated
+} from "./conductor-traces.js";
 function getOutcomesLogPath() {
   return join(homedir(), ".stackmemory", "conductor", "outcomes.jsonl");
 }
@@ -1272,6 +1276,17 @@ class Conductor {
       run.logStream = logStream;
       const tee = new TeeTransform(logStream);
       proc.stdout.pipe(tee);
+      let traceCollector;
+      try {
+        traceCollector = new TraceCollector({
+          issueId: issue.identifier,
+          attempt: run.attempt
+        });
+      } catch {
+        logger.warn("Failed to initialize trace collector", {
+          identifier: issue.identifier
+        });
+      }
       this.writeAgentStatus(issue.identifier, run);
       let stderr = "";
       let lastResultText = "";
@@ -1303,23 +1318,53 @@ class Conductor {
                 this.trackUsage(issue.identifier, msgUsage);
               }
               const content = message?.content || [];
+              const turnToolNames = [];
+              let turnFilesModified = 0;
+              const turnTextParts = [];
               for (const block of content) {
                 if (block.type === "tool_use") {
                   run.toolCalls++;
-                  const toolLower = (block.name || "").toLowerCase();
+                  const name = block.name || "";
+                  turnToolNames.push(name);
+                  const toolLower = name.toLowerCase();
                   if (toolLower.includes("edit") || toolLower.includes("write")) {
                     run.filesModified++;
+                    turnFilesModified++;
                   }
                 }
                 if (block.type === "text" && block.text) {
-                  run.tokensUsed += Math.ceil(
-                    block.text.length / 4
+                  const text = block.text;
+                  run.tokensUsed += Math.ceil(text.length / 4);
+                  turnTextParts.push(text);
+                }
+              }
+              try {
+                if (traceCollector) {
+                  const turnData = {
+                    toolNames: turnToolNames,
+                    toolCount: turnToolNames.length,
+                    filesModified: turnFilesModified,
+                    textPreview: turnTextParts.length > 0 ? turnTextParts.join("\n").slice(0, 500) : null,
+                    inputTokens: msgUsage?.input_tokens ?? 0,
+                    outputTokens: msgUsage?.output_tokens ?? 0,
+                    cacheCreationTokens: msgUsage?.cache_creation_input_tokens ?? 0,
+                    cacheReadTokens: msgUsage?.cache_read_input_tokens ?? 0
+                  };
+                  traceCollector.recordTurn(
+                    turnData,
+                    phase,
+                    stringifyEventTruncated(event)
                   );
                 }
+              } catch {
               }
             }
             if (event.type === "result" && event.result) {
               lastResultText = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+              try {
+                traceCollector?.recordResult(event);
+              } catch {
+              }
             }
             if (run.toolCalls % 5 === 0 || phase) {
               this.writeAgentStatus(issue.identifier, run);
@@ -1337,10 +1382,12 @@ class Conductor {
       });
       proc.on("error", (err) => {
         clearTimeout(timer);
+        traceCollector?.close();
         reject(new Error(`Failed to spawn claude: ${err.message}`));
       });
       proc.on("close", (code) => {
         clearTimeout(timer);
+        traceCollector?.close();
         run.process = null;
         if (run.logStream && !run.logStream.destroyed) {
           run.logStream.end();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Lossless, project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, conductor orchestrator, loop/watch monitoring, snapshot capture, pre-flight overlap checks, Claude/Codex/OpenCode wrappers, Linear sync, and automatic hooks.",
   "engines": {
     "node": ">=20.0.0",