claude-flow 3.7.0-alpha.68 → 3.7.0-alpha.69

package/.claude/agents/github/code-review-swarm.md

@@ -2,7 +2,7 @@
 name: code-review-swarm
 description: |
   Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis
-tools: mcp__claude-flow__swarm_init, mcp__claude-flow__agent_spawn, mcp__claude-flow__task_orchestrate, Bash, Read, Write, TodoWrite
+tools: mcp__claude-flow__swarm_init, mcp__claude-flow__agent_spawn, mcp__claude-flow__task_orchestrate, mcp__claude-flow__memory_search, mcp__claude-flow__memory_store, mcp__claude-flow__memory_retrieve, mcp__claude-flow__hooks_pre-task, mcp__claude-flow__hooks_post-task, mcp__claude-flow__hooks_route, Bash, Read, Write, TodoWrite
 ---
 
 # Code Review Swarm - Automated Code Review with AI Agents

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.68",
+  "version": "3.7.0-alpha.69",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/init/claudemd-generator.js

@@ -19,49 +19,74 @@ function behavioralRules() {
 - Validate input at system boundaries`;
 }
 function agentComms() {
-    return `## Agent Comms (SendMessage-First Coordination)
+    return `## Agent Comms — Reality-Based Coordination
 
-Named agents coordinate via \`SendMessage\`, not polling or shared state.
+**Tool-availability asymmetry:** \`SendMessage\` works **lead↔subagent** and lead↔lead, but **NOT subagent↔subagent**. Subagents spawned via the \`Agent\` tool are stateless one-shot workers — they have no inbox, cannot wait for events, and \`SendMessage\`/\`TaskUpdate\` are typically not in their tool allowlists. The \`hive-mind_*\` MCP tools provide coordination **metadata** (registry, consensus state) but do NOT grant subagents communication channels. Patterns that assume peer messaging will silently fail — agents either abort cleanly or run open-loop with stale assumptions. (See ruvnet/ruflo#2028 for the diagnosis.)
+
+### Canonical pattern: memory-as-bus, lead-orchestrated phases
 
 \`\`\`
-Lead (you) ←→ architect ←→ developer ←→ tester ←→ reviewer
-              (named agents message each other directly)
+Lead (the orchestrator)
+  │
+  ├─ spawns agent → agent reads inputs from memory keys → writes outputs to memory keys → completes
+  │
+  ├─ verifies outputs in memory
+  │
+  └─ spawns next agent with explicit input-key list in its brief
 \`\`\`
 
-### Spawning a Coordinated Team
+All inter-agent state lives in a shared memory namespace (\`memory_store\` / \`memory_search\`). Lead-to-subagent \`SendMessage\` is fine when needed; subagent-to-subagent \`SendMessage\` is not.
+
+### Spawning rules
+
+- **Parallelize ONLY when work is genuinely independent** (no upstream dependency between siblings).
+- **Spawn dependent agents only after the lead confirms upstream outputs are in memory.** Do NOT tell a downstream agent to "WAIT for SendMessage from X" — it has no mechanism to wait; it will abort.
+- **Every subagent brief MUST include a degraded-mode paragraph** at the top: *"If your expected coordination tools (SendMessage, TaskUpdate, hive-mind_*) are missing, do NOT abort. Read these specific source files directly, write outputs to these specific memory keys, and complete your phase."*
+- **Name agents** — \`name: "role"\` makes them addressable by the lead even though they cannot address each other.
+- **After spawning**: STOP, tell user what's running, wait for completion notifications. No polling.
+
+### Spawning example (memory-as-bus)
 
 \`\`\`javascript
-// ALL agents in ONE message, each knows WHO to message next
-Agent({ prompt: "Research the codebase. SendMessage findings to 'architect'.",
-  subagent_type: "researcher", name: "researcher", run_in_background: true })
-Agent({ prompt: "Wait for 'researcher'. Design solution. SendMessage to 'coder'.",
-  subagent_type: "system-architect", name: "architect", run_in_background: true })
-Agent({ prompt: "Wait for 'architect'. Implement it. SendMessage to 'tester'.",
-  subagent_type: "coder", name: "coder", run_in_background: true })
-Agent({ prompt: "Wait for 'coder'. Write tests. SendMessage results to 'reviewer'.",
-  subagent_type: "tester", name: "tester", run_in_background: true })
-Agent({ prompt: "Wait for 'tester'. Review code quality and security.",
-  subagent_type: "reviewer", name: "reviewer", run_in_background: true })
-
-// Kick off the pipeline
-SendMessage({ to: "researcher", summary: "Start", message: "[task context]" })
+// Phase 1 — independent parallel work
+Agent({
+  prompt: "Read docs at <paths>. Write inventory JSON to memory key phase1/researcher/inventory in namespace <ns>. Degraded mode: if memory tools missing, return inventory in your final message.",
+  subagent_type: "researcher", name: "researcher", run_in_background: true
+})
+Agent({
+  prompt: "Walk the source tree. Write capability matrix to memory key phase1/coder/capability-matrix. Degraded mode: ...",
+  subagent_type: "coder", name: "source-reader", run_in_background: true
+})
+
+// AFTER both Phase 1 agents complete (lead verifies via memory_search), THEN spawn Phase 2.
+// Each Phase 2 agent's brief explicitly lists the Phase 1 memory keys it should read.
 \`\`\`
 
 ### Patterns
 
 | Pattern | Flow | Use When |
 |---------|------|----------|
-| **Pipeline** | A → B → C → D | Sequential dependencies (feature dev) |
-| **Fan-out** | Lead → A, B, C → Lead | Independent parallel work (research) |
-| **Supervisor** | Lead ↔ workers | Ongoing coordination (complex refactor) |
+| **Sequential pipeline** | Lead → A → (verify in memory) → B → (verify) → C | Phase dependencies (audit, complex refactor) |
+| **Fan-out** | Lead → A, B, C (parallel) → Lead aggregates from memory | Independent parallel work (research, multi-lens critique) |
+| **Lead-as-bus** | Subagents → Lead → reroute by spawning next | Workaround when supervisor↔workers coordination needed |
+
+### Anti-patterns (will silently fail)
 
-### Rules
+- "WAIT for SendMessage from X" in a subagent prompt — no mechanism to wait
+- "SendMessage findings to architect" in a subagent prompt — architect can't receive
+- Spawning N dependent agents in one batch expecting them to chain via messages — they won't
+- Relying on \`hive-mind_consensus\` to gather subagent votes — subagents aren't registered hive workers
 
-- ALWAYS name agents — \`name: "role"\` makes them addressable
-- ALWAYS include comms instructions in prompts — who to message, what to send
-- Spawn ALL agents in ONE message with \`run_in_background: true\`
-- After spawning: STOP, tell user what's running, wait for results
-- NEVER poll status — agents message back or complete automatically`;
+### Lead-only SendMessage (still works)
+
+\`SendMessage\` is still useful for **lead → subagent** redirects and priority changes:
+
+\`\`\`javascript
+// Lead → subagent: redirect or update priority mid-flight
+SendMessage({ to: "developer", summary: "Prioritize auth", message: "Auth is blocking tester, do that first." })
+// Lead → subagent: graceful shutdown
+SendMessage({ to: "developer", message: { type: "shutdown_request" } })
+\`\`\``;
 }
 function swarmConfig(options) {
     return `## Swarm & Routing

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.68",
+  "version": "3.7.0-alpha.69",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

package/.claude/scheduled_tasks.lock

@@ -1 +0,0 @@
-{"sessionId":"1fc1a1cc-9310-4991-8a7d-832dbca9ebad","pid":8051,"procStart":"Sun May 17 12:50:14 2026","acquiredAt":1779051467717}