engramx 0.1.1 → 0.2.0

package/dist/chunk-QKCPFSVU.js

@@ -0,0 +1,361 @@
+// src/hooks.ts
+import { existsSync, readFileSync, writeFileSync, chmodSync, unlinkSync } from "fs";
+import { join } from "path";
+var HOOK_START = "# engram-hook-start";
+var HOOK_END = "# engram-hook-end";
+var POST_COMMIT_SCRIPT = `
+${HOOK_START}
+# Auto-rebuild engram graph after commit (AST only, no LLM needed)
+ENGRAM_BIN=$(command -v engram 2>/dev/null)
+if [ -z "$ENGRAM_BIN" ]; then
+  ENGRAM_BIN=$(npm root -g 2>/dev/null)/engram/dist/cli.js
+fi
+
+if [ -d ".engram" ] && [ -f "$ENGRAM_BIN" ]; then
+  node "$ENGRAM_BIN" init . --quiet 2>/dev/null &
+fi
+${HOOK_END}
+`;
+var POST_CHECKOUT_SCRIPT = `
+${HOOK_START}
+# Auto-rebuild engram graph on branch switch
+PREV_HEAD=$1
+NEW_HEAD=$2
+BRANCH_SWITCH=$3
+
+if [ "$BRANCH_SWITCH" != "1" ]; then
+  exit 0
+fi
+
+ENGRAM_BIN=$(command -v engram 2>/dev/null)
+if [ -z "$ENGRAM_BIN" ]; then
+  ENGRAM_BIN=$(npm root -g 2>/dev/null)/engram/dist/cli.js
+fi
+
+if [ -d ".engram" ] && [ -f "$ENGRAM_BIN" ]; then
+  echo "[engram] Branch switched \u2014 rebuilding graph..."
+  node "$ENGRAM_BIN" init . --quiet 2>/dev/null &
+fi
+${HOOK_END}
+`;
+function findGitRoot(from) {
+  let current = from;
+  while (current !== "/") {
+    if (existsSync(join(current, ".git"))) return current;
+    current = join(current, "..");
+  }
+  return null;
+}
+function installHook(hooksDir, name, script) {
+  const hookPath = join(hooksDir, name);
+  if (existsSync(hookPath)) {
+    const content = readFileSync(hookPath, "utf-8");
+    if (content.includes(HOOK_START)) {
+      return `${name}: already installed`;
+    }
+    writeFileSync(hookPath, content.trimEnd() + "\n\n" + script);
+    return `${name}: appended to existing hook`;
+  }
+  writeFileSync(hookPath, "#!/bin/bash\n" + script);
+  chmodSync(hookPath, 493);
+  return `${name}: installed`;
+}
+function uninstallHook(hooksDir, name) {
+  const hookPath = join(hooksDir, name);
+  if (!existsSync(hookPath)) return `${name}: not installed`;
+  const content = readFileSync(hookPath, "utf-8");
+  if (!content.includes(HOOK_START)) return `${name}: engram hook not found`;
+  const cleaned = content.replace(new RegExp(`\\n?${HOOK_START}[\\s\\S]*?${HOOK_END}\\n?`, "g"), "").trim();
+  if (!cleaned || cleaned === "#!/bin/bash") {
+    unlinkSync(hookPath);
+    return `${name}: removed`;
+  }
+  writeFileSync(hookPath, cleaned + "\n");
+  return `${name}: engram section removed (other hooks preserved)`;
+}
+function install(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Error: not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const results = [
+    installHook(hooksDir, "post-commit", POST_COMMIT_SCRIPT),
+    installHook(hooksDir, "post-checkout", POST_CHECKOUT_SCRIPT)
+  ];
+  return results.join("\n");
+}
+function uninstall(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Error: not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const results = [
+    uninstallHook(hooksDir, "post-commit"),
+    uninstallHook(hooksDir, "post-checkout")
+  ];
+  return results.join("\n");
+}
+function status(projectRoot) {
+  const gitRoot = findGitRoot(projectRoot);
+  if (!gitRoot) return "Not a git repository";
+  const hooksDir = join(gitRoot, ".git", "hooks");
+  const check = (name) => {
+    const p = join(hooksDir, name);
+    if (!existsSync(p)) return "not installed";
+    return readFileSync(p, "utf-8").includes(HOOK_START) ? "installed" : "not installed";
+  };
+  return `post-commit: ${check("post-commit")}
+post-checkout: ${check("post-checkout")}`;
+}
+
+// src/autogen.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var AUTOGEN_START = "<!-- engram:start -->";
+var AUTOGEN_END = "<!-- engram:end -->";
+var SECTION_BUILDERS = {
+  gods: (store, limit) => {
+    const gods = store.getGodNodes(limit);
+    if (gods.length === 0) return "";
+    return gods.map(
+      (g) => `- \`${g.node.label}\` (${g.node.kind}, ${g.degree} connections) \u2014 ${g.node.sourceFile}`
+    ).join("\n");
+  },
+  // Hot files are produced by git-miner as `kind: "pattern"` nodes with
+  // `metadata.type === "hot_file"`. We surface them separately so the
+  // Patterns section only contains real session-mined patterns.
+  hotFiles: (store, limit) => {
+    const allNodes = store.getAllNodes();
+    const hot = allNodes.filter(
+      (n) => n.kind === "pattern" && n.metadata?.type === "hot_file"
+    ).sort((a, b) => {
+      const ac = a.metadata.changeCount ?? 0;
+      const bc = b.metadata.changeCount ?? 0;
+      return bc - ac;
+    }).slice(0, limit);
+    if (hot.length === 0) return "";
+    return hot.map((n) => `- ${n.label}`).join("\n");
+  },
+  mistakes: (store, limit) => {
+    const mistakes = store.getAllNodes().filter((n) => n.kind === "mistake").slice(0, limit);
+    if (mistakes.length === 0) return "";
+    return mistakes.map((m) => `- ${m.label}`).join("\n");
+  },
+  decisions: (store, limit) => {
+    const decisions = store.getAllNodes().filter((n) => n.kind === "decision").slice(0, limit);
+    if (decisions.length === 0) return "";
+    return decisions.map((d) => `- ${d.label}`).join("\n");
+  },
+  // "Real" patterns = kind:pattern nodes that are NOT hot files.
+  // Hot files live in their own section so they don't clutter this one.
+  patterns: (store, limit) => {
+    const patterns = store.getAllNodes().filter((n) => {
+      if (n.kind !== "pattern") return false;
+      const meta = n.metadata;
+      return meta?.type !== "hot_file";
+    }).slice(0, limit);
+    if (patterns.length === 0) return "";
+    return patterns.map((p) => `- ${p.label}`).join("\n");
+  },
+  deps: (store, limit) => {
+    const allEdges = store.getAllEdges();
+    const importEdges = allEdges.filter((e) => e.relation === "imports");
+    const mostImported = /* @__PURE__ */ new Map();
+    for (const edge of importEdges) {
+      mostImported.set(edge.target, (mostImported.get(edge.target) ?? 0) + 1);
+    }
+    const topImported = [...mostImported.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+    if (topImported.length === 0) return "";
+    return topImported.map(([target, count]) => {
+      const node = store.getNode(target);
+      return `- \`${node?.label ?? target}\` (imported by ${count} files)`;
+    }).join("\n");
+  },
+  // `limit` is intentionally unused — the structure section always renders
+  // the full file tree. A 0 or positive limit is legal ceremony in the
+  // SectionSpec because every other builder honors it.
+  structure: (store, _limit) => {
+    void _limit;
+    const filesByDir = /* @__PURE__ */ new Map();
+    for (const node of store.getAllNodes()) {
+      if (node.kind !== "file" || !node.sourceFile) continue;
+      const parts = node.sourceFile.split("/");
+      const dir = parts.slice(0, -1).join("/") || ".";
+      if (!filesByDir.has(dir)) filesByDir.set(dir, []);
+      filesByDir.get(dir).push(node.label);
+    }
+    if (filesByDir.size === 0) return "";
+    return [...filesByDir.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([dir, files]) => `- \`${dir}/\` \u2014 ${files.join(", ")}`).join("\n");
+  }
+};
+var VIEWS = {
+  general: {
+    name: "general",
+    sections: [
+      { section: "gods", limit: 8, heading: "Core entities" },
+      { section: "structure", limit: 0, heading: "Structure" },
+      { section: "mistakes", limit: 5, heading: "\u26A0\uFE0F Past mistakes" },
+      { section: "decisions", limit: 5, heading: "Decisions" },
+      { section: "patterns", limit: 5, heading: "Patterns" },
+      { section: "deps", limit: 5, heading: "Key dependencies" }
+    ]
+  },
+  "bug-fix": {
+    name: "bug-fix",
+    sections: [
+      { section: "hotFiles", limit: 10, heading: "\u{1F525} Hot files" },
+      { section: "mistakes", limit: 10, heading: "\u26A0\uFE0F Past mistakes" },
+      { section: "gods", limit: 5, heading: "Core entities" },
+      { section: "structure", limit: 0, heading: "Structure" },
+      { section: "patterns", limit: 5, heading: "Patterns" }
+    ]
+  },
+  feature: {
+    name: "feature",
+    sections: [
+      { section: "gods", limit: 12, heading: "Core entities" },
+      { section: "structure", limit: 0, heading: "Structure" },
+      { section: "decisions", limit: 10, heading: "Decisions" },
+      { section: "deps", limit: 5, heading: "Key dependencies" },
+      { section: "mistakes", limit: 3, heading: "\u26A0\uFE0F Past mistakes" }
+    ]
+  },
+  refactor: {
+    name: "refactor",
+    sections: [
+      { section: "gods", limit: 15, heading: "Core entities" },
+      { section: "structure", limit: 0, heading: "Structure" },
+      { section: "deps", limit: 10, heading: "Key dependencies" },
+      { section: "patterns", limit: 10, heading: "Patterns" },
+      { section: "mistakes", limit: 5, heading: "\u26A0\uFE0F Past mistakes" }
+    ]
+  }
+};
+function generateSummary(store, view = VIEWS.general) {
+  const stats = store.getStats();
+  const parts = [
+    AUTOGEN_START,
+    "## Codebase Structure (auto-generated by engram)",
+    "",
+    `**Graph:** ${stats.nodes} nodes, ${stats.edges} edges | ${stats.extractedPct}% extracted, ${stats.inferredPct}% inferred`,
+    `**View:** ${view.name}`,
+    ""
+  ];
+  for (const spec of view.sections) {
+    const builder = SECTION_BUILDERS[spec.section];
+    if (!builder) continue;
+    const body = builder(store, spec.limit);
+    if (!body) continue;
+    parts.push(`## ${spec.heading}`, "", body, "");
+  }
+  parts.push(
+    '**Tip:** Run `engram query "your question"` for structural context instead of reading files.',
+    AUTOGEN_END
+  );
+  return parts.join("\n");
+}
+function analyzeMarkers(content) {
+  const realStarts = [];
+  const realEnds = [];
+  let fenceDepth = 0;
+  let pos = 0;
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      fenceDepth = fenceDepth === 0 ? 1 : 0;
+      pos += line.length + 1;
+      continue;
+    }
+    if (fenceDepth === 0) {
+      const startAt = line.indexOf(AUTOGEN_START);
+      if (startAt !== -1) realStarts.push(pos + startAt);
+      const endAt = line.indexOf(AUTOGEN_END);
+      if (endAt !== -1) realEnds.push(pos + endAt);
+    }
+    pos += line.length + 1;
+  }
+  if (realStarts.length === 0 && realEnds.length === 0) {
+    return { state: "none" };
+  }
+  if (realStarts.length === 1 && realEnds.length === 1 && realStarts[0] < realEnds[0]) {
+    return {
+      state: "balanced",
+      startOffset: realStarts[0],
+      endOffset: realEnds[0] + AUTOGEN_END.length
+    };
+  }
+  return {
+    state: "unbalanced",
+    error: `Found ${realStarts.length} start marker(s) and ${realEnds.length} end marker(s) outside code fences; expected exactly 1 of each. Fix the markers manually.`
+  };
+}
+function writeToFile(filePath, summary) {
+  let content = "";
+  if (existsSync2(filePath)) {
+    content = readFileSync2(filePath, "utf-8");
+  }
+  const analysis = analyzeMarkers(content);
+  if (analysis.state === "unbalanced") {
+    throw new Error(
+      `engram: cannot safely update ${filePath}: ${analysis.error} Re-run engram gen after fixing the markers.`
+    );
+  }
+  let newContent;
+  if (analysis.state === "balanced") {
+    newContent = content.slice(0, analysis.startOffset) + summary + content.slice(analysis.endOffset);
+  } else {
+    const trimmed = content.trimEnd();
+    newContent = (trimmed ? trimmed + "\n\n" : "") + summary + "\n";
+  }
+  if (!newContent.endsWith("\n")) newContent += "\n";
+  writeFileSync2(filePath, newContent);
+}
+async function autogen(projectRoot, target, task) {
+  const { getStore } = await import("./core-H72MM256.js");
+  const store = await getStore(projectRoot);
+  try {
+    let view = VIEWS.general;
+    if (task) {
+      const found = VIEWS[task];
+      if (!found) {
+        const valid = Object.keys(VIEWS).join(", ");
+        throw new Error(
+          `engram gen: unknown task "${task}". Valid: ${valid}.`
+        );
+      }
+      view = found;
+    }
+    const summary = generateSummary(store, view);
+    const stats = store.getStats();
+    let targetFile;
+    if (target === "claude") {
+      targetFile = join2(projectRoot, "CLAUDE.md");
+    } else if (target === "cursor") {
+      targetFile = join2(projectRoot, ".cursorrules");
+    } else if (target === "agents") {
+      targetFile = join2(projectRoot, "AGENTS.md");
+    } else {
+      if (existsSync2(join2(projectRoot, "CLAUDE.md"))) {
+        targetFile = join2(projectRoot, "CLAUDE.md");
+      } else if (existsSync2(join2(projectRoot, ".cursorrules"))) {
+        targetFile = join2(projectRoot, ".cursorrules");
+      } else if (existsSync2(join2(projectRoot, "AGENTS.md"))) {
+        targetFile = join2(projectRoot, "AGENTS.md");
+      } else {
+        targetFile = join2(projectRoot, "CLAUDE.md");
+      }
+    }
+    writeToFile(targetFile, summary);
+    return { file: targetFile, nodesIncluded: stats.nodes, view: view.name };
+  } finally {
+    store.close();
+  }
+}
+
+export {
+  install,
+  uninstall,
+  status,
+  VIEWS,
+  generateSummary,
+  autogen
+};

package/dist/cli.js

@@ -4,31 +4,42 @@ import {
   install,
   status,
   uninstall
-} from "./chunk-WJUA4VZ7.js";
+} from "./chunk-QKCPFSVU.js";
 import {
   benchmark,
   godNodes,
   init,
   learn,
+  mistakes,
   path,
   query,
   stats
-} from "./chunk-44GN6IRQ.js";
+} from "./chunk-D53DRZZL.js";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
 var program = new Command();
-program.name("engram").description("AI coding memory that learns from every session").version("0.1.0");
-program.command("init").description("Scan codebase and build knowledge graph (zero LLM cost)").argument("[path]", "Project directory", ".").action(async (projectPath) => {
+program.name("engram").description("AI coding memory that learns from every session").version("0.2.0");
+program.command("init").description("Scan codebase and build knowledge graph (zero LLM cost)").argument("[path]", "Project directory", ".").option(
+  "--with-skills [dir]",
+  "Also index Claude Code skills from ~/.claude/skills/ or a given path"
+).action(async (projectPath, opts) => {
   console.log(chalk.dim("\u{1F50D} Scanning codebase..."));
-  const result = await init(projectPath);
+  const result = await init(projectPath, {
+    withSkills: opts.withSkills
+  });
   console.log(
     chalk.green("\u{1F333} AST extraction complete") + chalk.dim(` (${result.timeMs}ms, 0 tokens used)`)
   );
   console.log(
     `   ${chalk.bold(String(result.nodes))} nodes, ${chalk.bold(String(result.edges))} edges from ${chalk.bold(String(result.fileCount))} files (${result.totalLines.toLocaleString()} lines)`
   );
+  if (result.skillCount && result.skillCount > 0) {
+    console.log(
+      chalk.cyan(`   ${chalk.bold(String(result.skillCount))} skills indexed`)
+    );
+  }
   const bench = await benchmark(projectPath);
   if (bench.naiveFullCorpus > 0 && bench.reductionVsRelevant > 1) {
     console.log(
@@ -105,6 +116,33 @@ program.command("learn").description("Teach engram a decision, pattern, or lesso
     console.log(chalk.yellow("No patterns extracted. Try a more specific statement."));
   }
 });
+program.command("mistakes").description("List known mistakes extracted from past sessions").option("-p, --project <path>", "Project directory", ".").option("-l, --limit <n>", "Max entries to display", "20").option("--since <days>", "Only mistakes from the last N days").action(
+  async (opts) => {
+    const result = await mistakes(opts.project, {
+      limit: Number(opts.limit),
+      sinceDays: opts.since ? Number(opts.since) : void 0
+    });
+    if (result.length === 0) {
+      console.log(chalk.yellow("No mistakes recorded."));
+      return;
+    }
+    console.log(
+      chalk.bold(`
+\u26A0\uFE0F  ${result.length} mistake(s) recorded:
+`)
+    );
+    for (const m of result) {
+      const ago = Math.max(
+        1,
+        Math.round((Date.now() - m.lastVerified) / 864e5)
+      );
+      console.log(
+        `  ${chalk.dim(`[${m.sourceFile}, ${ago}d ago]`)} ${m.label}`
+      );
+    }
+    console.log();
+  }
+);
 program.command("bench").description("Run token reduction benchmark").option("-p, --project <path>", "Project directory", ".").action(async (opts) => {
   const result = await benchmark(opts.project);
   console.log(chalk.bold("\n\u26A1 engram token reduction benchmark\n"));
@@ -122,8 +160,18 @@ var hooks = program.command("hooks").description("Manage git hooks");
 hooks.command("install").description("Install post-commit and post-checkout hooks").argument("[path]", "Project directory", ".").action((p) => console.log(install(p)));
 hooks.command("uninstall").description("Remove engram git hooks").argument("[path]", "Project directory", ".").action((p) => console.log(uninstall(p)));
 hooks.command("status").description("Check if hooks are installed").argument("[path]", "Project directory", ".").action((p) => console.log(status(p)));
-program.command("gen").description("Generate CLAUDE.md / .cursorrules section from graph").option("-p, --project <path>", "Project directory", ".").option("-t, --target <type>", "Target file: claude, cursor, agents").action(async (opts) => {
-  const result = await autogen(opts.project, opts.target);
-  console.log(chalk.green(`\u2705 Updated ${result.file} (${result.nodesIncluded} nodes)`));
-});
+program.command("gen").description("Generate CLAUDE.md / .cursorrules section from graph").option("-p, --project <path>", "Project directory", ".").option("-t, --target <type>", "Target file: claude, cursor, agents").option(
+  "--task <name>",
+  "Task-aware view: general (default), bug-fix, feature, refactor"
+).action(
+  async (opts) => {
+    const target = opts.target;
+    const result = await autogen(opts.project, target, opts.task);
+    console.log(
+      chalk.green(
+        `\u2705 Updated ${result.file} (${result.nodesIncluded} nodes, view: ${result.view})`
+      )
+    );
+  }
+);
 program.parse();

package/dist/{core-M5N34VUU.js → core-H72MM256.js}

@@ -5,10 +5,11 @@ import {
   godNodes,
   init,
   learn,
+  mistakes,
   path,
   query,
   stats
-} from "./chunk-44GN6IRQ.js";
+} from "./chunk-D53DRZZL.js";
 export {
   benchmark,
   getDbPath,
@@ -16,6 +17,7 @@ export {
   godNodes,
   init,
   learn,
+  mistakes,
   path,
   query,
   stats

package/dist/index.js

@@ -1,8 +1,10 @@
 import {
+  VIEWS,
   autogen,
+  generateSummary,
   install,
   uninstall
-} from "./chunk-WJUA4VZ7.js";
+} from "./chunk-QKCPFSVU.js";
 import {
   GraphStore,
   SUPPORTED_EXTENSIONS,
@@ -12,27 +14,37 @@ import {
   godNodes,
   init,
   learn,
+  mineSkills,
+  mistakes,
   path,
   query,
   queryGraph,
   shortestPath,
-  stats
-} from "./chunk-44GN6IRQ.js";
+  sliceGraphemeSafe,
+  stats,
+  truncateGraphemeSafe
+} from "./chunk-D53DRZZL.js";
 export {
   GraphStore,
   SUPPORTED_EXTENSIONS,
+  VIEWS,
   autogen,
   benchmark,
   extractDirectory,
   extractFile,
+  generateSummary,
   godNodes,
   init,
   install as installHooks,
   learn,
+  mineSkills,
+  mistakes,
   path,
   query,
   queryGraph,
   shortestPath,
+  sliceGraphemeSafe,
   stats,
+  truncateGraphemeSafe,
   uninstall as uninstallHooks
 };

package/dist/serve.js

@@ -1,13 +1,21 @@
 #!/usr/bin/env node
 import {
+  MAX_MISTAKE_LABEL_CHARS,
   benchmark,
   godNodes,
+  mistakes,
   path,
   query,
-  stats
-} from "./chunk-44GN6IRQ.js";
+  stats,
+  truncateGraphemeSafe
+} from "./chunk-D53DRZZL.js";
 
 // src/serve.ts
+function clampInt(value, defaultValue, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return defaultValue;
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
 var PROJECT_ROOT = process.argv[2] || process.cwd();
 var TOOLS = [
   {
@@ -50,22 +58,41 @@ var TOOLS = [
     name: "benchmark",
     description: "Compare token cost of graph queries vs reading raw files.",
     inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "list_mistakes",
+    description: "List known mistakes from the knowledge graph \u2014 prior bugs, failure modes, and wrong approaches extracted from past session documents. Use this before making changes to check if the codebase has hit similar problems before.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "integer",
+          default: 20,
+          description: "Maximum number of mistakes to return"
+        },
+        since_days: {
+          type: "integer",
+          description: "Only return mistakes verified in the last N days"
+        }
+      }
+    }
   }
 ];
 async function handleToolCall(name, args) {
   switch (name) {
     case "query_graph": {
-      const result = await query(PROJECT_ROOT, args.question, {
-        mode: args.mode ?? "bfs",
-        depth: args.depth ?? 3,
-        tokenBudget: args.token_budget ?? 2e3
+      const question = typeof args.question === "string" ? args.question : "";
+      const result = await query(PROJECT_ROOT, question, {
+        mode: args.mode === "dfs" ? "dfs" : "bfs",
+        depth: clampInt(args.depth, 3, 1, 6),
+        tokenBudget: clampInt(args.token_budget, 2e3, 100, 1e4)
       });
       return `${result.nodesFound} nodes found (~${result.estimatedTokens} tokens)
 
 ${result.text}`;
     }
     case "god_nodes": {
-      const gods = await godNodes(PROJECT_ROOT, args.top_n ?? 10);
+      const gods = await godNodes(PROJECT_ROOT, clampInt(args.top_n, 10, 1, 100));
       return gods.map((g, i) => `${i + 1}. ${g.label} [${g.kind}] \u2014 ${g.degree} edges (${g.sourceFile})`).join("\n");
     }
     case "graph_stats": {
@@ -91,6 +118,17 @@ AMBIGUOUS: ${s.ambiguousPct}%`;
         ...b.perQuestion.map((pq) => `[${pq.reductionFull}x full / ${pq.reductionRelevant}x relevant] ${pq.question}`)
       ].join("\n");
     }
+    case "list_mistakes": {
+      const result = await mistakes(PROJECT_ROOT, {
+        limit: clampInt(args.limit, 20, 1, 100),
+        sinceDays: args.since_days !== void 0 ? clampInt(args.since_days, 0, 0, 3650) : void 0
+      });
+      if (result.length === 0) return "No mistakes recorded.";
+      return result.map((m, i) => {
+        const label = truncateGraphemeSafe(m.label, MAX_MISTAKE_LABEL_CHARS);
+        return `${i + 1}. ${label} (confidence: ${m.confidence} ${m.confidenceScore}, from ${m.sourceFile})`;
+      }).join("\n");
+    }
     default:
       return `Unknown tool: ${name}`;
   }
@@ -103,13 +141,28 @@ process.stdin.on("data", (chunk) => {
   buffer = lines.pop() ?? "";
   for (const line of lines) {
     if (!line.trim()) continue;
+    let req;
     try {
-      const req = JSON.parse(line);
-      handleRequest(req).then((res) => {
-        process.stdout.write(JSON.stringify(res) + "\n");
-      });
+      req = JSON.parse(line);
     } catch {
+      const errResp = {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Parse error" }
+      };
+      process.stdout.write(JSON.stringify(errResp) + "\n");
+      continue;
     }
+    handleRequest(req).then((res) => {
+      process.stdout.write(JSON.stringify(res) + "\n");
+    }).catch(() => {
+      const errResp = {
+        jsonrpc: "2.0",
+        id: req.id,
+        error: { code: -32e3, message: "Internal server error" }
+      };
+      process.stdout.write(JSON.stringify(errResp) + "\n");
+    });
   }
 });
 async function handleRequest(req) {
@@ -121,7 +174,7 @@ async function handleRequest(req) {
         result: {
           protocolVersion: "2024-11-05",
           capabilities: { tools: {} },
-          serverInfo: { name: "engram", version: "0.1.0" }
+          serverInfo: { name: "engram", version: "0.2.0" }
         }
       };
     case "tools/list":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engramx",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "AI coding memory that learns from every session — persistent, structural, universal",
   "type": "module",
   "bin": {