claude-code-swarm 0.3.12 → 0.3.17

package/.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.12",
+  "version": "0.3.17",
   "description": "Launch Claude Code with swarmkit capabilities, including team orchestration, MAP observability, and session tracking.",
   "owner": {
     "name": "alexngai"

package/.claude-plugin/mcp-launcher.mjs

@@ -162,12 +162,25 @@ if (!def.enabled()) {
   runNoop();
 } else {
   const { cmd, args } = def.launch();
-  if (which(cmd)) {
-    // Replace this process with the real server
-    const { execFileSync: _ , ...rest } = await import('node:child_process');
+  const resolved = which(cmd);
+  // Debug: log MCP server resolution to a temp file for diagnostics
+  try {
+    const { appendFileSync } = await import('node:fs');
+    appendFileSync('/tmp/mcp-launcher-debug.log', `[${new Date().toISOString()}] server=${server} cmd=${cmd} resolved=${resolved} cwd=${process.cwd()} args=${JSON.stringify(args)}\n`);
+  } catch {}
+  if (resolved) {
+    // Replace this process with the real server.
+    // NODE_NO_WARNINGS suppresses Node.js experimental feature warnings on stderr
+    // (e.g., sqlite). Some MCP clients interpret stderr output as server errors,
+    // causing them to mark the server as "failed" even though it's functional.
+    const spawnEnv = { ...process.env, NODE_NO_WARNINGS: '1' };
     const child = (await import('node:child_process')).spawn(cmd, args, {
-      stdio: 'inherit',
+      stdio: ['inherit', 'inherit', 'pipe'],
+      env: spawnEnv,
     });
+    // Swallow stderr to prevent MCP client from misinterpreting it.
+    // In debug mode, forward to our stderr.
+    child.stderr.on('data', () => {});
     child.on('exit', (code) => process.exit(code ?? 0));
   } else {
     process.stderr.write(`[${server}-mcp] ${cmd} CLI not found\n`);

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-swarm",
   "description": "Spin up Claude Code agent teams from openteams YAML topologies with optional MAP (Multi-Agent Protocol) observability and coordination. Provides hooks for session lifecycle, agent spawn/complete tracking, and a /swarm skill to launch team configurations.",
-  "version": "0.3.12",
+  "version": "0.3.17",
   "author": {
     "name": "alexngai"
   },

package/e2e/tier7-memory-sync.test.mjs

@@ -0,0 +1,259 @@
+/**
+ * Tier 7: minimem → MAP sync integration test
+ *
+ * Tests the full bridge flow:
+ *   Agent uses minimem MCP tool (write) → PostToolUse hook fires
+ *   → map-hook.mjs builds bridge command → sidecar calls x-openhive/memory.sync
+ *   → Mock MAP server receives the sync notification
+ *
+ * Groups:
+ *   1. Hook configuration verification (no agent, no LLM)
+ *   2. Bridge command builder (no agent, no LLM)
+ *   3. Live agent writes memory → MAP event received (LIVE_AGENT_TEST=1)
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { createWorkspace } from "./helpers/workspace.mjs";
+import { cleanupWorkspace, waitFor } from "./helpers/cleanup.mjs";
+import { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+
+// Check if dependencies are available (try require for CJS-compatible packages)
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+
+let minimemAvailable = false;
+try {
+  require("minimem");
+  minimemAvailable = true;
+} catch { /* minimem not installed */ }
+
+let mapSdkAvailable = false;
+try {
+  require("@multi-agent-protocol/sdk");
+  mapSdkAvailable = true;
+} catch { /* MAP SDK not installed */ }
+
+// Check if Claude CLI is available
+let cliAvailable = false;
+try {
+  const { CLI_AVAILABLE } = await import("./helpers/cli.mjs");
+  cliAvailable = CLI_AVAILABLE;
+} catch { /* CLI not available */ }
+
+// ── Group 1: Hook configuration ─────────────────────────────────────────────
+
+describe("tier7: minimem sync hook configuration", { timeout: 30_000 }, () => {
+  it("hooks.json has a PostToolUse entry for minimem", () => {
+    const hooksPath = join(import.meta.dirname, "..", "hooks", "hooks.json");
+    const hooks = JSON.parse(readFileSync(hooksPath, "utf-8"));
+    const postToolUse = hooks.hooks.PostToolUse || [];
+
+    const minimemHook = postToolUse.find((h) => h.matcher === "minimem");
+    expect(minimemHook).toBeDefined();
+    expect(minimemHook.hooks[0].command).toContain("minimem-mcp-used");
+  });
+
+  it("minimem hook checks both minimem.enabled and map.enabled", () => {
+    const hooksPath = join(import.meta.dirname, "..", "hooks", "hooks.json");
+    const hooks = JSON.parse(readFileSync(hooksPath, "utf-8"));
+    const postToolUse = hooks.hooks.PostToolUse || [];
+
+    const minimemHook = postToolUse.find((h) => h.matcher === "minimem");
+    const cmd = minimemHook.hooks[0].command;
+
+    expect(cmd).toContain("minimem");
+    expect(cmd).toContain("map");
+  });
+
+  it("hooks.json minimem hook is gated behind config check", () => {
+    const hooksPath = join(import.meta.dirname, "..", "hooks", "hooks.json");
+    const hooks = JSON.parse(readFileSync(hooksPath, "utf-8"));
+    const postToolUse = hooks.hooks.PostToolUse || [];
+
+    const minimemHook = postToolUse.find((h) => h.matcher === "minimem");
+    const cmd = minimemHook.hooks[0].command;
+
+    // Should have the config check prefix (node -e "..." && node map-hook.mjs)
+    expect(cmd).toContain('node -e');
+    expect(cmd).toContain('process.exit');
+    expect(cmd).toContain('map-hook.mjs');
+  });
+});
+
+// ── Group 2: Bridge command builder ─────────────────────────────────────────
+
+describe("tier7: minimem bridge command builder", { timeout: 30_000 }, () => {
+  it("builds command for write operations", async () => {
+    const { buildMinimemBridgeCommand } = await import("../src/map-events.mjs");
+
+    const cmd = buildMinimemBridgeCommand({
+      tool_name: "minimem__memory_append",
+      tool_input: { text: "Test memory entry" },
+      session_id: "test-session",
+    });
+
+    expect(cmd).not.toBeNull();
+    expect(cmd.action).toBe("bridge-memory-sync");
+    expect(cmd.agentId).toBe("test-session");
+  });
+
+  it("skips read-only operations", async () => {
+    const { buildMinimemBridgeCommand } = await import("../src/map-events.mjs");
+
+    const cmd = buildMinimemBridgeCommand({
+      tool_name: "minimem__memory_search",
+      tool_input: { query: "test" },
+    });
+
+    expect(cmd).toBeNull();
+  });
+
+  it("map-hook.mjs switch statement includes minimem-mcp-used", () => {
+    const hookScript = readFileSync(
+      join(import.meta.dirname, "..", "scripts", "map-hook.mjs"),
+      "utf-8"
+    );
+    expect(hookScript).toContain('"minimem-mcp-used"');
+    expect(hookScript).toContain("handleMinimemMcpUsed");
+  });
+
+  it("sidecar-server.mjs handles bridge-memory-sync command", () => {
+    const sidecarScript = readFileSync(
+      join(import.meta.dirname, "..", "src", "sidecar-server.mjs"),
+      "utf-8"
+    );
+    expect(sidecarScript).toContain('"bridge-memory-sync"');
+    expect(sidecarScript).toContain("x-openhive/memory.sync");
+  });
+});
+
+// ── Group 3: Live agent test ────────────────────────────────────────────────
+
+describe.skipIf(!process.env.LIVE_AGENT_TEST || !minimemAvailable || !cliAvailable || !mapSdkAvailable)(
+  "tier7: live agent minimem → MAP sync",
+  { timeout: 300_000 },
+  () => {
+    let mockServer;
+    let workspace;
+    let messages;
+    let runResult;
+
+    beforeAll(async () => {
+      const { MockMapServer } = await import("./helpers/map-mock-server.mjs");
+      mockServer = new MockMapServer();
+      await mockServer.start();
+
+      workspace = createWorkspace({
+        config: {
+          minimem: { enabled: true, provider: "none" },
+          map: {
+            enabled: true,
+            server: `ws://localhost:${mockServer.port}`,
+          },
+        },
+        gitInit: true,
+      });
+
+      // Initialize minimem in the workspace so the MCP server can start.
+      // Must run `minimem sync` to create index.db — without it the MCP server
+      // starts but may report tools inconsistently.
+      const minimemDir = join(workspace.dir, ".swarm", "minimem");
+      mkdirSync(join(minimemDir, "memory"), { recursive: true });
+      writeFileSync(join(minimemDir, "MEMORY.md"), "# Test Memory\n");
+      writeFileSync(
+        join(minimemDir, "config.json"),
+        JSON.stringify({ embedding: { provider: "none" } })
+      );
+      writeFileSync(join(minimemDir, ".gitignore"), "index.db\n");
+
+      // Initialize the search index — critical for MCP server readiness.
+      // Use require() to avoid ESM resolution issues with node:sqlite in vitest.
+      try {
+        const { Minimem } = require("minimem");
+        const mem = await Minimem.create({ memoryDir: minimemDir, embedding: { provider: "none" } });
+        await mem.sync();
+        await mem.close();
+      } catch (err) {
+        console.warn("[tier7] minimem init warning:", err.message?.slice(0, 200));
+      }
+
+      const { runClaude } = await import("./helpers/cli.mjs");
+      runResult = await runClaude(
+        'Use the minimem MCP tools: First search for "test" using memory_search. Then write a memory file at .swarm/minimem/memory/e2e-test.md containing "### 2026-03-31 12:00\n<!-- type: decision -->\nChose PostgreSQL for the main database." using the Write tool. Report what you did.',
+        {
+          cwd: workspace.dir,
+          model: "haiku",
+          maxTurns: 6,
+          maxBudgetUsd: 0.5,
+          timeout: 120_000,
+          label: "memory-sync-e2e",
+        }
+      );
+      messages = runResult.messages;
+    }, 300_000);
+
+    afterAll(async () => {
+      if (workspace) {
+        try { cleanupWorkspace(workspace.dir); } catch { /* best effort */ }
+      }
+      if (mockServer) {
+        try { await mockServer.stop(); } catch { /* best effort */ }
+      }
+    });
+
+    it("agent completed without error", () => {
+      expect(runResult.exitCode).toBe(0);
+    });
+
+    it("agent used minimem MCP tools", () => {
+      const { extractToolCalls } = require("./helpers/assertions.mjs");
+      const allCalls = extractToolCalls(messages);
+      const memCalls = allCalls.filter((c) =>
+        c.name?.includes("minimem") || c.name?.includes("memory_search")
+      );
+      expect(memCalls.length).toBeGreaterThan(0);
+    });
+
+    it("agent wrote a memory file", () => {
+      const { extractToolCalls } = require("./helpers/assertions.mjs");
+      const allCalls = extractToolCalls(messages);
+      // Agent may use Write tool to create memory file, or minimem append/upsert
+      const writeCalls = allCalls.filter(
+        (c) => c.name === "Write" || c.name?.includes("append") || c.name?.includes("upsert")
+      );
+      expect(writeCalls.length).toBeGreaterThan(0);
+    });
+
+    it("memory file was written to disk", () => {
+      const minimemDir = join(workspace.dir, ".swarm", "minimem");
+      const memoryDir = join(minimemDir, "memory");
+      if (!existsSync(memoryDir)) return; // skip if dir not created
+      const mdFiles = readdirSync(memoryDir).filter((f) => f.endsWith(".md"));
+      expect(mdFiles.length).toBeGreaterThan(0);
+    });
+
+    it("sidecar file watcher sent MAP sync notification", async () => {
+      // The sidecar's memory file watcher detects .md file writes and sends
+      // bridge-memory-sync → callExtension("x-openhive/memory.sync").
+      // This covers both Write tool and minimem MCP tool writes.
+      //
+      // The watcher has a 2s debounce, so we wait up to 10s for the event.
+      const received = await waitFor(() => {
+        const extCalls = mockServer.getByMethod("x-openhive/memory.sync");
+        if (extCalls.length > 0) return true;
+        const broadcasts = mockServer.getMessages("memory.sync");
+        if (broadcasts.length > 0) return true;
+        // Check all received messages for any memory-related content
+        const all = mockServer.receivedMessages || [];
+        return all.some(
+          (m) =>
+            JSON.stringify(m).includes("memory") &&
+            JSON.stringify(m).includes("sync")
+        );
+      }, 10_000);
+
+      expect(received).toBe(true);
+    });
+  }
+);

package/hooks/hooks.json

@@ -10,7 +10,7 @@
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-start; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-start"
           }
         ]
       }
@@ -21,7 +21,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-end; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch session-end"
           }
         ]
       }
@@ -32,11 +32,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" inject; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" inject"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch user-prompt-submit; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch user-prompt-submit"
           }
         ]
       }
@@ -47,7 +47,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch pre-task; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch pre-task"
           }
         ]
       }
@@ -58,7 +58,16 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit((c.opentasks?.enabled||process.env.SWARM_OPENTASKS_ENABLED)&&(c.map?.enabled||c.map?.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" opentasks-mcp-used; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit((c.opentasks?.enabled||process.env.SWARM_OPENTASKS_ENABLED)&&(c.map?.enabled||c.map?.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" opentasks-mcp-used"
+          }
+        ]
+      },
+      {
+        "matcher": "minimem",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit((c.minimem?.enabled||process.env.SWARM_MINIMEM_ENABLED)&&(c.map?.enabled||c.map?.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" minimem-mcp-used"
           }
         ]
       },
@@ -67,7 +76,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task"
           }
         ]
       },
@@ -76,11 +85,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-created; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-created"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-create; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-create"
           }
         ]
       },
@@ -89,11 +98,11 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-updated; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" native-task-updated"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-update; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-task-update"
           }
         ]
       },
@@ -102,7 +111,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-todo; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-todo"
           }
         ]
       },
@@ -111,7 +120,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-enter; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-enter"
           }
         ]
       },
@@ -120,7 +129,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-exit; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-plan-exit"
           }
         ]
       },
@@ -129,7 +138,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-skill; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch post-skill"
           }
         ]
       }
@@ -140,15 +149,15 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" turn-completed; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" turn-completed"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));const m=c.map||{};process.exit((m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)&&c.sessionlog?.sync&&c.sessionlog.sync!=='off'?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-sync; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit((m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED)&&c.sessionlog?.sync&&c.sessionlog.sync!=='off'?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-sync"
           },
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8'));process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch stop; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};process.exit(c.sessionlog?.enabled?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" sessionlog-dispatch stop"
           }
         ]
       }
@@ -159,7 +168,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-start; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-start"
           }
         ]
       }
@@ -170,7 +179,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-stop; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" subagent-stop"
           }
         ]
       }
@@ -181,7 +190,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" teammate-idle; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" teammate-idle"
           }
         ]
       }
@@ -192,7 +201,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "if [ -f .swarm/claude-swarm/config.json ] && node -e \"const c=JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json','utf-8')).map||{};process.exit(c.enabled||c.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null; then node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" task-completed; fi"
+            "command": "node -e \"const f=require('fs'),p=require('path'),h=require('os').homedir();let c={};try{c=JSON.parse(f.readFileSync('.swarm/claude-swarm/config.json','utf-8'))}catch{try{c=JSON.parse(f.readFileSync(p.join(h,'.claude-swarm','config.json'),'utf-8'))}catch{}};const m=c.map||{};process.exit(m.enabled||m.server||process.env.SWARM_MAP_SERVER||process.env.SWARM_MAP_ENABLED?0:1)\" 2>/dev/null && node \"${CLAUDE_PLUGIN_ROOT}/scripts/map-hook.mjs\" task-completed"
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.12",
+  "version": "0.3.17",
   "description": "Claude Code plugin for launching agent teams from openteams topologies with MAP observability",
   "type": "module",
   "exports": {
@@ -18,7 +18,7 @@
     "swarm-generate-agents": "./scripts/generate-agents.mjs"
   },
   "dependencies": {
-    "@multi-agent-protocol/sdk": "^0.1.4",
+    "@multi-agent-protocol/sdk": "^0.1.9",
     "agentic-mesh": "^0.2.0",
     "js-yaml": "^4.1.0"
   },
@@ -54,8 +54,8 @@
   },
   "devDependencies": {
     "agent-inbox": "^0.1.9",
-    "minimem": "^0.1.0",
-    "opentasks": "^0.0.6",
+    "minimem": "^0.1.1",
+    "opentasks": "^0.0.8",
     "skill-tree": "^0.1.5",
     "vitest": "^4.0.18",
     "ws": "^8.0.0"

package/scripts/map-hook.mjs

@@ -48,6 +48,7 @@ import {
   buildOpentasksBridgeCommands,
   handleNativeTaskCreatedEvent,
   handleNativeTaskUpdatedEvent,
+  buildMinimemBridgeCommand,
 } from "../src/map-events.mjs";
 import { syncSessionlog, dispatchSessionlogHook } from "../src/sessionlog.mjs";
 import { findSocketPath, pushSyncEvent } from "../src/opentasks-client.mjs";
@@ -194,6 +195,18 @@ async function handleSessionlogDispatch(hookData) {
   await dispatchSessionlogHook(sessionlogHookName, hookData);
 }
 
+// ── minimem sync ─────────────────────────────────────────────────────────────
+
+async function handleMinimemMcpUsed(hookData, sessionId) {
+  const config = readConfig();
+  if (!config.minimem?.enabled) return;
+
+  const command = buildMinimemBridgeCommand(hookData);
+  if (command) {
+    await sendCommand(config, command, sessionId);
+  }
+}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 
 async function main() {
@@ -214,6 +227,7 @@ async function main() {
       case "opentasks-mcp-used": await handleOpentasksMcpUsed(hookData, sessionId); break;
       case "native-task-created": await handleNativeTaskCreated(hookData, sessionId); break;
       case "native-task-updated": await handleNativeTaskUpdated(hookData, sessionId); break;
+      case "minimem-mcp-used": await handleMinimemMcpUsed(hookData, sessionId); break;
       case "sessionlog-dispatch": await handleSessionlogDispatch(hookData); break;
       default:
         log.warn("unknown action", { action });