@stackmemoryai/stackmemory 1.6.2 → 1.8.0

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/dist/src/cli/commands/search.js

@@ -88,7 +88,7 @@ function createSearchCommand() {
           console.log("");
           totalResults += tasks.length;
         }
-      } catch (error) {
+      } catch {
       }
     }
     if (searchContext) {
@@ -123,7 +123,7 @@ function createSearchCommand() {
           console.log("");
           totalResults += contexts.length;
         }
-      } catch (error) {
+      } catch {
       }
     }
     if (searchContext) {
@@ -154,7 +154,7 @@ function createSearchCommand() {
           console.log("");
           totalResults += events.length;
         }
-      } catch (error) {
+      } catch {
       }
     }
     db.close();

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

@@ -759,7 +759,7 @@ function createSetupRemoteCommand() {
     const serviceDir = platform === "darwin" ? join(home, "Library", "LaunchAgents") : join(home, ".config", "systemd", "user");
     const serviceFile = platform === "darwin" ? join(serviceDir, `${serviceName}.plist`) : join(serviceDir, `${serviceName}.service`);
     const logDir = join(home, ".stackmemory", "logs");
-    const pidFile = join(home, ".stackmemory", "remote-mcp.pid");
+    const _pidFile = join(home, ".stackmemory", "remote-mcp.pid");
     if (options.status) {
       console.log(chalk.cyan("\nRemote MCP Server Status\n"));
       if (platform === "darwin") {

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

@@ -15,7 +15,7 @@ function registerSignupCommand(program) {
       try {
         await open(signupUrl);
         console.log(chalk.green("\u2713 Opened: ") + chalk.cyan(signupUrl));
-      } catch (error) {
+      } catch {
         console.log(chalk.yellow("Could not open browser automatically."));
         console.log(chalk.gray("Please visit: ") + chalk.cyan(signupUrl));
       }

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

@@ -46,7 +46,7 @@ function getVersion() {
   _version = "0.0.0";
   return _version;
 }
-function getEnv(key, defaultValue) {
+function _getEnv(key, defaultValue) {
   const value = process.env[key];
   if (value === void 0) {
     if (defaultValue !== void 0) return defaultValue;
@@ -58,7 +58,7 @@ function getEnv(key, defaultValue) {
   }
   return value;
 }
-function getOptionalEnv(key) {
+function _getOptionalEnv(key) {
   return process.env[key];
 }
 async function initializeSkillContext() {

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

@@ -75,7 +75,7 @@ Detected ${worktrees.length} worktree(s):`));
         } else {
           contextStatus = "\u25CB Not initialized";
         }
-      } catch (error) {
+      } catch {
         contextStatus = "\u2717 Error";
       }
       table.push([

package/dist/src/core/config/config-manager.js

@@ -7,7 +7,8 @@ import * as path from "path";
 import * as yaml from "js-yaml";
 import {
   DEFAULT_CONFIG,
-  PRESET_PROFILES
+  PRESET_PROFILES,
+  DEFAULT_ENRICHMENT
 } from "./types.js";
 class ConfigManager {
   static instance = null;
@@ -75,6 +76,7 @@ class ConfigManager {
         }
       },
       performance: { ...DEFAULT_CONFIG.performance, ...loaded.performance },
+      enrichment: { ...DEFAULT_ENRICHMENT, ...loaded.enrichment },
       profiles: { ...PRESET_PROFILES, ...loaded.profiles }
     };
     if (config.profile && config.profiles?.[config.profile]) {

package/dist/src/core/config/types.js

@@ -103,6 +103,11 @@ const PRESET_PROFILES = {
     }
   }
 };
+const DEFAULT_ENRICHMENT = {
+  enabled: false,
+  lookbackDepth: 3,
+  extractEntities: true
+};
 const DEFAULT_CONFIG = {
   version: "1.0",
   scoring: {
@@ -133,10 +138,12 @@ const DEFAULT_CONFIG = {
     retrieval_timeout_ms: 500,
     batch_upload_size: 100
   },
+  enrichment: DEFAULT_ENRICHMENT,
   profiles: PRESET_PROFILES
 };
 export {
   DEFAULT_CONFIG,
+  DEFAULT_ENRICHMENT,
   DEFAULT_TOOL_SCORES,
   DEFAULT_WEIGHTS,
   PRESET_PROFILES

package/dist/src/core/context/dual-stack-manager.js

@@ -19,7 +19,7 @@ class DualStackManager {
   activeContext;
   handoffRequests = /* @__PURE__ */ new Map();
   permissionManager;
-  constructor(adapter, projectId, userId, defaultTeamId) {
+  constructor(adapter, projectId, userId, _defaultTeamId) {
     this.adapter = adapter;
     this.permissionManager = new PermissionManager();
     const rawDb = adapter instanceof SQLiteAdapter ? adapter.getRawDatabase() : null;
@@ -796,7 +796,7 @@ class DualStackManager {
               )
             );
             stacks.push(context);
-          } catch (permissionError) {
+          } catch {
             logger.debug("User lacks access to stack", {
               stackId: context.stackId,
               userId: this.activeContext.ownerId