claude-code-swarm 0.3.23 → 0.3.24

package/.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "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.23",
+  "version": "0.3.24",
   "author": {
     "name": "alexngai"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "description": "Claude Code plugin for launching agent teams from openteams topologies with MAP observability",
   "type": "module",
   "exports": {
@@ -55,7 +55,7 @@
   "devDependencies": {
     "agent-inbox": "^0.1.9",
     "minimem": "^0.1.1",
-    "opentasks": "^0.1.1",
+    "opentasks": "^0.1.2",
     "skill-tree": "^0.1.5",
     "vitest": "^4.0.18",
     "ws": "^8.0.0"

package/scripts/map-sidecar.mjs

@@ -24,6 +24,7 @@ import { SOCKET_PATH, PID_PATH, INBOX_SOCKET_PATH, sessionPaths, pluginDir } fro
 import { connectToMAP } from "../src/map-connection.mjs";
 import { createMeshPeer, createMeshInbox } from "../src/mesh-connection.mjs";
 import { createSocketServer, createCommandHandler } from "../src/sidecar-server.mjs";
+import { startOpenTasksEventBridge } from "../src/opentasks-bridge.mjs";
 import { createContentProvider } from "../src/content-provider.mjs";
 import { startMemoryWatcher } from "../src/memory-watcher.mjs";
 import { readConfig } from "../src/config.mjs";
@@ -123,6 +124,7 @@ let inboxInstance = null;
 let inactivityTimer = null;
 let reconnectInterval = null;
 let transportMode = "websocket"; // "mesh" or "websocket"
+let opentasksBridge = null; // Daemon watch → MAP event bridge (Option A)
 const registeredAgents = new Map();
 
 // ── Inactivity Timer ────────────────────────────────────────────────────────
@@ -143,6 +145,13 @@ async function shutdown() {
   if (inactivityTimer) clearTimeout(inactivityTimer);
   if (reconnectInterval) clearInterval(reconnectInterval);
 
+  // Stop opentasks event bridge before the MAP connection drops — the
+  // bridge needs a live connection to send its unsubscribe over.
+  if (opentasksBridge) {
+    try { await opentasksBridge.stop(); } catch { /* ignore */ }
+    opentasksBridge = null;
+  }
+
   // Stop agent-inbox first (it borrows the connection/peer, doesn't own it)
   if (inboxInstance) {
     try { await inboxInstance.stop(); } catch { /* ignore */ }
@@ -242,6 +251,19 @@ function startSlowReconnectLoop() {
         // Re-subscribe inbox events to the new connection
         subscribeInboxEvents(newConn);
 
+        // Re-attach opentasks event bridge to the fresh connection —
+        // the previous bridge was bound to the dead one.
+        if (opentasksBridge) {
+          try { await opentasksBridge.stop(); } catch { /* ignore */ }
+          opentasksBridge = null;
+        }
+        if (PROJECT_CONTEXT.task_graph) {
+          opentasksBridge = await startOpenTasksEventBridge(newConn, {
+            scope: MAP_SCOPE,
+            onActivity: resetInactivityTimer,
+          });
+        }
+
         log.info("reconnected to MAP server");
       }
     } catch (err) {
@@ -428,6 +450,18 @@ async function startWebSocketTransport() {
     await registerOpenTasksHandler(connection);
   }
 
+  // Start the opentasks → MAP event bridge — surfaces every graph
+  // change (context/spec nodes in particular) as a MAP event over the
+  // shared connection. Task-event emission is suppressed inside the
+  // bridge to avoid double-sending alongside the existing PostToolUse
+  // `bridge-task-*` command chain.
+  if (connection && PROJECT_CONTEXT.task_graph) {
+    opentasksBridge = await startOpenTasksEventBridge(connection, {
+      scope: MAP_SCOPE,
+      onActivity: resetInactivityTimer,
+    });
+  }
+
   // Start agent-inbox with MAP connection (legacy mode)
   if (INBOX_CONFIG && connection) {
     inboxInstance = await startLegacyAgentInbox(connection);

package/src/opentasks-bridge.mjs

@@ -0,0 +1,140 @@
+/**
+ * opentasks-bridge.mjs — Opentasks MAP event bridge for the sidecar
+ *
+ * Attaches opentasks' `createMAPEventBridge` to the local daemon's watch
+ * stream so every graph change surfaces as a `task.*` / `context.*` MAP
+ * event over the shared MAP connection. The bridge is kind-agnostic for
+ * contexts — downstream consumers (e.g. OpenHive's hub) route by
+ * `metadata.kind` to classify specs vs plain contexts.
+ *
+ * This is the "Option A" daemon-wired path — no explicit `bridge-*`
+ * sidecar command is needed for contexts. For tasks, the existing
+ * PostToolUse(TaskCreate) → `bridge-task-*` command chain remains the
+ * active path (matches the filters in sidecar-server.mjs and avoids
+ * double-emission when both hooks and the watcher fire for the same
+ * change).
+ *
+ * Extracted from map-sidecar.mjs for testability.
+ */
+
+import { createLogger } from "./log.mjs";
+
+const log = createLogger("opentasks-bridge");
+
+/**
+ * Start the opentasks MAP event bridge.
+ *
+ * Connects to the local opentasks daemon, subscribes to graph changes,
+ * and forwards every event through the MAP event bridge so connected
+ * observers (OpenHive hub, peer swarms) see them as standard MAP events.
+ *
+ * Safe to call when the daemon isn't running or when MAP connection is
+ * absent — returns `null` and logs at debug level.
+ *
+ * @param {object} conn - MAP connection (AgentConnection or MeshPeer connection)
+ * @param {object} options
+ * @param {string} options.scope - MAP scope (e.g. "swarm:gsd")
+ * @param {() => void} [options.onActivity] - Called on each bridged event
+ * @param {() => Promise<object>} [options.importOpentasks] - Override for `await import("opentasks")`
+ * @param {() => Promise<object>} [options.importOpentasksClient] - Override for `./opentasks-client.mjs` import
+ * @returns {Promise<{ stop: () => Promise<void> } | null>}
+ */
+export async function startOpenTasksEventBridge(conn, options = {}) {
+  if (!conn) return null;
+
+  const {
+    scope = "swarm:default",
+    onActivity,
+    importOpentasks,
+    importOpentasksClient,
+  } = options;
+
+  let opentasks;
+  try {
+    opentasks = importOpentasks
+      ? await importOpentasks()
+      : await import("opentasks");
+  } catch (err) {
+    log.debug("opentasks package not available", { error: err.message });
+    return null;
+  }
+
+  const { createMAPEventBridge, createIPCClient } = opentasks || {};
+  if (!createMAPEventBridge || !createIPCClient) {
+    log.debug("opentasks event-bridge exports missing");
+    return null;
+  }
+
+  let socketPath;
+  try {
+    const opentasksClient = importOpentasksClient
+      ? await importOpentasksClient()
+      : await import("./opentasks-client.mjs");
+    socketPath = opentasksClient.findSocketPath();
+  } catch (err) {
+    log.debug("could not resolve opentasks socket path", { error: err.message });
+    return null;
+  }
+
+  const client = createIPCClient(socketPath);
+  try {
+    await client.connect();
+  } catch (err) {
+    log.debug("opentasks daemon not reachable, bridge disabled", {
+      socketPath,
+      error: err.message,
+    });
+    return null;
+  }
+
+  const bridge = createMAPEventBridge({
+    connection: conn,
+    scope,
+    agentId: `${scope}-sidecar`,
+    // Suppress bridge task.* events — the sidecar's existing
+    // `bridge-task-*` command chain (driven by PostToolUse hooks) is the
+    // canonical path for tasks. Emitting here too would duplicate every
+    // task event. Contexts have no hook counterpart, so they only flow
+    // via this watcher.
+    filter: (type) => !type.startsWith("task."),
+  });
+
+  const offNotif = client.onNotification((method, params) => {
+    if (method !== "watch.event") return;
+    if (onActivity) onActivity();
+    log.debug("watch.event received", {
+      kind: params?.type,
+      nodeId: params?.nodeId,
+      nodeType: params?.node?.type,
+    });
+    try {
+      bridge.handleProviderChange("native", { kind: "node", event: params });
+    } catch (err) {
+      log.debug("bridge.handleProviderChange threw", { error: err.message });
+    }
+  });
+
+  try {
+    await client.request("watch.subscribe", {});
+  } catch (err) {
+    log.debug("watch.subscribe failed, bridge disabled", { error: err.message });
+    offNotif();
+    try { client.disconnect(); } catch { /* ignore */ }
+    return null;
+  }
+
+  log.info("opentasks event bridge active", { scope, socketPath });
+
+  return {
+    async stop() {
+      try {
+        await client.request("watch.unsubscribe", {});
+      } catch {
+        // ignore — we're shutting down anyway
+      }
+      offNotif();
+      bridge.stop();
+      try { client.disconnect(); } catch { /* ignore */ }
+    },
+  };
+}