claude-code-swarm 0.3.17 → 0.3.19

package/.claude-plugin/marketplace.json

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

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.17",
+  "version": "0.3.19",
   "author": {
     "name": "alexngai"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.17",
+  "version": "0.3.19",
   "description": "Claude Code plugin for launching agent teams from openteams topologies with MAP observability",
   "type": "module",
   "exports": {

package/scripts/map-sidecar.mjs

@@ -523,8 +523,6 @@ async function main() {
   if (sidecarConfig.minimem?.enabled) {
     const minimemDir = sidecarConfig.minimem?.dir || ".swarm/minimem";
     const memWatcher = startMemoryWatcher(minimemDir, (_event) => {
-      // Send bridge-memory-sync through the command handler
-      // This reuses the same callExtension path as the PostToolUse hook
       const fakeClient = {
         write: () => {},
         writable: true,
@@ -533,6 +531,7 @@ async function main() {
         action: "bridge-memory-sync",
         agentId: SESSION_ID || "minimem",
         timestamp: new Date().toISOString(),
+        memoryDir: minimemDir,
       }, fakeClient);
     });
 

package/src/__tests__/memory-watcher.test.mjs

@@ -1,9 +1,9 @@
 /**
- * Unit tests for memory file watcher
+ * Unit tests for memory file watcher (fs.watch implementation)
  */
 
 import { describe, it, expect, afterEach, vi } from "vitest";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { mkdtempSync, mkdirSync, writeFileSync, unlinkSync, rmSync, existsSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { startMemoryWatcher } from "../memory-watcher.mjs";
@@ -23,6 +23,8 @@ describe("startMemoryWatcher", () => {
     }
   });
 
+  // ── Null/skip cases ─────────────────────────────────────────────
+
   it("returns null for non-existent directory", () => {
     const result = startMemoryWatcher("/nonexistent/path", () => {});
     expect(result).toBeNull();
@@ -33,6 +35,8 @@ describe("startMemoryWatcher", () => {
     expect(startMemoryWatcher(undefined, () => {})).toBeNull();
   });
 
+  // ── Watcher lifecycle ───────────────────────────────────────────
+
   it("returns a watcher handle with close method", () => {
     tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
     mkdirSync(join(tmpDir, "memory"), { recursive: true });
@@ -42,6 +46,18 @@ describe("startMemoryWatcher", () => {
     expect(typeof watcher.close).toBe("function");
   });
 
+  it("close() can be called multiple times without error", () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+
+    watcher = startMemoryWatcher(tmpDir, () => {});
+    expect(watcher).not.toBeNull();
+    watcher.close();
+    watcher.close(); // should not throw
+    watcher = null;
+  });
+
+  // ── File detection ──────────────────────────────────────────────
+
   it("detects new .md file and calls onSync", async () => {
     tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
     mkdirSync(join(tmpDir, "memory"), { recursive: true });
@@ -49,46 +65,108 @@ describe("startMemoryWatcher", () => {
     const onSync = vi.fn();
     watcher = startMemoryWatcher(tmpDir, onSync);
 
-    // Wait for watcher to be ready
-    await new Promise((r) => setTimeout(r, 500));
+    // Wait for watcher to initialize
+    await new Promise((r) => setTimeout(r, 300));
 
     // Write a new .md file
     writeFileSync(join(tmpDir, "memory", "test-note.md"), "# Test Note\nContent here.");
 
     // Wait for debounce (2s) + buffer
-    await new Promise((r) => setTimeout(r, 3500));
+    await new Promise((r) => setTimeout(r, 3000));
 
     expect(onSync).toHaveBeenCalled();
     const call = onSync.mock.calls[0][0];
-    expect(call.type).toBe("add");
     expect(call.path).toContain("test-note.md");
+    // fs.watch reports 'rename' for new files, 'change' for modifications
+    expect(["rename", "change"]).toContain(call.type);
   }, 10_000);
 
+  it("detects changes to existing .md file", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, "memory"), { recursive: true });
+
+    // Create file before starting watcher
+    const filePath = join(tmpDir, "memory", "existing.md");
+    writeFileSync(filePath, "# Original");
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Modify the file
+    writeFileSync(filePath, "# Updated content");
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    expect(onSync).toHaveBeenCalled();
+    const call = onSync.mock.calls[0][0];
+    expect(call.path).toContain("existing.md");
+  }, 10_000);
+
+  // ── Ignore patterns ─────────────────────────────────────────────
+
   it("ignores non-.md files", async () => {
     tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
 
     const onSync = vi.fn();
     watcher = startMemoryWatcher(tmpDir, onSync);
 
-    await new Promise((r) => setTimeout(r, 500));
+    await new Promise((r) => setTimeout(r, 300));
 
     // Write non-.md files
-    writeFileSync(join(tmpDir, "index.db"), "binary data");
-    writeFileSync(join(tmpDir, "config.json"), "{}");
+    writeFileSync(join(tmpDir, "data.json"), "{}");
+    writeFileSync(join(tmpDir, "config.yaml"), "key: value");
+    writeFileSync(join(tmpDir, "README.txt"), "readme");
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    expect(onSync).not.toHaveBeenCalled();
+  }, 10_000);
 
-    await new Promise((r) => setTimeout(r, 3500));
+  it("ignores files in .minimem directory", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, ".minimem"), { recursive: true });
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Write to .minimem (should be ignored even if .md)
+    writeFileSync(join(tmpDir, ".minimem", "index.md"), "ignored");
+
+    await new Promise((r) => setTimeout(r, 3000));
 
     expect(onSync).not.toHaveBeenCalled();
   }, 10_000);
 
-  it("debounces rapid changes", async () => {
+  it("ignores files in .cache directory", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, ".cache"), { recursive: true });
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    writeFileSync(join(tmpDir, ".cache", "embeddings.md"), "cached");
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    expect(onSync).not.toHaveBeenCalled();
+  }, 10_000);
+
+  // ── Debounce ────────────────────────────────────────────────────
+
+  it("debounces rapid changes into a single callback", async () => {
     tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
     mkdirSync(join(tmpDir, "memory"), { recursive: true });
 
     const onSync = vi.fn();
     watcher = startMemoryWatcher(tmpDir, onSync);
 
-    await new Promise((r) => setTimeout(r, 500));
+    await new Promise((r) => setTimeout(r, 300));
 
     // Write multiple files rapidly
     writeFileSync(join(tmpDir, "memory", "note1.md"), "# Note 1");
@@ -96,9 +174,56 @@ describe("startMemoryWatcher", () => {
     writeFileSync(join(tmpDir, "memory", "note3.md"), "# Note 3");
 
     // Wait for debounce
-    await new Promise((r) => setTimeout(r, 3500));
+    await new Promise((r) => setTimeout(r, 3000));
 
     // Should only fire once (debounced)
     expect(onSync).toHaveBeenCalledTimes(1);
   }, 10_000);
+
+  // ── Minimem directory structure ─────────────────────────────────
+
+  it("watches the real minimem layout: memory/*.md + MEMORY.md", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+
+    // Recreate minimem structure
+    mkdirSync(join(tmpDir, "memory"), { recursive: true });
+    mkdirSync(join(tmpDir, ".minimem"), { recursive: true });
+
+    // Pre-existing files (like a real minimem store)
+    writeFileSync(join(tmpDir, "MEMORY.md"), "# Memory Index");
+    writeFileSync(join(tmpDir, "memory", "existing-note.md"), "# Existing");
+    writeFileSync(join(tmpDir, ".minimem", "config.json"), "{}");
+    writeFileSync(join(tmpDir, ".minimem", "index.db"), "binary");
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Agent writes a new memory file (should trigger)
+    writeFileSync(join(tmpDir, "memory", "knowledge-dns.md"), "# DNS Knowledge\nContent");
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    expect(onSync).toHaveBeenCalled();
+    expect(onSync.mock.calls[0][0].path).toContain("knowledge-dns.md");
+  }, 10_000);
+
+  it("does not fire for .minimem/index.db updates in real layout", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mem-watch-"));
+    mkdirSync(join(tmpDir, ".minimem"), { recursive: true });
+    writeFileSync(join(tmpDir, ".minimem", "index.db"), "v1");
+
+    const onSync = vi.fn();
+    watcher = startMemoryWatcher(tmpDir, onSync);
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // Simulate index rebuild
+    writeFileSync(join(tmpDir, ".minimem", "index.db"), "v2");
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    expect(onSync).not.toHaveBeenCalled();
+  }, 10_000);
 });

package/src/memory-watcher.mjs

@@ -7,16 +7,22 @@
  * watcher is the only way to detect when an agent writes to memory.
  *
  * Runs inside the MAP sidecar process (persistent for the session).
+ *
+ * Uses Node's built-in fs.watch (recursive) instead of chokidar to avoid
+ * an external dependency. Requires Node 20+ for recursive on Linux.
  */
 
-import chokidar from "chokidar";
-import { existsSync } from "fs";
+import { watch, existsSync } from "fs";
+import { resolve } from "path";
 import { createLogger } from "./log.mjs";
 
 const log = createLogger("memory-watcher");
 
 const DEBOUNCE_MS = 2000;
 
+/** Patterns to ignore (matched against the relative filename). */
+const IGNORED = [/node_modules/, /\.git/, /index\.db/, /\.cache/, /\.minimem/];
+
 /**
  * Start watching a minimem directory for file changes.
  * When changes are detected (debounced), calls the provided callback.
@@ -32,37 +38,39 @@ export function startMemoryWatcher(memoryDir, onSync) {
   }
 
   let debounceTimer = null;
+  const absDir = resolve(memoryDir);
 
-  const watcher = chokidar.watch(memoryDir, {
-    ignoreInitial: true,
-    ignored: [/node_modules/, /\.git/, /index\.db/, /\.cache/, /\.minimem/],
-    depth: 3,
-  });
+  let watcher;
+  try {
+    watcher = watch(absDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
 
-  function debouncedSync(eventType, filePath) {
-    // Only react to .md file changes
-    if (!filePath.endsWith(".md")) return;
+      // Only react to .md file changes
+      if (!filename.endsWith(".md")) return;
 
-    if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(() => {
-      debounceTimer = null;
-      log.debug("memory change detected", { event: eventType, path: filePath });
-      onSync({ type: eventType, path: filePath });
-    }, DEBOUNCE_MS);
-  }
+      // Skip ignored patterns
+      if (IGNORED.some((re) => re.test(filename))) return;
 
-  watcher.on("add", (p) => debouncedSync("add", p));
-  watcher.on("change", (p) => debouncedSync("change", p));
-  watcher.on("unlink", (p) => debouncedSync("unlink", p));
+      const fullPath = resolve(absDir, filename);
 
-  watcher.on("ready", () => {
-    log.info("memory watcher started", { dir: memoryDir });
-  });
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        log.debug("memory change detected", { event: eventType, path: fullPath });
+        onSync({ type: eventType, path: fullPath });
+      }, DEBOUNCE_MS);
+    });
+  } catch (err) {
+    log.warn("memory watcher failed to start", { error: err.message });
+    return null;
+  }
 
   watcher.on("error", (err) => {
     log.warn("memory watcher error", { error: err.message });
   });
 
+  log.info("memory watcher started", { dir: memoryDir });
+
   return {
     close() {
       if (debounceTimer) clearTimeout(debounceTimer);

package/src/sessionlog.mjs

@@ -30,6 +30,28 @@ function getGitBranch() {
   }
 }
 
+function getGitCommitHash() {
+  try {
+    return execSync("git rev-parse HEAD", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function getGitRemoteUrl() {
+  try {
+    return execSync("git remote get-url origin", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Check if sessionlog is installed and active.
  * Returns 'active', 'installed but not enabled', or 'not installed'.
@@ -176,8 +198,11 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
     turnId: state.turnID,
     startedAt: state.startedAt,
     label: `Turn ${state.turnID || "?"} (step ${state.stepCount || 0}, ${state.phase || "unknown"})`,
-    // Project context for display
+    // Project context for display + auto-import
     project: path.basename(process.cwd()),
+    projectPath: process.cwd(),
+    gitRemoteUrl: getGitRemoteUrl(),
+    gitCommitHash: getGitCommitHash(),
     firstPrompt: state.firstPrompt ? state.firstPrompt.slice(0, 200) : undefined,
     template: config.template || undefined,
   };

package/src/sidecar-server.mjs

@@ -396,13 +396,13 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           const c = conn || await waitForConn();
           if (c) {
             try {
-              // Use callExtension for JSON-RPC vendor-prefixed method
-              // Same pattern as trajectory/checkpoint
               const params = {
                 resource_id: _memoryResourceId || "",
                 agent_id: command.agentId || "minimem",
                 commit_hash: `memory-${Date.now()}`,
                 timestamp: command.timestamp || new Date().toISOString(),
+                // Include the memory directory path for resource resolution on first call
+                path: command.memoryDir || "",
               };
               const result = await c.callExtension("x-openhive/memory.sync", params);
               // Cache resource_id from server response