@stackmemoryai/stackmemory 1.2.7 → 1.2.9

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.7",
-  "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 32 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();

package/templates/claude-hooks/session-rescue.sh

@@ -13,3 +13,6 @@ command -v stackmemory >/dev/null 2>&1 || exit 0
 # Capture without committing, compact format, 10s timeout
 timeout 10 stackmemory capture --no-commit --format compact \
   -m "auto-rescue on session close" >/dev/null 2>&1 || true
+
+# Generate today's digest (best-effort, 5s timeout)
+timeout 5 stackmemory digest today >/dev/null 2>&1 || true

package/templates/claude-hooks/team-subagent-stop.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Team Subagent Stop Hook (SubagentStop)
+ *
+ * Fires when a subagent finishes. Captures the last assistant message
+ * as shared team context so other agents can see findings without
+ * manual team_context_share calls.
+ *
+ * Fire-and-forget: exits 0 always, never blocks the agent.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const MAX_CONTENT = 500;
+
+function hasStackmemory(cwd) {
+  let dir = cwd || process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (fs.existsSync(path.join(dir, '.stackmemory', 'context.db'))) {
+      return true;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+
+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();
+    const { agent_id, last_assistant_message, cwd } = input;
+
+    if (!hasStackmemory(cwd || process.cwd())) return;
+
+    const message = (last_assistant_message || '').slice(0, MAX_CONTENT).trim();
+    if (!message) return;
+
+    const args = [
+      'team',
+      'share',
+      '-c',
+      message,
+      '-t',
+      'FACT',
+      '-p',
+      '7',
+      '--source',
+      'subagent',
+    ];
+    if (agent_id) {
+      args.push('--agent-id', String(agent_id));
+    }
+
+    const child = spawn('stackmemory', args, {
+      stdio: 'ignore',
+      detached: true,
+      cwd: cwd || process.cwd(),
+    });
+    child.unref();
+  } catch {
+    // Silent fail — never block the agent
+  }
+}
+
+main();

package/templates/claude-hooks/team-task-complete.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Team Task Complete Hook (TaskCompleted)
+ *
+ * Fires when a task is marked complete. Shares the completion summary
+ * as a DECISION anchor so other agents know what was accomplished.
+ *
+ * Fire-and-forget: exits 0 always, never blocks the agent.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const MAX_CONTENT = 800;
+
+function hasStackmemory(cwd) {
+  let dir = cwd || process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (fs.existsSync(path.join(dir, '.stackmemory', 'context.db'))) {
+      return true;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+
+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();
+    const { task_id, task_subject, task_description, teammate_name, cwd } =
+      input;
+
+    if (!hasStackmemory(cwd || process.cwd())) return;
+
+    const who = teammate_name || 'agent';
+    const subject = task_subject || 'unknown task';
+    const desc = task_description || '';
+    const content = `Task completed by ${who}: ${subject}. ${desc}`
+      .slice(0, MAX_CONTENT)
+      .trim();
+
+    if (!content) return;
+
+    const args = [
+      'team',
+      'share',
+      '-c',
+      content,
+      '-t',
+      'DECISION',
+      '-p',
+      '8',
+      '--source',
+      'task-complete',
+    ];
+    if (task_id) {
+      args.push('--task-id', String(task_id));
+    }
+
+    const child = spawn('stackmemory', args, {
+      stdio: 'ignore',
+      detached: true,
+      cwd: cwd || process.cwd(),
+    });
+    child.unref();
+  } catch {
+    // Silent fail — never block the agent
+  }
+}
+
+main();

package/templates/claude-hooks/team-teammate-idle.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/**
+ * Team Teammate Idle Hook (TeammateIdle)
+ *
+ * Fires when a teammate is about to go idle. Logs the idle event
+ * for audit and shares a low-priority FACT anchor.
+ *
+ * Fire-and-forget: exits 0 always, never blocks the agent.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const HOME = process.env.HOME || '/tmp';
+
+function hasStackmemory(cwd) {
+  let dir = cwd || process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (fs.existsSync(path.join(dir, '.stackmemory', 'context.db'))) {
+      return true;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+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();
+    const { teammate_name, team_name, cwd } = input;
+
+    if (!hasStackmemory(cwd || process.cwd())) return;
+
+    const name = teammate_name || 'unknown';
+
+    // Log idle event for audit
+    const auditDir = path.join(HOME, '.stackmemory', 'team-events');
+    ensureDir(auditDir);
+    const entry = {
+      event: 'teammate_idle',
+      teammate: name,
+      team: team_name || 'default',
+      ts: new Date().toISOString(),
+      cwd: cwd || process.cwd(),
+    };
+    const auditFile = path.join(
+      auditDir,
+      `idle-${new Date().toISOString().slice(0, 10)}.jsonl`
+    );
+    fs.appendFileSync(auditFile, JSON.stringify(entry) + '\n');
+
+    // Share low-priority anchor
+    const content = `Teammate ${name} idle`;
+    const args = [
+      'team',
+      'share',
+      '-c',
+      content,
+      '-t',
+      'FACT',
+      '-p',
+      '4',
+      '--source',
+      'teammate-idle',
+    ];
+
+    const child = spawn('stackmemory', args, {
+      stdio: 'ignore',
+      detached: true,
+      cwd: cwd || process.cwd(),
+    });
+    child.unref();
+  } catch {
+    // Silent fail — never block the agent
+  }
+}
+
+main();