@stackmemoryai/stackmemory 1.2.8 → 1.2.9

package/dist/src/integrations/mcp/server.js

@@ -13,7 +13,15 @@ import {
   AddAnchorSchema,
   CreateTaskSchema
 } from "./schemas.js";
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import {
+  readFileSync,
+  readdirSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  appendFileSync
+} from "fs";
+import { homedir } from "os";
 import { compactPlan } from "../../orchestrators/multimodal/utils.js";
 import { filterPending } from "./pending-utils.js";
 import { join, dirname } from "path";
@@ -1444,7 +1452,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Cord handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.cordHandlers.handleCordSpawn(args);
@@ -1455,7 +1464,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Cord handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.cordHandlers.handleCordFork(args);
@@ -1466,7 +1476,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Cord handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.cordHandlers.handleCordComplete(args);
@@ -1477,7 +1488,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Cord handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.cordHandlers.handleCordAsk(args);
@@ -1488,7 +1500,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Cord handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.cordHandlers.handleCordTree(args);
@@ -1500,7 +1513,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Team handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.teamHandlers.handleTeamContextGet(args);
@@ -1511,7 +1525,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Team handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.teamHandlers.handleTeamContextShare(args);
@@ -1522,7 +1537,8 @@ ${summary}...`, 0.8);
                 result = {
                   content: [
                     { type: "text", text: "Team handlers not initialized." }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.teamHandlers.handleTeamSearch(args);
@@ -1537,7 +1553,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleDelegateToModel(
@@ -1553,7 +1570,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleBatchSubmit(
@@ -1569,7 +1587,8 @@ ${summary}...`, 0.8);
                       type: "text",
                       text: "Multi-provider routing is disabled."
                     }
-                  ]
+                  ],
+                  is_error: true
                 };
               } else {
                 result = await this.providerHandlers.handleBatchCheck(
@@ -1580,12 +1599,16 @@ ${summary}...`, 0.8);
             case "sm_digest":
               result = await this.handleSmDigest(args);
               break;
+            case "sm_desire_paths":
+              result = this.handleDesirePaths(args);
+              break;
             default:
               throw new Error(`Unknown tool: ${name}`);
           }
         } catch (err) {
           error = err instanceof Error ? err : new Error(String(err));
           toolCall.error = error.message;
+          this.logDesirePath(name, args, error.message);
           throw err;
         } finally {
           const endTime = Date.now();
@@ -3052,6 +3075,128 @@ ${typeBreakdown}`
       matchedText: editResult.match.matchedText.length > 200 ? editResult.match.matchedText.slice(0, 200) + "..." : editResult.match.matchedText
     };
   }
+  /** Log failed tool calls to desire path JSONL for product prioritization */
+  logDesirePath(tool, args, errorMsg) {
+    try {
+      const home = process.env["HOME"] || "/tmp";
+      const dir = join(home, ".stackmemory", "desire-paths");
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      const category = /unknown tool/i.test(errorMsg) ? "unknown_tool" : /invalid param|missing.*param/i.test(errorMsg) ? "invalid_params" : "handler_error";
+      const sanitized = {};
+      for (const [k, v] of Object.entries(args)) {
+        sanitized[k] = typeof v === "string" && v.length > 200 ? v.slice(0, 200) + "...[truncated]" : v;
+      }
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const entry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        tool,
+        input: sanitized,
+        error: errorMsg.slice(0, 500),
+        category,
+        source: "mcp-server"
+      };
+      appendFileSync(
+        join(dir, `desire-server-${date}.jsonl`),
+        JSON.stringify(entry) + "\n"
+      );
+    } catch {
+    }
+  }
+  /** Handle sm_desire_paths tool — read and aggregate desire path logs */
+  handleDesirePaths(args) {
+    const mode = String(args.mode || "summary");
+    const days = Number(args.days || 7);
+    const limit = Number(args.limit || 20);
+    const categoryFilter = args.category ? String(args.category) : void 0;
+    const desireDir = join(homedir(), ".stackmemory", "desire-paths");
+    if (!existsSync(desireDir)) {
+      return {
+        content: [{ type: "text", text: "No desire path data found." }]
+      };
+    }
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
+    const files = readdirSync(desireDir).filter(
+      (f) => f.startsWith("desire-") && f.endsWith(".jsonl")
+    );
+    const entries = [];
+    for (const file of files) {
+      const lines = readFileSync(join(desireDir, file), "utf-8").split("\n").filter(Boolean);
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (new Date(entry.ts).getTime() < cutoff) continue;
+          if (categoryFilter && entry.category !== categoryFilter) continue;
+          entries.push(entry);
+        } catch {
+        }
+      }
+    }
+    if (entries.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No desire path data in the last ${days} day(s).`
+          }
+        ]
+      };
+    }
+    if (mode === "list") {
+      const recent = entries.sort((a, b) => b.ts.localeCompare(a.ts)).slice(0, limit);
+      const lines = recent.map(
+        (e) => `${e.ts.slice(0, 19)} ${e.tool} [${e.category}]
+  ${e.error.slice(0, 120)}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Recent desire paths (${recent.length}/${entries.length}):
+
+${lines.join("\n\n")}`
+          }
+        ]
+      };
+    }
+    const byTool = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const existing = byTool.get(e.tool);
+      if (!existing || e.ts > existing.lastSeen) {
+        byTool.set(e.tool, {
+          count: (existing?.count || 0) + 1,
+          category: e.category,
+          lastSeen: e.ts
+        });
+      } else {
+        existing.count++;
+      }
+    }
+    const sorted = [...byTool.entries()].sort(
+      (a, b) => b[1].count - a[1].count
+    );
+    const byCat = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      byCat.set(e.category, (byCat.get(e.category) || 0) + 1);
+    }
+    const toolLines = sorted.map(
+      ([tool, data]) => `${tool}: ${data.count}x [${data.category}] (last: ${data.lastSeen.slice(0, 10)})`
+    );
+    const catLines = [...byCat.entries()].sort((a, b) => b[1] - a[1]).map(([cat, count]) => `  ${cat}: ${count}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Desire Path Summary (last ${days}d, ${entries.length} total failures)
+
+By Tool:
+${toolLines.join("\n")}
+
+By Category:
+${catLines.join("\n")}`
+        }
+      ]
+    };
+  }
   async handleSmDigest(args) {
     const period = String(args.period || "today");
     if (!["today", "yesterday", "week"].includes(period)) {

package/dist/src/integrations/mcp/tool-definitions.js

@@ -23,7 +23,8 @@ class MCPToolDefinitions {
       ...this.getProviderTools(),
       ...this.getTeamTools(),
       ...this.getCordTools(),
-      ...this.getDigestTools()
+      ...this.getDigestTools(),
+      ...this.getDesirePathTools()
     ];
   }
   /**
@@ -1175,6 +1176,43 @@ class MCPToolDefinitions {
       }
     ];
   }
+  /**
+   * Desire path analysis tools
+   */
+  getDesirePathTools() {
+    return [
+      {
+        name: "sm_desire_paths",
+        description: 'Analyze failed tool calls (desire paths) \u2014 what agents want but cannot get. Use mode "summary" for aggregated counts or "list" for recent failures.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              enum: ["summary", "list"],
+              description: "Output mode: summary (aggregated) or list (recent)",
+              default: "summary"
+            },
+            limit: {
+              type: "number",
+              default: 20,
+              description: "Max entries to return (list mode only)"
+            },
+            category: {
+              type: "string",
+              enum: ["unknown_tool", "handler_error", "invalid_params"],
+              description: "Filter by failure category"
+            },
+            days: {
+              type: "number",
+              default: 7,
+              description: "Look back N days"
+            }
+          }
+        }
+      }
+    ];
+  }
   /**
    * Multi-agent team collaboration tools
    */
@@ -1426,6 +1464,8 @@ class MCPToolDefinitions {
         return this.getCordTools();
       case "digest":
         return this.getDigestTools();
+      case "desire_paths":
+        return this.getDesirePathTools();
       default:
         return [];
     }

package/dist/src/utils/hook-installer.js

@@ -47,6 +47,41 @@ const CANONICAL_HOOKS = [
     timeout: 2,
     commandPrefix: "node",
     required: false
+  },
+  {
+    scriptName: "team-subagent-stop.js",
+    eventType: "SubagentStop",
+    timeout: 5,
+    commandPrefix: "node",
+    required: false
+  },
+  {
+    scriptName: "team-task-complete.js",
+    eventType: "TaskCompleted",
+    timeout: 5,
+    commandPrefix: "node",
+    required: false
+  },
+  {
+    scriptName: "team-teammate-idle.js",
+    eventType: "TeammateIdle",
+    timeout: 3,
+    commandPrefix: "node",
+    required: false
+  },
+  {
+    scriptName: "desire-path-trace.js",
+    eventType: "PostToolUse",
+    timeout: 2,
+    commandPrefix: "node",
+    required: false
+  },
+  {
+    scriptName: "daemon-auto-start.js",
+    eventType: "PostToolUse",
+    timeout: 2,
+    commandPrefix: "node",
+    required: false
   }
 ];
 const DEAD_HOOKS = ["sms-response-handler.js"];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.2.8",
-  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 55 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
+  "version": "1.2.9",
+  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0"

package/scripts/install-claude-hooks-auto.js

@@ -89,6 +89,41 @@ try {
       commandPrefix: 'node',
       required: true,
     },
+    {
+      scriptName: 'team-subagent-stop.js',
+      eventType: 'SubagentStop',
+      timeout: 5,
+      commandPrefix: 'node',
+      required: false,
+    },
+    {
+      scriptName: 'team-task-complete.js',
+      eventType: 'TaskCompleted',
+      timeout: 5,
+      commandPrefix: 'node',
+      required: false,
+    },
+    {
+      scriptName: 'team-teammate-idle.js',
+      eventType: 'TeammateIdle',
+      timeout: 3,
+      commandPrefix: 'node',
+      required: false,
+    },
+    {
+      scriptName: 'desire-path-trace.js',
+      eventType: 'PostToolUse',
+      timeout: 2,
+      commandPrefix: 'node',
+      required: false,
+    },
+    {
+      scriptName: 'daemon-auto-start.js',
+      eventType: 'PostToolUse',
+      timeout: 2,
+      commandPrefix: 'node',
+      required: false,
+    },
   ];
 
   const DEAD_HOOKS = ['sms-response-handler.js'];

package/templates/claude-hooks/daemon-auto-start.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Daemon Auto-Start Hook (PostToolUse)
+ *
+ * Checks if the unified daemon is running on each tool call.
+ * If not, spawns it in the background. Runs at most once per session
+ * (tracks via env var to avoid repeated checks).
+ *
+ * Must complete in <50ms — PID file check + optional spawn.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const HOME = process.env.HOME || '/tmp';
+const DAEMON_DIR = path.join(HOME, '.stackmemory', 'daemon');
+const PID_FILE = path.join(DAEMON_DIR, 'daemon.pid');
+
+// Track whether we already checked this session (avoid repeated spawns)
+const STATE_KEY = 'STACKMEMORY_DAEMON_CHECKED';
+const SESSION_ID = process.env.CLAUDE_INSTANCE_ID || String(process.ppid);
+const STATE_FILE = path.join(
+  HOME,
+  '.stackmemory',
+  `daemon-check-${SESSION_ID}`
+);
+
+function isDaemonRunning() {
+  try {
+    if (!fs.existsSync(PID_FILE)) return false;
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+    if (isNaN(pid)) return false;
+    process.kill(pid, 0); // signal 0 = check existence
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function findDaemonScript() {
+  // Check common locations for the daemon script
+  const candidates = [
+    // Global npm install
+    path.join(
+      __dirname,
+      '..',
+      '..',
+      'node_modules',
+      '@stackmemoryai',
+      'stackmemory',
+      'dist',
+      'daemon',
+      'unified-daemon.js'
+    ),
+    // Homebrew global
+    path.join(
+      '/opt/homebrew/lib/node_modules/@stackmemoryai/stackmemory/dist/daemon/unified-daemon.js'
+    ),
+    // ~/.stackmemory/bin (installed by postinstall)
+    path.join(HOME, '.stackmemory', 'bin', 'session-daemon.js'),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function alreadyChecked() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const age = Date.now() - fs.statSync(STATE_FILE).mtimeMs;
+      // Re-check every 30 minutes
+      return age < 30 * 60 * 1000;
+    }
+  } catch {
+    // ignore
+  }
+  return false;
+}
+
+function markChecked() {
+  try {
+    const dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(STATE_FILE, String(Date.now()));
+  } catch {
+    // best effort
+  }
+}
+
+async function main() {
+  try {
+    // Skip if recently checked
+    if (alreadyChecked()) return;
+    markChecked();
+
+    // Already running? Done.
+    if (isDaemonRunning()) return;
+
+    // Try to spawn daemon
+    const script = findDaemonScript();
+    if (!script) return;
+
+    const child = spawn('node', [script], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env },
+    });
+    child.unref();
+  } catch {
+    // Silent fail -- never block the agent
+  }
+}
+
+// Read stdin (required by hook protocol) then run
+let input = '';
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+});
+process.stdin.on('end', () => {
+  main();
+});

package/templates/claude-hooks/desire-path-trace.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+/**
+ * Desire Path Trace Hook (PostToolUse)
+ *
+ * Detects failed tool calls and logs them to ~/.stackmemory/desire-paths/
+ * as JSONL for later analysis. Tracks what agents *want* but can't get:
+ * unknown tools, invalid params, handler errors.
+ *
+ * Must complete in <50ms -- pure file I/O only.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const HOME = process.env.HOME || '/tmp';
+const DESIRE_DIR = path.join(HOME, '.stackmemory', 'desire-paths');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function categorize(errorText) {
+  if (!errorText) return 'handler_error';
+  if (/unknown tool/i.test(errorText)) return 'unknown_tool';
+  if (
+    /invalid param|missing.*param|required.*param|unexpected.*param/i.test(
+      errorText
+    )
+  )
+    return 'invalid_params';
+  return 'handler_error';
+}
+
+function isFailure(input) {
+  // Check is_error flag
+  if (input.tool_response && input.tool_response.is_error === true) return true;
+
+  // Check for error text in response
+  const response =
+    typeof input.tool_response === 'string'
+      ? input.tool_response
+      : JSON.stringify(input.tool_response || '');
+
+  if (/Unknown tool:/i.test(response)) return true;
+  if (/^Error:/m.test(response)) return true;
+  if (/McpError|MCP error/i.test(response)) return true;
+
+  return false;
+}
+
+function extractError(input) {
+  const response = input.tool_response;
+  if (!response) return 'unknown error';
+
+  if (typeof response === 'string') return response.slice(0, 500);
+  if (response.error) return String(response.error).slice(0, 500);
+  if (response.content && Array.isArray(response.content)) {
+    const textBlock = response.content.find((b) => b.type === 'text');
+    if (textBlock) return String(textBlock.text).slice(0, 500);
+  }
+
+  return JSON.stringify(response).slice(0, 500);
+}
+
+function truncateInput(toolInput) {
+  if (!toolInput) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(toolInput)) {
+    if (typeof value === 'string' && value.length > 200) {
+      result[key] = value.slice(0, 200) + '...[truncated]';
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+async function readInput() {
+  let input = '';
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  return JSON.parse(input);
+}
+
+async function main() {
+  try {
+    const input = await readInput();
+
+    if (!isFailure(input)) return;
+
+    const errorText = extractError(input);
+    const date = new Date().toISOString().slice(0, 10);
+    const entry = {
+      ts: new Date().toISOString(),
+      sid:
+        input.session_id ||
+        process.env.CLAUDE_INSTANCE_ID ||
+        String(process.ppid),
+      tool: input.tool_name || 'unknown',
+      input: truncateInput(input.tool_input),
+      error: errorText,
+      category: categorize(errorText),
+      cwd: input.cwd || process.cwd(),
+    };
+
+    ensureDir(DESIRE_DIR);
+    const filePath = path.join(DESIRE_DIR, `desire-${date}.jsonl`);
+    fs.appendFileSync(filePath, JSON.stringify(entry) + '\n');
+  } catch {
+    // Silent fail -- never block the agent
+  }
+}
+
+main();