claude-code-swarm 0.3.12 → 0.3.17

package/src/bootstrap.mjs

@@ -431,12 +431,37 @@ export async function bootstrap(pluginDirOverride, sessionId) {
 
   let minimemStatus = "disabled";
   if (config.minimem?.enabled) {
-    minimemStatus = "enabled";
+    // Check if minimem CLI is available and memory directory exists
+    try {
+      const { execFileSync } = await import("node:child_process");
+      const { existsSync } = await import("node:fs");
+      execFileSync("which", ["minimem"], { stdio: "pipe" });
+      const dir = config.minimem?.dir || ".swarm/minimem";
+      if (existsSync(dir)) {
+        minimemStatus = "ready";
+      } else {
+        // Create the directory and initialize so MCP server can start
+        const { mkdirSync } = await import("node:fs");
+        mkdirSync(dir + "/memory", { recursive: true });
+        try {
+          execFileSync("minimem", ["init", dir], { stdio: "pipe", timeout: 10_000 });
+        } catch { /* init may fail if already initialized */ }
+        minimemStatus = "ready";
+      }
+    } catch {
+      minimemStatus = "enabled"; // CLI not found — MCP server won't start
+    }
   }
 
   let skilltreeStatus = "disabled";
   if (config.skilltree?.enabled) {
-    skilltreeStatus = "enabled";
+    try {
+      const { execFileSync } = await import("node:child_process");
+      execFileSync("which", ["skill-tree"], { stdio: "pipe" });
+      skilltreeStatus = "ready";
+    } catch {
+      skilltreeStatus = "enabled";
+    }
   }
 
   return {

package/src/content-provider.mjs

@@ -0,0 +1,176 @@
+/**
+ * content-provider.mjs — Trajectory content provider for claude-code-swarm
+ *
+ * Provides session transcript content for on-demand trajectory/content requests
+ * from the hub. Reads from sessionlog's session state to find the transcript,
+ * then serves the raw Claude Code JSONL.
+ *
+ * Two content sources:
+ * 1. Live session: reads directly from state.transcriptPath (active JSONL file)
+ * 2. Committed checkpoint: reads from sessionlog's checkpoint store (full.jsonl)
+ *
+ * Returns { metadata, transcript, prompts, context } matching the
+ * SessionContentProvider type from @multi-agent-protocol/sdk.
+ */
+
+import fs from "fs";
+import path from "path";
+import { SESSIONLOG_DIR } from "./paths.mjs";
+import { resolvePackage } from "./swarmkit-resolver.mjs";
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("content-provider");
+
+/**
+ * Create a content provider function for the sidecar.
+ * The provider receives a checkpointId and returns transcript content.
+ *
+ * For live sessions, checkpointId may be the session ID or a checkpoint ID.
+ * We search sessionlog state to find the transcript path.
+ *
+ * @returns {Function} SessionContentProvider-compatible async function
+ */
+export function createContentProvider() {
+  return async function provideContent(checkpointId) {
+    try {
+      // 1. Try to find a live session with this checkpoint or session ID
+      const liveContent = await readLiveSessionContent(checkpointId);
+      if (liveContent) return liveContent;
+
+      // 2. Try to read from committed checkpoint store
+      const committedContent = await readCommittedContent(checkpointId);
+      if (committedContent) return committedContent;
+
+      log.warn("content not found for checkpoint", { checkpointId });
+      return null;
+    } catch (err) {
+      log.warn("content provider error", { checkpointId, error: err.message });
+      return null;
+    }
+  };
+}
+
+/**
+ * Read transcript content from a live (non-ended) sessionlog session.
+ * Searches all session state files for one that matches the checkpoint ID
+ * or has a matching session ID, then reads the transcript from disk.
+ */
+async function readLiveSessionContent(checkpointId) {
+  if (!fs.existsSync(SESSIONLOG_DIR)) return null;
+
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONLOG_DIR).filter(f => f.endsWith(".json"));
+  } catch {
+    return null;
+  }
+
+  for (const f of files) {
+    try {
+      const statePath = path.join(SESSIONLOG_DIR, f);
+      const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+
+      // Match by session ID, checkpoint ID, or checkpoint in turnCheckpointIDs
+      const isMatch =
+        state.sessionID === checkpointId ||
+        state.lastCheckpointID === checkpointId ||
+        (state.turnCheckpointIDs || []).includes(checkpointId);
+
+      if (!isMatch) continue;
+
+      // Read the transcript from the path stored in session state
+      const transcriptPath = state.transcriptPath;
+      if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+        log.warn("transcript path not found", { sessionID: state.sessionID, transcriptPath });
+        continue;
+      }
+
+      const transcript = fs.readFileSync(transcriptPath, "utf-8");
+
+      // Extract prompts from transcript (user messages)
+      const prompts = extractPrompts(transcript);
+
+      return {
+        metadata: {
+          sessionID: state.sessionID,
+          phase: state.phase,
+          stepCount: state.stepCount || 0,
+          filesTouched: state.filesTouched || [],
+          tokenUsage: state.tokenUsage || {},
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+          source: "live",
+        },
+        transcript,
+        prompts,
+        context: `Session ${state.sessionID} (${state.phase})`,
+      };
+    } catch {
+      // Skip malformed files
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read transcript content from sessionlog's committed checkpoint store.
+ * Uses sessionlog's library API via resolvePackage.
+ */
+async function readCommittedContent(checkpointId) {
+  try {
+    const sessionlogMod = await resolvePackage("sessionlog");
+    if (!sessionlogMod?.createCheckpointStore) return null;
+
+    const store = sessionlogMod.createCheckpointStore();
+    if (!store?.readSessionContent) return null;
+
+    // Try reading committed content (session index 0)
+    const content = await store.readSessionContent(checkpointId, 0);
+    if (!content) return null;
+
+    return {
+      metadata: {
+        ...content.metadata,
+        source: "committed",
+      },
+      transcript: content.transcript,
+      prompts: content.prompts,
+      context: content.context,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract user prompts from a Claude Code JSONL transcript.
+ */
+function extractPrompts(transcript) {
+  const prompts = [];
+  for (const line of transcript.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "user") {
+        const msg = entry.message;
+        if (typeof msg === "string") {
+          prompts.push(msg);
+        } else if (msg?.content) {
+          if (typeof msg.content === "string") {
+            prompts.push(msg.content);
+          } else if (Array.isArray(msg.content)) {
+            const text = msg.content
+              .filter(b => b.type === "text" && b.text)
+              .map(b => b.text)
+              .join("\n");
+            if (text) prompts.push(text);
+          }
+        }
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+  return prompts.join("\n---\n");
+}

package/src/map-connection.mjs

@@ -24,7 +24,7 @@ const log = createLogger("map");
  *   authRequired challenge with the server's preferred method + this credential.
  *   When absent, uses the standard SDK connect() for open mode servers.
  */
-export async function connectToMAP({ server, scope, systemId, onMessage, credential }) {
+export async function connectToMAP({ server, scope, systemId, onMessage, credential, projectContext }) {
   try {
     const mapSdk = await resolvePackage("@multi-agent-protocol/sdk");
     if (!mapSdk) throw new Error("@multi-agent-protocol/sdk not available");
@@ -38,12 +38,16 @@ export async function connectToMAP({ server, scope, systemId, onMessage, credent
       role: "sidecar",
       scopes: [scope],
       capabilities: {
-        trajectory: { canReport: true },
+        trajectory: { canReport: true, canServeContent: true },
         tasks: { canCreate: true, canAssign: true, canUpdate: true, canList: true },
+        ...(projectContext?.task_graph ? {
+          opentasks: { canQuery: true, canLink: true, canAnnotate: true, canTask: true },
+        } : {}),
       },
       metadata: {
         systemId,
         type: "claude-code-swarm-sidecar",
+        ...(projectContext || {}),
       },
       reconnection: {
         enabled: true,

package/src/map-events.mjs

@@ -443,3 +443,33 @@ export async function handleNativeTaskUpdatedEvent(config, hookData, sessionId)
     }, sessionId);
   }
 }
+
+// ── minimem/skill-tree sync → MAP ──────────────────────────────────────────────
+//
+// When agents use minimem MCP tools that write data (append, upsert),
+// emit x-openhive/memory.sync so OpenHive can update its content cache.
+// This is a best-effort notification — the source of truth is the filesystem.
+
+/** Tools that indicate a memory write (vs read-only search) */
+const MINIMEM_WRITE_TOOLS = new Set([
+  "minimem__memory_append",
+  "minimem__memory_upsert",
+]);
+
+/**
+ * Build bridge command for minimem MCP tool use.
+ * Only emits for write operations (append/upsert), not reads.
+ */
+export function buildMinimemBridgeCommand(hookData) {
+  const toolName = hookData.tool_name || "";
+  // Only emit for write operations
+  if (!MINIMEM_WRITE_TOOLS.has(toolName) && !toolName.includes("append") && !toolName.includes("upsert")) {
+    return null;
+  }
+
+  return {
+    action: "bridge-memory-sync",
+    agentId: hookData.session_id || "minimem",
+    timestamp: new Date().toISOString(),
+  };
+}

package/src/memory-watcher.mjs

@@ -0,0 +1,73 @@
+/**
+ * memory-watcher.mjs — Watches the minimem memory directory for file changes
+ * and sends bridge-memory-sync commands to notify OpenHive via MAP.
+ *
+ * This bridges the gap between filesystem writes (Write tool, manual edits)
+ * and MAP sync notifications. minimem's MCP tools are read-only, so this
+ * watcher is the only way to detect when an agent writes to memory.
+ *
+ * Runs inside the MAP sidecar process (persistent for the session).
+ */
+
+import chokidar from "chokidar";
+import { existsSync } from "fs";
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("memory-watcher");
+
+const DEBOUNCE_MS = 2000;
+
+/**
+ * Start watching a minimem directory for file changes.
+ * When changes are detected (debounced), calls the provided callback.
+ *
+ * @param {string} memoryDir - Path to the minimem directory (e.g., ".swarm/minimem")
+ * @param {(event: { type: string; path: string }) => void} onSync - Called when sync should be emitted
+ * @returns {{ close: () => void } | null} Watcher handle, or null if directory doesn't exist
+ */
+export function startMemoryWatcher(memoryDir, onSync) {
+  if (!memoryDir || !existsSync(memoryDir)) {
+    log.debug("memory watcher skipped — directory not found", { dir: memoryDir });
+    return null;
+  }
+
+  let debounceTimer = null;
+
+  const watcher = chokidar.watch(memoryDir, {
+    ignoreInitial: true,
+    ignored: [/node_modules/, /\.git/, /index\.db/, /\.cache/, /\.minimem/],
+    depth: 3,
+  });
+
+  function debouncedSync(eventType, filePath) {
+    // Only react to .md file changes
+    if (!filePath.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);
+  }
+
+  watcher.on("add", (p) => debouncedSync("add", p));
+  watcher.on("change", (p) => debouncedSync("change", p));
+  watcher.on("unlink", (p) => debouncedSync("unlink", p));
+
+  watcher.on("ready", () => {
+    log.info("memory watcher started", { dir: memoryDir });
+  });
+
+  watcher.on("error", (err) => {
+    log.warn("memory watcher error", { error: err.message });
+  });
+
+  return {
+    close() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      watcher.close();
+      log.debug("memory watcher stopped");
+    },
+  };
+}

package/src/opentasks-connector.mjs

@@ -0,0 +1,86 @@
+/**
+ * opentasks-connector.mjs — MAP connector registration for opentasks
+ *
+ * Extracted from map-sidecar.mjs for testability.
+ * Registers notification handlers on a MAP connection so that when the hub
+ * (or another agent) sends opentasks/*.request notifications, the connector
+ * queries the local daemon and sends back opentasks/*.response.
+ */
+
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("opentasks-connector");
+
+/**
+ * Register opentasks notification handlers on a MAP connection.
+ *
+ * @param {object} conn - MAP connection with onNotification/sendNotification
+ * @param {object} options
+ * @param {string} options.scope - MAP scope (e.g. "swarm:gsd")
+ * @param {() => void} [options.onActivity] - Called on each notification (for inactivity timer reset)
+ * @param {() => Promise<object>} [options.importOpentasks] - Override for dynamic import("opentasks")
+ * @param {() => Promise<object>} [options.importOpentasksClient] - Override for dynamic import of opentasks-client
+ */
+export async function registerOpenTasksHandler(conn, options = {}) {
+  if (!conn || typeof conn.onNotification !== "function") return;
+
+  const {
+    scope = "swarm:default",
+    onActivity,
+    importOpentasks,
+    importOpentasksClient,
+  } = options;
+
+  try {
+    const opentasks = importOpentasks
+      ? await importOpentasks()
+      : await import("opentasks");
+
+    if (!opentasks?.createMAPConnector || !opentasks?.createClient) {
+      log.debug("opentasks MAP connector not available (missing exports)");
+      return;
+    }
+
+    const { createMAPConnector, createClient, MAP_CONNECTOR_METHODS } = opentasks;
+
+    const opentasksClient = importOpentasksClient
+      ? await importOpentasksClient()
+      : await import("./opentasks-client.mjs");
+
+    const { findSocketPath } = opentasksClient;
+    const socketPath = findSocketPath();
+    const client = createClient({ socketPath, autoConnect: true });
+
+    const connector = createMAPConnector({
+      client,
+      send: (method, params) => {
+        try {
+          conn.sendNotification(method, params);
+        } catch {
+          log.debug("failed to send opentasks response", { method });
+        }
+      },
+      agentId: `${scope}-sidecar`,
+    });
+
+    // Register handlers for all 4 request methods
+    const requestMethods = [
+      MAP_CONNECTOR_METHODS.QUERY_REQUEST,
+      MAP_CONNECTOR_METHODS.LINK_REQUEST,
+      MAP_CONNECTOR_METHODS.ANNOTATE_REQUEST,
+      MAP_CONNECTOR_METHODS.TASK_REQUEST,
+    ];
+
+    for (const method of requestMethods) {
+      conn.onNotification(method, async (params) => {
+        log.debug("opentasks request received", { method, requestId: params?.request_id });
+        if (onActivity) onActivity();
+        connector.handleNotification(method, params || {});
+      });
+    }
+
+    log.info("opentasks connector registered", { methods: requestMethods.length });
+  } catch (err) {
+    log.debug("opentasks connector not available", { error: err.message });
+  }
+}

package/src/sessionlog.mjs

@@ -16,6 +16,20 @@ import { sendToSidecar, ensureSidecar } from "./sidecar-client.mjs";
 import { fireAndForgetTrajectory } from "./map-connection.mjs";
 import { resolvePackage } from "./swarmkit-resolver.mjs";
 
+/**
+ * Get the current git branch name. Returns null if not in a git repo.
+ */
+function getGitBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      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'.
@@ -151,6 +165,7 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
     id,
     session_id: state.sessionID,
     agent: `${teamName}-sidecar`,
+    branch: getGitBranch(),
     files_touched: [],
     checkpoints_count: 0,
   };
@@ -161,6 +176,10 @@ 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: path.basename(process.cwd()),
+    firstPrompt: state.firstPrompt ? state.firstPrompt.slice(0, 200) : undefined,
+    template: config.template || undefined,
   };
   if (state.endedAt) metadata.endedAt = state.endedAt;
 

package/src/sidecar-server.mjs

@@ -94,6 +94,8 @@ export function createSocketServer(socketPath, onCommand) {
 export function createCommandHandler(connection, scope, registeredAgents, opts = {}) {
   // Use a getter pattern so the connection ref can be updated
   let conn = connection;
+  let _trajectoryResourceId = null; // Cached resource_id from server response
+  let _memoryResourceId = null; // Cached resource_id for memory sync
   const { inboxInstance, meshPeer, transportMode = "websocket" } = opts;
   const useMeshRegistry = transportMode === "mesh" && inboxInstance;
 
@@ -291,10 +293,17 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           const c = conn || await waitForConn();
           if (c) {
             try {
-              await c.callExtension("trajectory/checkpoint", {
-                checkpoint: command.checkpoint,
-              });
-              respond(client, { ok: true, method: "trajectory" });
+              // Include cached resource_id if available from a previous response
+              const payload = { checkpoint: command.checkpoint };
+              if (_trajectoryResourceId) {
+                payload.resource_id = _trajectoryResourceId;
+              }
+              const result = await c.callExtension("trajectory/checkpoint", payload);
+              // Cache resource_id from server response for subsequent calls
+              if (result?.resource_id) {
+                _trajectoryResourceId = result.resource_id;
+              }
+              respond(client, { ok: true, method: "trajectory", resource_id: result?.resource_id });
             } catch (err) {
               log.warn("trajectory/checkpoint not supported, falling back to broadcast", { error: err.message });
               await c.send(
@@ -303,9 +312,10 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
                   type: "trajectory.checkpoint",
                   checkpoint: {
                     id: command.checkpoint.id,
-                    agentId: command.checkpoint.agentId,
-                    sessionId: command.checkpoint.sessionId,
-                    label: command.checkpoint.label,
+                    agent: command.checkpoint.agent,
+                    session_id: command.checkpoint.session_id,
+                    files_touched: command.checkpoint.files_touched,
+                    token_usage: command.checkpoint.token_usage,
                     metadata: command.checkpoint.metadata,
                   },
                 },
@@ -380,6 +390,43 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           break;
         }
 
+        // --- Memory/skill sync → MAP (x-openhive vendor extensions) ---
+
+        case "bridge-memory-sync": {
+          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(),
+              };
+              const result = await c.callExtension("x-openhive/memory.sync", params);
+              // Cache resource_id from server response
+              if (result?.resource_id) {
+                _memoryResourceId = result.resource_id;
+              }
+              respond(client, { ok: true, method: "memory-sync", resource_id: result?.resource_id });
+            } catch (err) {
+              log.warn("x-openhive/memory.sync not supported, falling back to broadcast", { error: err.message });
+              // Fallback: emit as a regular message
+              await c.send({ scope }, {
+                type: "memory.sync",
+                agent_id: command.agentId || "minimem",
+                timestamp: command.timestamp,
+                _origin: command.agentId || "minimem",
+              }, { relationship: "broadcast" });
+              respond(client, { ok: true, method: "broadcast-fallback" });
+            }
+          } else {
+            respond(client, { ok: false, error: "no connection" });
+          }
+          break;
+        }
+
         case "state": {
           const c = conn || await waitForConn();
           if (c) {