claude-code-swarm 0.3.20 → 0.3.22

package/.claude-plugin/marketplace.json

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

package/CLAUDE.md

@@ -398,6 +398,15 @@ Both modes:
 - Report trajectory checkpoints via `trajectory/checkpoint` (with broadcast fallback)
 - Self-terminate after 30 minutes of inactivity (session mode)
 
+**MAP capabilities declared** (in `src/map-connection.mjs`):
+- `messaging: { canSend: true, canReceive: true }` — can exchange MAP scope messages
+- `mail: { canCreate: true, canJoin: true, canViewHistory: true }` — supports agent-inbox conversations (enables Mail chat mode in OpenHive session view)
+- `trajectory: { canReport: true, canServeContent: true }` — reports checkpoints, serves transcript content on demand
+- `tasks: { canCreate, canAssign, canUpdate, canList }` — task management
+- `opentasks: { canQuery, canLink, canAnnotate, canTask }` — conditional, when task_graph configured
+
+Message delivery is **pull-based**: the `UserPromptSubmit` hook reads the inbox on each turn and injects messages into Claude Code's prompt context. No real-time push delivery.
+
 The hook helper (`scripts/map-hook.mjs`) includes best-effort auto-recovery: if the sidecar is down, it attempts to restart it, with a fire-and-forget fallback (mesh or direct WebSocket) if recovery fails.
 
 ### OpenTasks integration

package/package.json

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

package/scripts/map-sidecar.mjs

@@ -224,6 +224,7 @@ function startSlowReconnectLoop() {
         systemId: SYSTEM_ID,
         credential: AUTH_CREDENTIAL || undefined,
         projectContext: PROJECT_CONTEXT,
+        inboxEnabled: !!INBOX_CONFIG || MESH_ENABLED,
         onMessage: () => resetInactivityTimer(),
       });
 
@@ -409,6 +410,7 @@ async function startWebSocketTransport() {
     systemId: SYSTEM_ID,
     credential: AUTH_CREDENTIAL || undefined,
     projectContext: PROJECT_CONTEXT,
+    inboxEnabled: !!INBOX_CONFIG || MESH_ENABLED,
     onMessage: () => {
       resetInactivityTimer();
     },

package/src/__tests__/opentasks-connector.test.mjs

@@ -5,9 +5,17 @@ import { registerOpenTasksHandler } from "../opentasks-connector.mjs";
 
 const MOCK_METHODS = {
   QUERY_REQUEST: "opentasks/query.request",
+  QUERY_RESPONSE: "opentasks/query.response",
   LINK_REQUEST: "opentasks/link.request",
+  LINK_RESPONSE: "opentasks/link.response",
   ANNOTATE_REQUEST: "opentasks/annotate.request",
+  ANNOTATE_RESPONSE: "opentasks/annotate.response",
   TASK_REQUEST: "opentasks/task.request",
+  TASK_RESPONSE: "opentasks/task.response",
+  GRAPH_CREATE_REQUEST: "opentasks/graph.create.request",
+  GRAPH_CREATE_RESPONSE: "opentasks/graph.create.response",
+  GRAPH_UPDATE_REQUEST: "opentasks/graph.update.request",
+  GRAPH_UPDATE_RESPONSE: "opentasks/graph.update.response",
 };
 
 function createMockConnection() {
@@ -89,16 +97,53 @@ describe("registerOpenTasksHandler", () => {
     expect(callArgs.agentId).toBe("swarm:test-sidecar");
   });
 
-  it("registers onNotification for all 4 request methods", async () => {
+  it("registers onNotification for every *.request method exported by opentasks", async () => {
     await callRegister();
 
-    expect(mockConn.onNotification).toHaveBeenCalledTimes(4);
+    const expectedRequestMethods = Object.values(MOCK_METHODS).filter((m) =>
+      m.endsWith(".request"),
+    );
+    expect(mockConn.onNotification).toHaveBeenCalledTimes(expectedRequestMethods.length);
 
     const registeredMethods = mockConn.onNotification.mock.calls.map((c) => c[0]);
     expect(registeredMethods).toContain(MOCK_METHODS.QUERY_REQUEST);
     expect(registeredMethods).toContain(MOCK_METHODS.LINK_REQUEST);
     expect(registeredMethods).toContain(MOCK_METHODS.ANNOTATE_REQUEST);
     expect(registeredMethods).toContain(MOCK_METHODS.TASK_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.GRAPH_CREATE_REQUEST);
+    expect(registeredMethods).toContain(MOCK_METHODS.GRAPH_UPDATE_REQUEST);
+  });
+
+  it("does not register response methods (only .request is subscribed)", async () => {
+    await callRegister();
+
+    const registeredMethods = mockConn.onNotification.mock.calls.map((c) => c[0]);
+    const responseMethods = registeredMethods.filter((m) => m.endsWith(".response"));
+    expect(responseMethods).toEqual([]);
+  });
+
+  it("forwards graph.create.request to the connector", async () => {
+    await callRegister();
+
+    const params = { request_id: "req-c1", create: { type: "task", title: "New" } };
+    await mockConn._fireNotification(MOCK_METHODS.GRAPH_CREATE_REQUEST, params);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.GRAPH_CREATE_REQUEST,
+      params,
+    );
+  });
+
+  it("forwards graph.update.request to the connector", async () => {
+    await callRegister();
+
+    const params = { request_id: "req-u1", update: { id: "n-1", title: "Renamed" } };
+    await mockConn._fireNotification(MOCK_METHODS.GRAPH_UPDATE_REQUEST, params);
+
+    expect(mockOpentasks._connector.handleNotification).toHaveBeenCalledWith(
+      MOCK_METHODS.GRAPH_UPDATE_REQUEST,
+      params,
+    );
   });
 
   it("forwards notifications to connector.handleNotification", async () => {

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, projectContext }) {
+export async function connectToMAP({ server, scope, systemId, onMessage, credential, projectContext, inboxEnabled }) {
   try {
     const mapSdk = await resolvePackage("@multi-agent-protocol/sdk");
     if (!mapSdk) throw new Error("@multi-agent-protocol/sdk not available");
@@ -38,6 +38,12 @@ export async function connectToMAP({ server, scope, systemId, onMessage, credent
       role: "sidecar",
       scopes: [scope],
       capabilities: {
+        // Messaging and mail capabilities are conditional on agent-inbox being available.
+        // Without inbox, the sidecar can't receive messages or participate in conversations.
+        ...(inboxEnabled ? {
+          messaging: { canSend: true, canReceive: true },
+          mail: { canCreate: true, canJoin: true, canViewHistory: true },
+        } : {}),
         trajectory: { canReport: true, canServeContent: true },
         tasks: { canCreate: true, canAssign: true, canUpdate: true, canList: true },
         ...(projectContext?.task_graph ? {

package/src/opentasks-connector.mjs

@@ -63,13 +63,13 @@ export async function registerOpenTasksHandler(conn, options = {}) {
       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,
-    ];
+    // Subscribe to every `opentasks/*.request` method the opentasks package
+    // exports. Iterating MAP_CONNECTOR_METHODS (rather than hardcoding a list)
+    // means new request methods added upstream — e.g. graph.create.request,
+    // graph.update.request — are wired up automatically.
+    const requestMethods = Object.values(MAP_CONNECTOR_METHODS).filter(
+      (m) => typeof m === "string" && m.endsWith(".request"),
+    );
 
     for (const method of requestMethods) {
       conn.onNotification(method, async (params) => {