claude-code-swarm 0.3.25 → 0.4.0

package/src/config.mjs

@@ -105,6 +105,13 @@ export function readConfig(configPath = CONFIG_PATH, globalConfigPath = GLOBAL_C
         trust: project.inbox?.federation?.trust ?? global.inbox?.federation?.trust ?? undefined,
       },
     },
+    // Cascade integration. Only meaningful when `map` is enabled — the
+    // sidecar emits x-cascade/* notifications over the MAP connection.
+    // When map is disabled there is no connection to emit on, so cascade
+    // becomes an inert no-op (no hard failure — mirrors opentasks/minimem).
+    cascade: {
+      enabled: envBool("SWARM_CASCADE_ENABLED") ?? Boolean(project.cascade?.enabled ?? global.cascade?.enabled),
+    },
     minimem: {
       enabled: envBool("SWARM_MINIMEM_ENABLED") ?? Boolean(project.minimem?.enabled ?? global.minimem?.enabled),
       provider: envStr("SWARM_MINIMEM_PROVIDER") ?? project.minimem?.provider ?? global.minimem?.provider ?? "auto",

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, inboxEnabled }) {
+export async function connectToMAP({ server, scope, systemId, onMessage, credential, projectContext, inboxEnabled, cascadeEnabled }) {
   try {
     const mapSdk = await resolvePackage("@multi-agent-protocol/sdk");
     if (!mapSdk) throw new Error("@multi-agent-protocol/sdk not available");
@@ -49,6 +49,23 @@ export async function connectToMAP({ server, scope, systemId, onMessage, credent
         ...(projectContext?.task_graph ? {
           opentasks: { canQuery: true, canLink: true, canAnnotate: true, canTask: true },
         } : {}),
+        // Cascade capability (CascadeCapability, git-cascade >= 0.0.8) — gated
+        // on cascade.enabled. cc-swarm runs cascade in "observed git" mode: it
+        // watches git state and serves diffs. It now also probes in-progress
+        // *merge* conflict state on every poll tick and emits
+        // `x-cascade/stream.conflicted` / `stream.conflict_resolved` on the
+        // transitions — so `emitsConflicts: true` ships honestly. Action-layer
+        // remains observe-only (`canAct: false`); the watcher does not drive
+        // merges / rebases / pauses.
+        //   canServeDiff: true   — the diff server (src/cascade-diff-server.mjs) is wired
+        //   canAct: false        — no cascade action handler
+        //   emitsConflicts: true — the watcher observes merge-conflict transitions
+        // TODO: rebase-conflict observation (`.git/rebase-merge/`,
+        // `.git/rebase-apply/`) is a known follow-up. v1 covers `git merge`
+        // conflicts only.
+        ...(cascadeEnabled ? {
+          cascade: { canServeDiff: true, canAct: false, emitsConflicts: true },
+        } : {}),
       },
       metadata: {
         systemId,

package/src/map-events.mjs

@@ -63,12 +63,18 @@ export async function emitPayload(config, payload, meta, sessionId) {
 
 /**
  * Build a "spawn" sidecar command for a subagent.
+ *
+ * The agentId is derived from hookData.agent_id when available (stable,
+ * set by the spawning agent) or falls back to a timestamp-based ID.
+ * `inboxAgentId` is included in metadata so the hub can correlate MAP
+ * and inbox identities.
  */
 export function buildSubagentSpawnCommand(hookData, teamName) {
+  const agentId = hookData.agent_id || `${teamName}-subagent-${Date.now()}`;
   return {
     action: "spawn",
     agent: {
-      agentId: hookData.agent_id || `${teamName}-subagent-${Date.now()}`,
+      agentId,
       name: hookData.agent_type || "subagent",
       role: "subagent",
       scopes: [`swarm:${teamName}`],
@@ -76,6 +82,7 @@ export function buildSubagentSpawnCommand(hookData, teamName) {
         agentType: hookData.agent_type || "",
         sessionId: hookData.session_id || "",
         isTeamRole: false,
+        inboxAgentId: agentId,
       },
     },
   };

package/src/paths.mjs

@@ -102,6 +102,10 @@ export const LOGS_DIR = path.join(GLOBAL_CONFIG_DIR, "tmp", "logs");
 export const OPENTASKS_DIR = path.join(_tmpDir, "opentasks");
 export const OPENTASKS_SYNC_STATE_PATH = path.join(_tmpDir, "opentasks", "sync-state.json");
 
+// cascade runtime state — git-cascade tracker DB (local-mode state store)
+export const CASCADE_DIR = path.join(_tmpDir, "cascade");
+export const CASCADE_DB_PATH = path.join(_tmpDir, "cascade", "tracker.db");
+
 /**
  * Whether paths resolved to global (~/.claude-swarm/tmp/) vs project-level.
  */
@@ -149,6 +153,14 @@ export function ensureOpentasksDir() {
   fs.mkdirSync(OPENTASKS_DIR, { recursive: true });
 }
 
+/**
+ * Ensure the cascade runtime directory exists.
+ * Holds the git-cascade tracker DB (local-mode state store).
+ */
+export function ensureCascadeDir() {
+  fs.mkdirSync(CASCADE_DIR, { recursive: true });
+}
+
 /**
  * Resolve the plugin root directory.
  * Works from any file in src/ or scripts/.

package/src/sidecar-server.mjs

@@ -99,6 +99,17 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
   const { inboxInstance, meshPeer, transportMode = "websocket" } = opts;
   const useMeshRegistry = transportMode === "mesh" && inboxInstance;
 
+  // Dispatch thread nudge state — set by x-dispatch/nudge notifications,
+  // consumed by the UserPromptSubmit hook via the check-nudge command.
+  // Keyed by dispatch_id → { conversation_id, received_at }.
+  const _pendingNudges = new Map();
+
+  // Cascade attribution hint — the single most-recent { agentId, taskRef, ts }
+  // sent by the PostToolUse(Bash) hook via the cascade-attribution command.
+  // The cascade-watcher reads this (via getCascadeAttribution) to stamp
+  // agent_id / task_ref on observed-git events when the hint is fresh.
+  let _cascadeAttribution = null;
+
   // 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.
@@ -474,6 +485,52 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           break;
         }
 
+        // --- Dispatch thread nudge ---
+        // Set by x-dispatch/nudge MAP notifications, consumed by hooks.
+
+        case "nudge": {
+          // Called internally when the notification handler fires.
+          const { dispatch_id, conversation_id } = command;
+          if (dispatch_id) {
+            _pendingNudges.set(dispatch_id, {
+              conversation_id,
+              received_at: Date.now(),
+            });
+          }
+          respond(client, { ok: true });
+          break;
+        }
+
+        case "check-nudge": {
+          // Called by UserPromptSubmit hook. Returns and clears all
+          // pending nudges so the hook can inject a hint.
+          const nudges = [];
+          for (const [dispatchId, info] of _pendingNudges) {
+            nudges.push({
+              dispatch_id: dispatchId,
+              conversation_id: info.conversation_id,
+            });
+          }
+          _pendingNudges.clear();
+          respond(client, { ok: true, nudges });
+          break;
+        }
+
+        // --- Cascade attribution hint ---
+        // Sent by the PostToolUse(Bash) hook. Stores the single most-recent
+        // attribution hint; the cascade-watcher reads it to attribute
+        // observed-git events. Attribution-only — no git detection here.
+
+        case "cascade-attribution": {
+          _cascadeAttribution = {
+            agentId: command.agentId || "",
+            taskRef: command.taskRef || null,
+            ts: typeof command.ts === "number" ? command.ts : Date.now(),
+          };
+          respond(client, { ok: true });
+          break;
+        }
+
         default:
           respond(client, { ok: false, error: `Unknown action: ${action}` });
       }
@@ -483,6 +540,11 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
     }
   };
 
+  // Expose the latest cascade attribution hint so the sidecar can pass a
+  // getter to startCascadeWatcher as `getAttribution`. Returns the single
+  // most-recent { agentId, taskRef, ts } hint, or null when none received.
+  handler.getCascadeAttribution = () => _cascadeAttribution;
+
   // Allow updating the connection reference (also resolves any pending waitForConn)
   handler.setConnection = (newConn) => {
     conn = newConn;

package/src/skilltree-client.mjs

@@ -155,7 +155,7 @@ export function inferProfileFromRole(roleName) {
 // The bridge between openteams `loadout.skills` (SkillsConfig in the
 // schema) and skill-tree's LoadoutCriteria. skill-tree is the
 // *mechanism*; openteams is the *declaration layer* that dispatches
-// into it. See openhive's docs/LOADOUT_INTEGRATION.md for the model.
+// into it.
 //
 // Bridged fields are locked in by src/__tests__/loadout-schema-bridge.test.mjs
 // which cross-references this list against openteams' SkillsConfig schema.