claude-code-swarm 0.3.26 → 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/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

@@ -104,6 +104,12 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
   // 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.
@@ -510,6 +516,21 @@ export function createCommandHandler(connection, scope, registeredAgents, opts =
           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}` });
       }
@@ -519,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;