claude-code-swarm 0.3.10 → 0.3.12

package/src/sessionlog.mjs

@@ -10,9 +10,11 @@ import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
 import { SESSIONLOG_DIR, SESSIONLOG_STATE_PATH, sessionPaths } from "./paths.mjs";
+import { readConfig } from "./config.mjs";
 import { resolveTeamName, resolveScope } from "./config.mjs";
 import { sendToSidecar, ensureSidecar } from "./sidecar-client.mjs";
 import { fireAndForgetTrajectory } from "./map-connection.mjs";
+import { resolvePackage } from "./swarmkit-resolver.mjs";
 
 /**
  * Check if sessionlog is installed and active.
@@ -39,6 +41,60 @@ export function checkSessionlogStatus() {
   }
 }
 
+/**
+ * Check if sessionlog's standalone hooks are installed in .claude/settings.json.
+ * Reads the file directly — no dependency on resolvePackage("sessionlog").
+ * Looks for any SessionStart hook command containing "sessionlog " as a sentinel
+ * (if session-start is there, all 12 hooks were installed together).
+ */
+export function hasStandaloneHooks() {
+  try {
+    const settingsPath = path.join(process.cwd(), ".claude", "settings.json");
+    const content = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const hooks = settings.hooks?.SessionStart ?? [];
+    return hooks.some(m => m.hooks?.some(h => h.command?.includes("sessionlog ")));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Auto-enable sessionlog if it is installed but not yet enabled.
+ * Tries the programmatic API first (dynamic import), then falls back to CLI.
+ * Best-effort — returns true if enabled, false otherwise. Never throws.
+ */
+export async function ensureSessionlogEnabled() {
+  const status = checkSessionlogStatus();
+  if (status === "active") return true;
+  if (status === "not installed") return false;
+
+  // Status is "installed but not enabled" — try to enable it
+
+  // 1. Try programmatic API via dynamic import
+  //    skipAgentHooks: true — agent hooks are managed by cc-swarm's hooks.json
+  try {
+    const sessionlogMod = await resolvePackage("sessionlog");
+    if (sessionlogMod?.enable) {
+      const result = await sessionlogMod.enable({ agent: "claude-code", skipAgentHooks: true });
+      if (result.enabled) return true;
+    }
+  } catch {
+    // Fall through to CLI
+  }
+
+  // 2. Fallback to CLI
+  try {
+    execSync("sessionlog enable --agent claude-code --skip-agent-hooks", {
+      stdio: "ignore",
+      timeout: 15_000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Find the active (non-ended) sessionlog session file.
  * Returns parsed SessionState or null.
@@ -78,31 +134,54 @@ export function findActiveSession(sessionlogDir = SESSIONLOG_DIR) {
 
 /**
  * Build a MAP TrajectoryCheckpoint from sessionlog state.
- * Metadata contents are filtered by sync level.
+ *
+ * Conforms to sessionlog's SessionSyncCheckpoint wire format (snake_case,
+ * top-level fields) so OpenHive's sync listener can extract fields correctly.
+ * Extra sessionlog-specific fields go in `metadata` for passthrough.
  */
 export function buildTrajectoryCheckpoint(state, syncLevel, config) {
   const teamName = resolveTeamName(config);
-  const agentId = `${teamName}-sidecar`;
 
   const id =
     state.lastCheckpointID ||
     `${state.sessionID}-step${state.stepCount || 0}`;
 
-  const label = `Turn ${state.turnID || "?"} (step ${state.stepCount || 0}, ${state.phase || "unknown"})`;
+  // Wire format fields (top-level, snake_case) — always present
+  const checkpoint = {
+    id,
+    session_id: state.sessionID,
+    agent: `${teamName}-sidecar`,
+    files_touched: [],
+    checkpoints_count: 0,
+  };
 
+  // Metadata — sessionlog-specific fields for passthrough
   const metadata = {
     phase: state.phase,
     turnId: state.turnID,
     startedAt: state.startedAt,
+    label: `Turn ${state.turnID || "?"} (step ${state.stepCount || 0}, ${state.phase || "unknown"})`,
   };
   if (state.endedAt) metadata.endedAt = state.endedAt;
 
   if (syncLevel === "metrics" || syncLevel === "full") {
+    // Promote to top-level wire format fields
+    checkpoint.files_touched = state.filesTouched || [];
+    checkpoint.checkpoints_count = (state.turnCheckpointIDs || []).length;
+    if (state.tokenUsage) {
+      checkpoint.token_usage = {
+        input_tokens: state.tokenUsage.inputTokens ?? state.tokenUsage.input ?? 0,
+        output_tokens: state.tokenUsage.outputTokens ?? state.tokenUsage.output ?? 0,
+        cache_creation_tokens: state.tokenUsage.cacheCreationTokens ?? 0,
+        cache_read_tokens: state.tokenUsage.cacheReadTokens ?? 0,
+        api_call_count: state.tokenUsage.apiCallCount ?? 0,
+      };
+    }
+
+    // Keep in metadata for sessionlog consumers
     metadata.stepCount = state.stepCount;
-    metadata.filesTouched = state.filesTouched;
     metadata.lastCheckpointID = state.lastCheckpointID;
     metadata.turnCheckpointIDs = state.turnCheckpointIDs;
-    if (state.tokenUsage) metadata.tokenUsage = state.tokenUsage;
   }
 
   if (syncLevel === "full") {
@@ -113,13 +192,7 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
     }
   }
 
-  return {
-    id,
-    agentId,
-    sessionId: state.sessionID,
-    label,
-    metadata,
-  };
+  return { ...checkpoint, metadata };
 }
 
 /**
@@ -176,7 +249,9 @@ export async function annotateSwarmSession(config, sessionId) {
 
   let createSessionStore;
   try {
-    ({ createSessionStore } = await import("sessionlog"));
+    const sessionlogMod = await resolvePackage("sessionlog");
+    if (!sessionlogMod) return;
+    ({ createSessionStore } = sessionlogMod);
   } catch {
     // sessionlog not available as a module
     return;
@@ -200,3 +275,63 @@ export async function annotateSwarmSession(config, sessionId) {
     // Non-critical — session may not exist yet or annotate failed
   }
 }
+
+/**
+ * Dispatch a sessionlog hook event programmatically.
+ * Replaces the CLI pattern: `sessionlog hooks claude-code <hookName>`
+ * Uses resolvePackage("sessionlog") to call the lifecycle handler directly.
+ * Best-effort — never throws.
+ *
+ * @param {string} hookName - Sessionlog hook name (e.g. "session-start", "stop")
+ * @param {object} hookData - Raw hook event data from Claude Code stdin
+ */
+export async function dispatchSessionlogHook(hookName, hookData) {
+  // Decide whether plugin dispatch should handle this hook.
+  // config.sessionlog.mode: "plugin" (always dispatch), "standalone" (never dispatch), "auto" (check)
+  const config = readConfig();
+  const mode = config.sessionlog?.mode || "auto";
+  if (mode === "standalone") return;
+  if (mode === "auto" && hasStandaloneHooks()) return;
+
+  let sessionlogMod;
+  try {
+    sessionlogMod = await resolvePackage("sessionlog");
+  } catch {
+    return;
+  }
+  if (!sessionlogMod) return;
+
+  const {
+    isEnabled,
+    getAgent,
+    hasHookSupport,
+    createLifecycleHandler,
+    createSessionStore,
+    createCheckpointStore,
+  } = sessionlogMod;
+
+  // Pass cwd explicitly — sessionlog's defaults use git rev-parse which
+  // resolves against the OS working directory, not process.cwd().
+  const cwd = process.cwd();
+
+  // Bail if sessionlog is not enabled in this repo
+  try {
+    if (typeof isEnabled === "function" && !(await isEnabled(cwd))) return;
+  } catch {
+    return;
+  }
+
+  const agent = getAgent("claude-code");
+  if (!agent || (typeof hasHookSupport === "function" && !hasHookSupport(agent))) return;
+
+  const event = agent.parseHookEvent(hookName, JSON.stringify(hookData));
+  if (!event) return;
+
+  const handler = createLifecycleHandler({
+    sessionStore: createSessionStore(cwd),
+    checkpointStore: createCheckpointStore(cwd),
+    cwd,
+  });
+
+  await handler.dispatch(agent, event);
+}

package/src/sidecar-server.mjs

@@ -97,14 +97,35 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
   const { inboxInstance, meshPeer, transportMode = "websocket" } = opts;
   const useMeshRegistry = transportMode === "mesh" && inboxInstance;
 
+  // Connection-ready gate: commands that need `conn` await this promise.
+  // If connection is already available, resolves immediately.
+  // When connection arrives later (via setConnection), resolves the pending promise.
+  let _connReadyResolve;
+  let _connReady = conn
+    ? Promise.resolve(conn)
+    : new Promise((resolve) => { _connReadyResolve = resolve; });
+
+  const CONN_WAIT_TIMEOUT_MS = opts.connWaitTimeoutMs ?? 10_000;
+
+  /**
+   * Wait for the MAP connection to become available.
+   * Returns the connection or null if timed out.
+   */
+  async function waitForConn() {
+    if (conn) return conn;
+    const timeout = new Promise((resolve) => setTimeout(() => resolve(null), CONN_WAIT_TIMEOUT_MS));
+    return Promise.race([_connReady, timeout]);
+  }
+
   const handler = async (command, client) => {
     const { action } = command;
 
     try {
       switch (action) {
         case "emit": {
-          if (conn) {
-            await conn.send(
+          const c = conn || await waitForConn();
+          if (c) {
+            await c.send(
               { scope },
               command.event,
               command.meta || { relationship: "broadcast" }
@@ -115,8 +136,9 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         }
 
         case "send": {
-          if (conn) {
-            await conn.send(command.to, command.payload, command.meta);
+          const c = conn || await waitForConn();
+          if (c) {
+            await c.send(command.to, command.payload, command.meta);
           }
           respond(client, { ok: true });
           break;
@@ -160,10 +182,15 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
               log.error("spawn (mesh) failed", { error: err.message });
               respond(client, { ok: false, error: err.message });
             }
-          } else if (conn) {
-            // WebSocket mode: use MAP SDK
+          } else {
+            // WebSocket mode: use MAP SDK (wait for connection if needed)
+            const c = conn || await waitForConn();
+            if (!c) {
+              respond(client, { ok: false, error: "no connection (timed out waiting)" });
+              break;
+            }
             try {
-              const result = await conn.spawn({
+              const result = await c.spawn({
                 agentId,
                 name,
                 role,
@@ -191,8 +218,6 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
               log.error("spawn failed", { error: err.message });
               respond(client, { ok: false, error: err.message });
             }
-          } else {
-            respond(client, { ok: false, error: "no connection" });
           }
           break;
         }
@@ -229,7 +254,7 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
               }
             }
           } else if (conn) {
-            // WebSocket mode: use MAP SDK
+            // WebSocket mode: use MAP SDK (best-effort, no wait — local cleanup is priority)
             try {
               await conn.callExtension("map/agents/unregister", {
                 agentId,
@@ -263,15 +288,16 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         }
 
         case "trajectory-checkpoint": {
-          if (conn) {
+          const c = conn || await waitForConn();
+          if (c) {
             try {
-              await conn.callExtension("trajectory/checkpoint", {
+              await c.callExtension("trajectory/checkpoint", {
                 checkpoint: command.checkpoint,
               });
               respond(client, { ok: true, method: "trajectory" });
             } catch (err) {
               log.warn("trajectory/checkpoint not supported, falling back to broadcast", { error: err.message });
-              await conn.send(
+              await c.send(
                 { scope },
                 {
                   type: "trajectory.checkpoint",
@@ -288,7 +314,7 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
               respond(client, { ok: true, method: "broadcast-fallback" });
             }
           } else {
-            respond(client, { ok: false, error: "no connection" });
+            respond(client, { ok: false, error: "no connection (timed out waiting)" });
           }
           break;
         }
@@ -299,9 +325,10 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         // both mesh and websocket modes.
 
         case "bridge-task-created": {
-          if (conn) {
+          const c = conn || await waitForConn();
+          if (c) {
             try {
-              await conn.send({ scope }, {
+              await c.send({ scope }, {
                 type: "task.created",
                 task: command.task,
                 _origin: command.agentId || "opentasks",
@@ -313,9 +340,10 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         }
 
         case "bridge-task-status": {
-          if (conn) {
+          const c = conn || await waitForConn();
+          if (c) {
             try {
-              await conn.send({ scope }, {
+              await c.send({ scope }, {
                 type: "task.status",
                 taskId: command.taskId,
                 previous: command.previous || "open",
@@ -324,7 +352,7 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
               }, { relationship: "broadcast" });
               // Also emit task.completed for terminal states
               if (command.current === "completed" || command.current === "closed") {
-                await conn.send({ scope }, {
+                await c.send({ scope }, {
                   type: "task.completed",
                   taskId: command.taskId,
                   _origin: command.agentId || "opentasks",
@@ -337,9 +365,10 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         }
 
         case "bridge-task-assigned": {
-          if (conn) {
+          const c = conn || await waitForConn();
+          if (c) {
             try {
-              await conn.send({ scope }, {
+              await c.send({ scope }, {
                 type: "task.assigned",
                 taskId: command.taskId,
                 agentId: command.assignee,
@@ -352,7 +381,8 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
         }
 
         case "state": {
-          if (conn) {
+          const c = conn || await waitForConn();
+          if (c) {
             try {
               if (command.agentId) {
                 // State update for a specific child agent
@@ -379,9 +409,9 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
                 }
               } else {
                 // State update for the sidecar agent itself
-                await conn.updateState(command.state);
+                await c.updateState(command.state);
                 if (command.metadata) {
-                  await conn.updateMetadata(command.metadata);
+                  await c.updateMetadata(command.metadata);
                 }
               }
             } catch {
@@ -406,9 +436,17 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
     }
   };
 
-  // Allow updating the connection reference
+  // Allow updating the connection reference (also resolves any pending waitForConn)
   handler.setConnection = (newConn) => {
     conn = newConn;
+    if (newConn && _connReadyResolve) {
+      _connReadyResolve(newConn);
+      _connReadyResolve = null;
+    }
+    // Reset the gate for future disconnection/reconnection cycles
+    if (!newConn) {
+      _connReady = new Promise((resolve) => { _connReadyResolve = resolve; });
+    }
   };
 
   return handler;

package/src/skilltree-client.mjs

@@ -10,47 +10,23 @@
 
 import fs from "fs";
 import path from "path";
-import { createRequire } from "module";
-import { getGlobalNodeModules } from "./swarmkit-resolver.mjs";
+import { resolvePackage } from "./swarmkit-resolver.mjs";
 import { createLogger } from "./log.mjs";
 
 const log = createLogger("skilltree");
 
-const require = createRequire(import.meta.url);
-
 let _skillTree = undefined;
 
 /**
  * Load the skill-tree module. Returns null if not available.
- * Tries local require first, then falls back to global node_modules.
+ * Uses resolvePackage() for consistent global fallback resolution.
  */
-function loadSkillTree() {
+async function loadSkillTree() {
   if (_skillTree !== undefined) return _skillTree;
 
-  // 1. Local require (works if skill-tree is in node_modules or NODE_PATH)
-  try {
-    _skillTree = require("skill-tree");
-    return _skillTree;
-  } catch {
-    // Not locally available
-  }
-
-  // 2. Global node_modules fallback (where swarmkit installs it)
-  const globalNm = getGlobalNodeModules();
-  if (globalNm) {
-    const globalPath = path.join(globalNm, "skill-tree");
-    if (fs.existsSync(globalPath)) {
-      try {
-        _skillTree = require(globalPath);
-        return _skillTree;
-      } catch {
-        // require failed
-      }
-    }
-  }
-
-  _skillTree = null;
-  return null;
+  const mod = await resolvePackage("skill-tree");
+  _skillTree = mod || null;
+  return _skillTree;
 }
 
 /**
@@ -93,7 +69,7 @@ export function parseSkillTreeExtension(manifest) {
  * @returns {Promise<string>} Rendered loadout markdown, or empty string on failure
  */
 export async function compileRoleLoadout(roleName, criteria, config) {
-  const st = loadSkillTree();
+  const st = await loadSkillTree();
   if (!st?.createSkillBank) return "";
 
   try {

package/src/swarmkit-resolver.mjs

@@ -120,8 +120,56 @@ export async function resolveSwarmkit() {
   }
 }
 
+/**
+ * Resolve an optional global package by name.
+ * Tries bare import first (works if in local dependencies), then falls back
+ * to absolute path via global node_modules (where swarmkit installs packages).
+ *
+ * ESM dynamic import() doesn't respect runtime NODE_PATH changes, so bare
+ * imports fail for packages only installed globally. This helper works around
+ * that by using absolute paths as a fallback.
+ *
+ * Results are cached in-memory. Returns the module or null. Never throws.
+ *
+ * @param {string} name - Package name (e.g. "agent-inbox", "sessionlog")
+ * @returns {Promise<object|null>}
+ */
+const _packageCache = new Map();
+
+export async function resolvePackage(name) {
+  if (_packageCache.has(name)) return _packageCache.get(name);
+
+  // 1. Try bare import (works for local dependencies)
+  try {
+    const mod = await import(/* @vite-ignore */ name);
+    _packageCache.set(name, mod);
+    return mod;
+  } catch {
+    // Not locally resolvable
+  }
+
+  // 2. Try global node_modules (where swarmkit installs)
+  const globalNm = getGlobalNodeModules();
+  if (globalNm) {
+    const globalPath = path.join(globalNm, name);
+    if (fs.existsSync(globalPath)) {
+      try {
+        const mod = await import(/* @vite-ignore */ globalPath);
+        _packageCache.set(name, mod);
+        return mod;
+      } catch {
+        // Global path exists but import failed
+      }
+    }
+  }
+
+  _packageCache.set(name, null);
+  return null;
+}
+
 /** Reset cached state (for testing) */
 export function _resetCache() {
   _globalPrefix = undefined;
   _swarmkit = undefined;
+  _packageCache.clear();
 }

package/.claude-plugin/run-agent-inbox-mcp.sh

@@ -1,95 +0,0 @@
-#!/bin/bash
-# Wrapper script to run agent-inbox MCP server
-# When the sidecar's inbox socket exists, runs in proxy mode (IPC client).
-# Otherwise falls back to standalone mode with its own storage.
-# Exits silently if inbox is not enabled or not installed.
-
-# Check if inbox is enabled in config
-ENABLED=false
-if [ -f .swarm/claude-swarm/config.json ]; then
-  ENABLED=$(node -e "
-    try {
-      const c = JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json', 'utf-8'));
-      const envEnabled = (process.env.SWARM_INBOX_ENABLED || '').toLowerCase();
-      const isEnabled = ['true', '1', 'yes'].includes(envEnabled) || c.inbox?.enabled === true;
-      process.stdout.write(isEnabled ? 'true' : 'false');
-    } catch { process.stdout.write('false'); }
-  " 2>/dev/null || echo "false")
-elif [ -n "$SWARM_INBOX_ENABLED" ]; then
-  case "$(echo "$SWARM_INBOX_ENABLED" | tr '[:upper:]' '[:lower:]')" in
-    true|1|yes) ENABLED=true ;;
-  esac
-fi
-
-if [ "$ENABLED" != "true" ]; then
-  # Not enabled — exit silently so Claude Code doesn't show an error
-  sleep 0.1
-  exit 0
-fi
-
-# Read scope from config (defaults to MAP scope or "default")
-SCOPE="default"
-if [ -f .swarm/claude-swarm/config.json ]; then
-  CONFIGURED_SCOPE=$(node -e "
-    try {
-      const c = JSON.parse(require('fs').readFileSync('.swarm/claude-swarm/config.json', 'utf-8'));
-      const s = c.inbox?.scope || c.map?.scope || process.env.SWARM_INBOX_SCOPE || '';
-      if (s) process.stdout.write(s);
-    } catch {}
-  " 2>/dev/null)
-  if [ -n "$CONFIGURED_SCOPE" ]; then
-    SCOPE="$CONFIGURED_SCOPE"
-  fi
-fi
-
-if [ -n "$SWARM_INBOX_SCOPE" ]; then
-  SCOPE="$SWARM_INBOX_SCOPE"
-fi
-
-export INBOX_SCOPE="$SCOPE"
-
-# Discover sidecar inbox socket for proxy mode
-# Check well-known paths: .swarm/claude-swarm/tmp/map/inbox.sock
-INBOX_SOCK=""
-if [ -S .swarm/claude-swarm/tmp/map/inbox.sock ]; then
-  INBOX_SOCK=".swarm/claude-swarm/tmp/map/inbox.sock"
-fi
-
-# Also check per-session paths
-if [ -z "$INBOX_SOCK" ] && [ -d .swarm/claude-swarm/tmp/map/sessions ]; then
-  # Find the most recently modified inbox.sock in session dirs
-  INBOX_SOCK=$(find .swarm/claude-swarm/tmp/map/sessions -name inbox.sock -type s 2>/dev/null | head -1)
-fi
-
-# If inbox socket found, enable proxy mode
-if [ -n "$INBOX_SOCK" ]; then
-  export INBOX_SOCKET_PATH="$INBOX_SOCK"
-fi
-
-# Try to find the agent-inbox module entry point
-INBOX_MAIN=""
-
-# 1. Check global npm root (swarmkit installs here)
-GLOBAL_ROOT=$(npm root -g 2>/dev/null)
-if [ -n "$GLOBAL_ROOT" ] && [ -f "$GLOBAL_ROOT/agent-inbox/dist/index.js" ]; then
-  INBOX_MAIN="$GLOBAL_ROOT/agent-inbox/dist/index.js"
-fi
-
-# 2. Check plugin directory's node_modules (dev installs)
-if [ -z "$INBOX_MAIN" ] && [ -n "$CLAUDE_PLUGIN_ROOT" ] && [ -f "$CLAUDE_PLUGIN_ROOT/node_modules/agent-inbox/dist/index.js" ]; then
-  INBOX_MAIN="$CLAUDE_PLUGIN_ROOT/node_modules/agent-inbox/dist/index.js"
-fi
-
-# 3. Fallback: try require.resolve from CWD
-if [ -z "$INBOX_MAIN" ]; then
-  INBOX_MAIN=$(node -e "try { console.log(require.resolve('agent-inbox/dist/index.js')); } catch {}" 2>/dev/null)
-fi
-
-if [ -n "$INBOX_MAIN" ]; then
-  # Uses proxy mode when INBOX_SOCKET_PATH is set, standalone otherwise
-  exec node "$INBOX_MAIN" mcp
-fi
-
-# agent-inbox not installed — log to stderr and exit cleanly
-echo "[agent-inbox-mcp] agent-inbox not found. Install with: npm install -g agent-inbox or install via swarmkit" >&2
-exit 0