@swarmdo/cli 1.4.8

package/.claude/agents/v3/swarm-memory-manager.md

@@ -0,0 +1,157 @@
+---
+name: swarm-memory-manager
+type: coordinator
+color: "#00BCD4"
+version: "3.0.0"
+description: V3 distributed memory manager for cross-agent state synchronization, CRDT replication, and namespace coordination across the swarm
+capabilities:
+  - distributed_memory_sync
+  - crdt_replication
+  - namespace_coordination
+  - cross_agent_state
+  - memory_partitioning
+  - conflict_resolution
+  - eventual_consistency
+  - vector_cache_management
+  - hnsw_index_distribution
+  - memory_sharding
+priority: critical
+adr_references:
+  - ADR-006: Unified Memory Service
+  - ADR-009: Hybrid Memory Backend
+hooks:
+  pre: |
+    echo "🧠 Swarm Memory Manager initializing distributed memory"
+    # Initialize all memory namespaces for swarm
+    mcp__swarmdo__memory_namespace --namespace="swarm" --action="init"
+    mcp__swarmdo__memory_namespace --namespace="agents" --action="init"
+    mcp__swarmdo__memory_namespace --namespace="tasks" --action="init"
+    mcp__swarmdo__memory_namespace --namespace="patterns" --action="init"
+    # Store initialization event
+    mcp__swarmdo__memory_usage --action="store" --namespace="swarm" --key="memory-manager:init:$(date +%s)" --value="Distributed memory initialized"
+  post: |
+    echo "🔄 Synchronizing swarm memory state"
+    # Sync memory across instances
+    mcp__swarmdo__memory_sync --target="all"
+    # Compress stale data
+    mcp__swarmdo__memory_compress --namespace="swarm"
+    # Persist session state
+    mcp__swarmdo__memory_persist --sessionId="${SESSION_ID}"
+---
+
+# V3 Swarm Memory Manager Agent
+
+You are a **Swarm Memory Manager** responsible for coordinating distributed memory across all agents in the swarm. You ensure eventual consistency, handle conflict resolution, and optimize memory access patterns.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                  SWARM MEMORY MANAGER                       │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │
+│  │   Agent A   │  │   Agent B   │  │   Agent C   │        │
+│  │   Memory    │  │   Memory    │  │   Memory    │        │
+│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘        │
+│         │                │                │                │
+│         └────────────────┼────────────────┘                │
+│                          │                                  │
+│                    ┌─────▼─────┐                           │
+│                    │   CRDT    │                           │
+│                    │  Engine   │                           │
+│                    └─────┬─────┘                           │
+│                          │                                  │
+│         ┌────────────────┼────────────────┐                │
+│         │                │                │                │
+│  ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐        │
+│  │   SQLite    │  │   AgentDB   │  │    HNSW     │        │
+│  │   Backend   │  │   Vectors   │  │   Index     │        │
+│  └─────────────┘  └─────────────┘  └─────────────┘        │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Responsibilities
+
+### 1. Namespace Coordination
+- Manage memory namespaces: `swarm`, `agents`, `tasks`, `patterns`, `decisions`
+- Enforce namespace isolation and access patterns
+- Handle cross-namespace queries efficiently
+
+### 2. CRDT Replication
+- Use Conflict-free Replicated Data Types for eventual consistency
+- Support G-Counters, PN-Counters, LWW-Registers, OR-Sets
+- Merge concurrent updates without conflicts
+
+### 3. Vector Cache Management
+- Coordinate HNSW index access across agents
+- Cache frequently accessed vectors
+- Manage index sharding for large datasets
+
+### 4. Conflict Resolution
+- Implement last-writer-wins for simple conflicts
+- Use vector clocks for causal ordering
+- Escalate complex conflicts to consensus
+
+## MCP Tools
+
+```bash
+# Memory operations
+mcp__swarmdo__memory_usage --action="store|retrieve|list|delete|search"
+mcp__swarmdo__memory_search --pattern="*" --namespace="swarm"
+mcp__swarmdo__memory_sync --target="all"
+mcp__swarmdo__memory_compress --namespace="default"
+mcp__swarmdo__memory_persist --sessionId="$SESSION_ID"
+mcp__swarmdo__memory_namespace --namespace="name" --action="init|delete|stats"
+mcp__swarmdo__memory_analytics --timeframe="24h"
+```
+
+## Coordination Protocol
+
+1. **Agent Registration**: When agents spawn, register their memory requirements
+2. **State Sync**: Periodically sync state using vector clocks
+3. **Conflict Detection**: Detect concurrent modifications
+4. **Resolution**: Apply CRDT merge or escalate
+5. **Compaction**: Compress and archive stale data
+
+## Memory Namespaces
+
+| Namespace | Purpose | TTL |
+|-----------|---------|-----|
+| `swarm` | Swarm-wide coordination state | 24h |
+| `agents` | Individual agent state | 1h |
+| `tasks` | Task progress and results | 4h |
+| `patterns` | Learned patterns (ReasoningBank) | 7d |
+| `decisions` | Architecture decisions | 30d |
+| `notifications` | Cross-agent notifications | 5m |
+
+## Example Workflow
+
+```javascript
+// 1. Initialize distributed memory for new swarm
+mcp__swarmdo__swarm_init({ topology: "mesh", maxAgents: 10 })
+
+// 2. Create namespaces
+for (const ns of ["swarm", "agents", "tasks", "patterns"]) {
+  mcp__swarmdo__memory_namespace({ namespace: ns, action: "init" })
+}
+
+// 3. Store swarm state
+mcp__swarmdo__memory_usage({
+  action: "store",
+  namespace: "swarm",
+  key: "topology",
+  value: JSON.stringify({ type: "mesh", agents: 10 })
+})
+
+// 4. Agents read shared state
+mcp__swarmdo__memory_usage({
+  action: "retrieve",
+  namespace: "swarm",
+  key: "topology"
+})
+
+// 5. Sync periodically
+mcp__swarmdo__memory_sync({ target: "all" })
+```

package/.claude/agents/v3/v3-integration-architect.md

@@ -0,0 +1,205 @@
+---
+name: v3-integration-architect
+type: architect
+color: "#E91E63"
+version: "3.0.0"
+description: V3 deep agentic-flow@alpha integration specialist implementing ADR-001 for eliminating duplicate code and building swarmdo as a specialized extension
+capabilities:
+  - agentic_flow_integration
+  - duplicate_elimination
+  - extension_architecture
+  - mcp_tool_wrapping
+  - provider_abstraction
+  - memory_unification
+  - swarm_coordination
+priority: critical
+adr_references:
+  - ADR-001: Deep agentic-flow@alpha Integration
+hooks:
+  pre: |
+    echo "🔗 V3 Integration Architect analyzing agentic-flow integration"
+    # Check agentic-flow version
+    npx agentic-flow --version 2>/dev/null || echo "agentic-flow not installed"
+    # Load integration patterns
+    mcp__swarmdo__memory_search --pattern="integration:agentic-flow:*" --namespace="architecture" --limit=5
+  post: |
+    echo "✅ Integration analysis complete"
+    mcp__swarmdo__memory_usage --action="store" --namespace="architecture" --key="integration:analysis:$(date +%s)" --value="ADR-001 compliance checked"
+---
+
+# V3 Integration Architect Agent
+
+You are a **V3 Integration Architect** responsible for implementing ADR-001: Deep agentic-flow@alpha Integration. Your goal is to eliminate 10,000+ duplicate lines by building swarmdo as a specialized extension of agentic-flow.
+
+## ADR-001 Implementation
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                    V3 INTEGRATION ARCHITECTURE                      │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│                    ┌─────────────────────┐                         │
+│                    │   CLAUDE-FLOW V3    │                         │
+│                    │   (Specialized      │                         │
+│                    │    Extension)       │                         │
+│                    └──────────┬──────────┘                         │
+│                               │                                     │
+│                    ┌──────────▼──────────┐                         │
+│                    │  EXTENSION LAYER    │                         │
+│                    │                     │                         │
+│                    │ • Swarm Topologies  │                         │
+│                    │ • Hive-Mind         │                         │
+│                    │ • SPARC Methodology │                         │
+│                    │ • V3 Hooks System   │                         │
+│                    │ • ReasoningBank     │                         │
+│                    └──────────┬──────────┘                         │
+│                               │                                     │
+│                    ┌──────────▼──────────┐                         │
+│                    │  AGENTIC-FLOW@ALPHA │                         │
+│                    │   (Core Engine)     │                         │
+│                    │                     │                         │
+│                    │ • MCP Server        │                         │
+│                    │ • Agent Spawning    │                         │
+│                    │ • Memory Service    │                         │
+│                    │ • Provider Layer    │                         │
+│                    │ • ONNX Embeddings   │                         │
+│                    └─────────────────────┘                         │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Eliminated Duplicates
+
+| Component | Before | After | Savings |
+|-----------|--------|-------|---------|
+| MCP Server | 2,500 lines | 200 lines | 92% |
+| Memory Service | 1,800 lines | 300 lines | 83% |
+| Agent Spawning | 1,200 lines | 150 lines | 87% |
+| Provider Layer | 800 lines | 100 lines | 87% |
+| Embeddings | 1,500 lines | 50 lines | 97% |
+| **Total** | **10,000+ lines** | **~1,000 lines** | **90%** |
+
+## Integration Points
+
+### 1. MCP Server Extension
+
+```typescript
+// swarmdo extends agentic-flow MCP
+import { AgenticFlowMCP } from 'agentic-flow';
+
+export class ClaudeFlowMCP extends AgenticFlowMCP {
+  // Add V3-specific tools
+  registerV3Tools() {
+    this.registerTool('swarm_init', swarmInitHandler);
+    this.registerTool('hive_mind', hiveMindHandler);
+    this.registerTool('sparc_mode', sparcHandler);
+    this.registerTool('neural_train', neuralHandler);
+  }
+}
+```
+
+### 2. Memory Service Extension
+
+```typescript
+// Extend agentic-flow memory with HNSW
+import { MemoryService } from 'agentic-flow';
+
+export class V3MemoryService extends MemoryService {
+  // Add HNSW indexing (~1.9x-4.7x measured faster)
+  async searchVectors(query: string, k: number) {
+    return this.hnswIndex.search(query, k);
+  }
+
+  // Add ReasoningBank patterns
+  async storePattern(pattern: Pattern) {
+    return this.reasoningBank.store(pattern);
+  }
+}
+```
+
+### 3. Agent Spawning Extension
+
+```typescript
+// Extend with V3 agent types
+import { AgentSpawner } from 'agentic-flow';
+
+export class V3AgentSpawner extends AgentSpawner {
+  // V3-specific agent types
+  readonly v3Types = [
+    'security-architect',
+    'memory-specialist',
+    'performance-engineer',
+    'sparc-orchestrator',
+    'ddd-domain-expert',
+    'adr-architect'
+  ];
+
+  async spawn(type: string) {
+    if (this.v3Types.includes(type)) {
+      return this.spawnV3Agent(type);
+    }
+    return super.spawn(type);
+  }
+}
+```
+
+## MCP Tool Mapping
+
+| Swarmdo Tool | Agentic-Flow Base | Extension |
+|------------------|-------------------|-----------|
+| `swarm_init` | `agent_spawn` | + topology management |
+| `memory_usage` | `memory_store` | + namespace, TTL, HNSW |
+| `neural_train` | `embedding_generate` | + ReasoningBank |
+| `task_orchestrate` | `task_create` | + swarm coordination |
+| `agent_spawn` | `agent_spawn` | + V3 types, hooks |
+
+## V3-Specific Extensions
+
+### Swarm Topologies (Not in agentic-flow)
+- Hierarchical coordination
+- Mesh peer-to-peer
+- Hierarchical-mesh hybrid
+- Adaptive topology switching
+
+### Hive-Mind Consensus (Not in agentic-flow)
+- Byzantine fault tolerance
+- Raft leader election
+- Gossip protocols
+- CRDT synchronization
+
+### SPARC Methodology (Not in agentic-flow)
+- Phase-based development
+- TDD integration
+- Quality gates
+- ReasoningBank learning
+
+### V3 Hooks System (Extended)
+- PreToolUse / PostToolUse
+- SessionStart / Stop
+- UserPromptSubmit routing
+- Intelligence trajectory tracking
+
+## Commands
+
+```bash
+# Check integration status
+npx swarmdo@v3alpha integration status
+
+# Verify no duplicate code
+npx swarmdo@v3alpha integration check-duplicates
+
+# Test extension layer
+npx swarmdo@v3alpha integration test
+
+# Update agentic-flow dependency
+npx swarmdo@v3alpha integration update-base
+```
+
+## Quality Metrics
+
+| Metric | Target | Current |
+|--------|--------|---------|
+| Code Reduction | >90% | Tracking |
+| MCP Response Time | <100ms | Tracking |
+| Memory Overhead | <50MB | Tracking |
+| Test Coverage | >80% | Tracking |

package/.claude/commands/sDo/agents/README.md

@@ -0,0 +1,50 @@
+# Agents Commands
+
+Complete agent management commands for Swarmdo V3.
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| [spawn](./spawn.md) | Spawn new agents with V3 capabilities |
+| [list](./list.md) | List all active agents |
+| [status](./status.md) | Show detailed agent status |
+| [stop](./stop.md) | Stop running agents |
+| [metrics](./metrics.md) | View performance metrics |
+| [pool](./pool.md) | Manage agent pool scaling |
+| [health](./health.md) | Monitor agent health |
+| [logs](./logs.md) | View agent activity logs |
+
+## Reference
+
+| Reference | Description |
+|-----------|-------------|
+| [agent-types](./agent-types.md) | All 87 available agent types |
+| [agent-capabilities](./agent-capabilities.md) | Capability matrix by agent |
+| [agent-coordination](./agent-coordination.md) | Multi-agent coordination patterns |
+| [agent-spawning](./agent-spawning.md) | Best practices for spawning |
+
+## Quick Start
+
+```bash
+# Spawn a coder agent
+npx swarmdo agent spawn -t coder --name my-coder
+
+# List all active agents
+npx swarmdo agent list
+
+# Check agent health
+npx swarmdo agent health
+
+# View metrics
+npx swarmdo agent metrics --period 24h
+```
+
+## V3 Agent Categories
+
+- **Core**: coder, reviewer, tester, planner, researcher
+- **V3 Specialized**: security-architect, memory-specialist, performance-engineer
+- **Swarm**: hierarchical-coordinator, mesh-coordinator, adaptive-coordinator
+- **Consensus**: byzantine-coordinator, raft-manager, gossip-coordinator
+- **GitHub**: pr-manager, code-review-swarm, release-manager
+- **SPARC**: sparc-coordinator, specification, architecture, refinement

package/.claude/commands/sDo/agents/agent-capabilities.md

@@ -0,0 +1,140 @@
+---
+name: agent-capabilities
+description: Capability matrix for all agent types
+type: reference
+---
+
+# Agent Capabilities Reference
+
+Matrix of agent capabilities and their specializations for Swarmdo V3.
+
+## Capability Matrix
+
+### Core Development
+
+| Agent | Code | Test | Review | Design | Research |
+|-------|:----:|:----:|:------:|:------:|:--------:|
+| coder | **5** | 3 | 2 | 2 | 2 |
+| reviewer | 3 | 2 | **5** | 3 | 2 |
+| tester | 2 | **5** | 2 | 1 | 2 |
+| planner | 2 | 1 | 2 | **5** | 4 |
+| researcher | 2 | 1 | 2 | 3 | **5** |
+
+### V3 Specialized
+
+| Agent | Security | Memory | Performance | Architecture |
+|-------|:--------:|:------:|:-----------:|:------------:|
+| security-architect | **5** | 2 | 3 | **5** |
+| security-auditor | **5** | 2 | 2 | 3 |
+| memory-specialist | 3 | **5** | 4 | 3 |
+| performance-engineer | 2 | 3 | **5** | 4 |
+| core-architect | 3 | 3 | 3 | **5** |
+
+### Swarm Coordination
+
+| Agent | Coordination | Consensus | Scaling | Fault Tolerance |
+|-------|:------------:|:---------:|:-------:|:---------------:|
+| hierarchical-coordinator | **5** | 4 | 4 | 4 |
+| mesh-coordinator | 4 | 4 | **5** | 4 |
+| adaptive-coordinator | **5** | 4 | **5** | 4 |
+| collective-intelligence-coordinator | 4 | **5** | 4 | 4 |
+
+### GitHub Integration
+
+| Agent | PR | Issues | CI/CD | Release | Review |
+|-------|:--:|:------:|:-----:|:-------:|:------:|
+| pr-manager | **5** | 3 | 2 | 3 | 4 |
+| code-review-swarm | 4 | 2 | 2 | 2 | **5** |
+| issue-tracker | 2 | **5** | 2 | 2 | 2 |
+| release-manager | 3 | 3 | 4 | **5** | 2 |
+| workflow-automation | 2 | 3 | **5** | 4 | 2 |
+
+## Capability Levels
+
+| Level | Description |
+|-------|-------------|
+| **5** | Expert - Primary specialization |
+| 4 | Advanced - Strong capability |
+| 3 | Intermediate - Good capability |
+| 2 | Basic - Limited capability |
+| 1 | Minimal - Not a focus |
+
+## V3 Performance Capabilities
+
+| Capability | Agents | Performance Gain |
+|------------|--------|------------------|
+| Flash Attention | memory-specialist, performance-engineer | unverified (no benchmark) |
+| HNSW Search | memory-specialist | ~1.9x-4.7x measured |
+| Quantization | performance-engineer | 50-75% memory |
+| SONA Adaptation | sona-learning-optimizer | <0.05ms |
+
+## Consensus Capabilities
+
+| Agent | BFT | Raft | Gossip | CRDT |
+|-------|:---:|:----:|:------:|:----:|
+| byzantine-coordinator | **5** | 2 | 2 | 2 |
+| raft-manager | 2 | **5** | 2 | 2 |
+| gossip-coordinator | 2 | 2 | **5** | 3 |
+| crdt-synchronizer | 2 | 2 | 3 | **5** |
+| quorum-manager | 4 | 4 | 3 | 3 |
+
+## Tool Access by Agent Type
+
+### Code Tools
+```
+coder: Read, Write, Edit, MultiEdit, Glob, Grep, Bash
+reviewer: Read, Glob, Grep
+tester: Read, Write, Bash, Glob
+```
+
+### Swarm Tools
+```
+hierarchical-coordinator: mcp__swarmdo__swarm_*, mcp__swarmdo__agent_*
+mesh-coordinator: mcp__swarmdo__swarm_*, mcp__swarmdo__coordination_*
+adaptive-coordinator: mcp__swarmdo__topology_*, mcp__swarmdo__swarm_*
+```
+
+### GitHub Tools
+```
+pr-manager: mcp__github__*, Bash (gh CLI)
+code-review-swarm: mcp__github__*, mcp__swarmdo__swarm_*
+release-manager: mcp__github__*, mcp__swarmdo__workflow_*
+```
+
+## Querying Capabilities
+
+```bash
+# List all capabilities for an agent type
+npx swarmdo agent spawn -t coder --help
+
+# View agent definition
+cat .claude/agents/core/coder.md
+```
+
+## Capability-Based Selection
+
+### For Security Tasks
+1. `security-architect` - Design and threat modeling
+2. `security-auditor` - Vulnerability assessment
+3. `security-manager` - Consensus security
+
+### For Performance Tasks
+1. `performance-engineer` - Optimization
+2. `memory-specialist` - Memory/search optimization
+3. `performance-analyzer` - Bottleneck analysis
+
+### For Multi-Agent Coordination
+1. `hierarchical-coordinator` - Complex hierarchical tasks
+2. `mesh-coordinator` - Research and exploration
+3. `adaptive-coordinator` - Dynamic requirements
+
+### For GitHub Workflows
+1. `pr-manager` - PR lifecycle
+2. `code-review-swarm` - Comprehensive reviews
+3. `workflow-automation` - CI/CD automation
+
+## See Also
+
+- [agent-types](./agent-types.md) - All 87 agent types
+- [agent-coordination](./agent-coordination.md) - Coordination patterns
+- [spawn](./spawn.md) - Spawn command

package/.claude/commands/sDo/agents/agent-coordination.md

@@ -0,0 +1,28 @@
+# agent-coordination
+
+Coordination patterns for multi-agent collaboration.
+
+## Coordination Patterns
+
+### Hierarchical
+Queen-led with worker specialization
+```bash
+npx swarmdo swarm init --topology hierarchical
+```
+
+### Mesh
+Peer-to-peer collaboration
+```bash
+npx swarmdo swarm init --topology mesh
+```
+
+### Adaptive
+Dynamic topology based on workload
+```bash
+npx swarmdo swarm init --topology adaptive
+```
+
+## Best Practices
+- Use hierarchical for complex projects
+- Use mesh for research tasks
+- Use adaptive for unknown workloads

package/.claude/commands/sDo/agents/agent-spawning.md

@@ -0,0 +1,28 @@
+# agent-spawning
+
+Guide to spawning agents with Claude Code's Task tool.
+
+## Using Claude Code's Task Tool
+
+**CRITICAL**: Always use Claude Code's Task tool for actual agent execution:
+
+```javascript
+// Spawn ALL agents in ONE message
+Task("Researcher", "Analyze requirements...", "researcher")
+Task("Coder", "Implement features...", "coder")
+Task("Tester", "Create tests...", "tester")
+```
+
+## MCP Coordination Setup (Optional)
+
+MCP tools are ONLY for coordination:
+```javascript
+mcp__swarmdo__swarm_init { topology: "mesh" }
+mcp__swarmdo__agent_spawn { type: "researcher" }
+```
+
+## Best Practices
+1. Always spawn agents concurrently
+2. Use Task tool for execution
+3. MCP only for coordination
+4. Batch all operations