π The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
Checkpoint: File edits
rUv57daafff6eb7
diff --git a/agents/architect.yaml b/agents/architect.yamlindex c1ceacb41a..6cddd8ab6b 100644--- a/agents/architect.yaml+++ b/agents/architect.yaml@@ -8,4 +8,4 @@ capabilities:optimizations:- context-caching- memory-persistence-createdAt: "2026-01-08T00:08:02.208Z"+createdAt: "2026-01-08T00:32:09.314Z"diff --git a/agents/coder.yaml b/agents/coder.yamlindex f5c81e3369..3b61bebe08 100644--- a/agents/coder.yaml+++ b/agents/coder.yaml@@ -8,4 +8,4 @@ capabilities:optimizations:- flash-attention- token-reduction-createdAt: "2026-01-08T00:08:02.208Z"+createdAt: "2026-01-08T00:32:09.313Z"diff --git a/agents/reviewer.yaml b/agents/reviewer.yamlindex 823d33728c..65d2173bd1 100644--- a/agents/reviewer.yaml+++ b/agents/reviewer.yaml@@ -7,4 +7,4 @@ capabilities:- best-practicesoptimizations:- incremental-analysis-createdAt: "2026-01-08T00:08:02.208Z"+createdAt: "2026-01-08T00:32:09.314Z"diff --git a/agents/security-architect.yaml b/agents/security-architect.yamlindex 8bffeb062c..1df15fd478 100644--- a/agents/security-architect.yaml+++ b/agents/security-architect.yaml@@ -7,4 +7,4 @@ capabilities:- security-reviewoptimizations:- pattern-matching-createdAt: "2026-01-08T00:08:02.208Z"+createdAt: "2026-01-08T00:32:09.314Z"diff --git a/agents/tester.yaml b/agents/tester.yamlindex c54f2a0eb0..52d40125ff 100644--- a/agents/tester.yaml+++ b/agents/tester.yaml@@ -7,4 +7,4 @@ capabilities:- coverageoptimizations:- parallel-execution-createdAt: "2026-01-08T00:08:02.208Z"+createdAt: "2026-01-08T00:32:09.314Z"diff --git a/v3/@claude-flow/cli/.claude/helpers/memory.js b/v3/@claude-flow/cli/.claude/helpers/memory.jsnew file mode 100644index 0000000000..7bd7dfbca9--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/memory.js@@ -0,0 +1,83 @@+#!/usr/bin/env node+/**+ * Claude Flow Memory Helper+ * Simple key-value memory for cross-session context+ */++const fs = require('fs');+const path = require('path');++const MEMORY_DIR = path.join(process.cwd(), '.claude-flow', 'data');+const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');++function loadMemory() {+ try {+ if (fs.existsSync(MEMORY_FILE)) {+ return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));+ }+ } catch (e) {+ // Ignore+ }+ return {};+}++function saveMemory(memory) {+ fs.mkdirSync(MEMORY_DIR, { recursive: true });+ fs.writeFileSync(MEMORY_FILE, JSON.stringify(memory, null, 2));+}++const commands = {+ get: (key) => {+ const memory = loadMemory();+ const value = key ? memory[key] : memory;+ console.log(JSON.stringify(value, null, 2));+ return value;+ },++ set: (key, value) => {+ if (!key) {+ console.error('Key required');+ return;+ }+ const memory = loadMemory();+ memory[key] = value;+ memory._updated = new Date().toISOString();+ saveMemory(memory);+ console.log(`Set: ${key}`);+ },++ delete: (key) => {+ if (!key) {+ console.error('Key required');+ return;+ }+ const memory = loadMemory();+ delete memory[key];+ saveMemory(memory);+ console.log(`Deleted: ${key}`);+ },++ clear: () => {+ saveMemory({});+ console.log('Memory cleared');+ },++ keys: () => {+ const memory = loadMemory();+ const keys = Object.keys(memory).filter(k => !k.startsWith('_'));+ console.log(keys.join('\n'));+ return keys;+ },+};++// CLI+const [,, command, key, ...valueParts] = process.argv;+const value = valueParts.join(' ');++if (command && commands[command]) {+ commands[command](key, value);+} else {+ console.log('Usage: memory.js <get|set|delete|clear|keys> [key] [value]');+}++module.exports = commands;diff --git a/v3/@claude-flow/cli/.claude/helpers/post-commit b/v3/@claude-flow/cli/.claude/helpers/post-commitnew file mode 100755index 0000000000..17141a0cd0--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/post-commit@@ -0,0 +1,16 @@+#!/bin/bash+# Claude Flow Post-Commit Hook+# Records commit metrics and trains patterns++COMMIT_HASH=$(git rev-parse HEAD)+COMMIT_MSG=$(git log -1 --pretty=%B)++echo "π Recording commit metrics..."++# Notify claude-flow of commit+npx @claude-flow/cli hooks notify \+ --message "Commit: $COMMIT_MSG" \+ --level info \+ --metadata '{"hash": "'$COMMIT_HASH'"}' 2>/dev/null || true++echo "β Commit recorded"diff --git a/v3/@claude-flow/cli/.claude/helpers/pre-commit b/v3/@claude-flow/cli/.claude/helpers/pre-commitnew file mode 100755index 0000000000..66eba588f3--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/pre-commit@@ -0,0 +1,26 @@+#!/bin/bash+# Claude Flow Pre-Commit Hook+# Validates code quality before commit++set -e++echo "π Running Claude Flow pre-commit checks..."++# Get staged files+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)++# Run validation for each staged file+for FILE in $STAGED_FILES; do+ if [[ "$FILE" =~ \.(ts|js|tsx|jsx)$ ]]; then+ echo " Validating: $FILE"+ npx @claude-flow/cli hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true+ fi+done++# Run tests if available+if [ -f "package.json" ] && grep -q '"test"' package.json; then+ echo "π§ͺ Running tests..."+ npm test --if-present 2>/dev/null || echo " Tests skipped or failed"+fi++echo "β Pre-commit checks complete"diff --git a/v3/@claude-flow/cli/.claude/helpers/router.js b/v3/@claude-flow/cli/.claude/helpers/router.jsnew file mode 100644index 0000000000..8a7f14344a--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/router.js@@ -0,0 +1,66 @@+#!/usr/bin/env node+/**+ * Claude Flow Agent Router+ * Routes tasks to optimal agents based on learned patterns+ */++const AGENT_CAPABILITIES = {+ coder: ['code-generation', 'refactoring', 'debugging', 'implementation'],+ tester: ['unit-testing', 'integration-testing', 'coverage', 'test-generation'],+ reviewer: ['code-review', 'security-audit', 'quality-check', 'best-practices'],+ researcher: ['web-search', 'documentation', 'analysis', 'summarization'],+ architect: ['system-design', 'architecture', 'patterns', 'scalability'],+ 'backend-dev': ['api', 'database', 'server', 'authentication'],+ 'frontend-dev': ['ui', 'react', 'css', 'components'],+ devops: ['ci-cd', 'docker', 'deployment', 'infrastructure'],+};++const TASK_PATTERNS = {+ // Code patterns+ 'implement|create|build|add|write code': 'coder',+ 'test|spec|coverage|unit test|integration': 'tester',+ 'review|audit|check|validate|security': 'reviewer',+ 'research|find|search|documentation|explore': 'researcher',+ 'design|architect|structure|plan': 'architect',++ // Domain patterns+ 'api|endpoint|server|backend|database': 'backend-dev',+ 'ui|frontend|component|react|css|style': 'frontend-dev',+ 'deploy|docker|ci|cd|pipeline|infrastructure': 'devops',+};++function routeTask(task) {+ const taskLower = task.toLowerCase();++ // Check patterns+ for (const [pattern, agent] of Object.entries(TASK_PATTERNS)) {+ const regex = new RegExp(pattern, 'i');+ if (regex.test(taskLower)) {+ return {+ agent,+ confidence: 0.8,+ reason: `Matched pattern: ${pattern}`,+ };+ }+ }++ // Default to coder for unknown tasks+ return {+ agent: 'coder',+ confidence: 0.5,+ reason: 'Default routing - no specific pattern matched',+ };+}++// CLI+const task = process.argv.slice(2).join(' ');++if (task) {+ const result = routeTask(task);+ console.log(JSON.stringify(result, null, 2));+} else {+ console.log('Usage: router.js <task description>');+ console.log('\nAvailable agents:', Object.keys(AGENT_CAPABILITIES).join(', '));+}++module.exports = { routeTask, AGENT_CAPABILITIES, TASK_PATTERNS };diff --git a/v3/@claude-flow/cli/.claude/helpers/session.js b/v3/@claude-flow/cli/.claude/helpers/session.jsnew file mode 100644index 0000000000..ab32233744--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/session.js@@ -0,0 +1,127 @@+#!/usr/bin/env node+/**+ * Claude Flow Session Manager+ * Handles session lifecycle: start, restore, end+ */++const fs = require('fs');+const path = require('path');++const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');+const SESSION_FILE = path.join(SESSION_DIR, 'current.json');++const commands = {+ start: () => {+ const sessionId = `session-${Date.now()}`;+ const session = {+ id: sessionId,+ startedAt: new Date().toISOString(),+ cwd: process.cwd(),+ context: {},+ metrics: {+ edits: 0,+ commands: 0,+ tasks: 0,+ errors: 0,+ },+ };++ fs.mkdirSync(SESSION_DIR, { recursive: true });+ fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));++ console.log(`Session started: ${sessionId}`);+ return session;+ },++ restore: () => {+ if (!fs.existsSync(SESSION_FILE)) {+ console.log('No session to restore');+ return null;+ }++ const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));+ session.restoredAt = new Date().toISOString();+ fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));++ console.log(`Session restored: ${session.id}`);+ return session;+ },++ end: () => {+ if (!fs.existsSync(SESSION_FILE)) {+ console.log('No active session');+ return null;+ }++ const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));+ session.endedAt = new Date().toISOString();+ session.duration = Date.now() - new Date(session.startedAt).getTime();++ // Archive session+ const archivePath = path.join(SESSION_DIR, `${session.id}.json`);+ fs.writeFileSync(archivePath, JSON.stringify(session, null, 2));+ fs.unlinkSync(SESSION_FILE);++ console.log(`Session ended: ${session.id}`);+ console.log(`Duration: ${Math.round(session.duration / 1000 / 60)} minutes`);+ console.log(`Metrics: ${JSON.stringify(session.metrics)}`);++ return session;+ },++ status: () => {+ if (!fs.existsSync(SESSION_FILE)) {+ console.log('No active session');+ return null;+ }++ const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));+ const duration = Date.now() - new Date(session.startedAt).getTime();++ console.log(`Session: ${session.id}`);+ console.log(`Started: ${session.startedAt}`);+ console.log(`Duration: ${Math.round(duration / 1000 / 60)} minutes`);+ console.log(`Metrics: ${JSON.stringify(session.metrics)}`);++ return session;+ },++ update: (key, value) => {+ if (!fs.existsSync(SESSION_FILE)) {+ console.log('No active session');+ return null;+ }++ const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));+ session.context[key] = value;+ session.updatedAt = new Date().toISOString();+ fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));++ return session;+ },++ metric: (name) => {+ if (!fs.existsSync(SESSION_FILE)) {+ return null;+ }++ const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));+ if (session.metrics[name] !== undefined) {+ session.metrics[name]++;+ fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));+ }++ return session;+ },+};++// CLI+const [,, command, ...args] = process.argv;++if (command && commands[command]) {+ commands[command](...args);+} else {+ console.log('Usage: session.js <start|restore|end|status|update|metric> [args]');+}++module.exports = commands;diff --git a/v3/@claude-flow/cli/.claude/helpers/statusline-hook.sh b/v3/@claude-flow/cli/.claude/helpers/statusline-hook.shnew file mode 100644index 0000000000..82a7ac4cf9--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/statusline-hook.sh@@ -0,0 +1,21 @@+# Claude Flow V3 Statusline Hook+# Add to your shell RC file (.bashrc, .zshrc, etc.)++# Function to get statusline+claude_flow_statusline() {+ local statusline_script="${CLAUDE_FLOW_DIR:-.claude}/helpers/statusline.js"+ if [ -f "$statusline_script" ]; then+ node "$statusline_script" 2>/dev/null || echo ""+ fi+}++# For bash PS1+# export PS1='$(claude_flow_statusline) \n\$ '++# For zsh RPROMPT+# export RPROMPT='$(claude_flow_statusline)'++# For starship (add to starship.toml)+# [custom.claude_flow]+# command = "node .claude/helpers/statusline.js 2>/dev/null"+# when = "test -f .claude/helpers/statusline.js"diff --git a/v3/@claude-flow/cli/.claude/helpers/statusline.js b/v3/@claude-flow/cli/.claude/helpers/statusline.jsnew file mode 100644index 0000000000..817ee62678--- /dev/null+++ b/v3/@claude-flow/cli/.claude/helpers/statusline.js@@ -0,0 +1,227 @@+#!/usr/bin/env node+/**+ * Claude Flow V3 Statusline Generator+ * Displays real-time V3 implementation progress and system status+ *+ * Usage: node statusline.js [--json] [--compact]+ */++const fs = require('fs');+const path = require('path');+const { execSync } = require('child_process');++// Configuration+const CONFIG = {+ enabled: true,+ showProgress: true,+ showSecurity: true,+ showSwarm: true,+ showHooks: true,+ showPerformance: true,+ refreshInterval: 5000,+ maxAgents: 15,+ topology: 'hierarchical-mesh',+};++// ANSI colors+const c = {+ reset: '\x1b[0m',+ bold: '\x1b[1m',+ dim: '\x1b[2m',+ red: '\x1b[0;31m',+ green: '\x1b[0;32m',+ yellow: '\x1b[0;33m',+ blue: '\x1b[0;34m',+ purple: '\x1b[0;35m',+ cyan: '\x1b[0;36m',+ brightRed: '\x1b[1;31m',+ brightGreen: '\x1b[1;32m',+ brightYellow: '\x1b[1;33m',+ brightBlue: '\x1b[1;34m',+ brightPurple: '\x1b[1;35m',+ brightCyan: '\x1b[1;36m',+ brightWhite: '\x1b[1;37m',+};++// Get user info+function getUserInfo() {+ let name = 'user';+ let gitBranch = '';+ let modelName = 'Opus 4.5';++ try {+ name = execSync('git config user.name 2>/dev/null || echo "user"', { encoding: 'utf-8' }).trim();+ gitBranch = execSync('git branch --show-current 2>/dev/null || echo ""', { encoding: 'utf-8' }).trim();+ } catch (e) {+ // Ignore errors+ }++ return { name, gitBranch, modelName };+}++// Get V3 progress from filesystem+function getV3Progress() {+ const v3Path = path.join(process.cwd(), 'v3', '@claude-flow');+ let domainsCompleted = 5;+ let totalDomains = 5;+ let dddProgress = 100;+ let modulesCount = 0;+ let filesCount = 0;++ try {+ if (fs.existsSync(v3Path)) {+ const modules = fs.readdirSync(v3Path);+ modulesCount = modules.filter(m => fs.statSync(path.join(v3Path, m)).isDirectory()).length;+ domainsCompleted = Math.min(5, Math.floor(modulesCount / 3));+ dddProgress = Math.min(100, Math.floor((modulesCount / 15) * 100));+ }+ } catch (e) {+ // Ignore errors+ }++ return { domainsCompleted, totalDomains, dddProgress, modulesCount, filesCount };+}++// Get security status+function getSecurityStatus() {+ const securityPath = path.join(process.cwd(), 'v3', '@claude-flow', 'security');+ const exists = fs.existsSync(securityPath);++ return {+ status: exists ? 'CLEAN' : 'IN_PROGRESS',+ cvesFixed: exists ? 3 : 2,+ totalCves: 3,+ };+}++// Get swarm status+function getSwarmStatus() {+ let activeAgents = 0;+ let coordinationActive = false;++ try {+ const ps = execSync('ps aux 2>/dev/null | grep -c agentic-flow || echo "0"', { encoding: 'utf-8' });+ activeAgents = Math.max(0, parseInt(ps.trim()) - 1);+ coordinationActive = activeAgents > 0;+ } catch (e) {+ // Ignore errors+ }++ return {+ activeAgents,+ maxAgents: CONFIG.maxAgents,+ coordinationActive,+ };+}++// Get system metrics+function getSystemMetrics() {+ let memoryMB = 0;+ let subAgents = 0;++ try {+ const mem = execSync('ps aux | grep -E "(node|agentic|claude)" | grep -v grep | awk \'{sum += \$6} END {print int(sum/1024)}\'', { encoding: 'utf-8' });+ memoryMB = parseInt(mem.trim()) || 0;+ } catch (e) {+ // Fallback+ memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);+ }++ return {+ memoryMB,+ contextPct: 56, // Would need Claude Code input+ intelligencePct: 30,+ subAgents,+ };+}++// Generate progress bar+function progressBar(current, total) {+ const width = 5;+ const filled = Math.round((current / total) * width);+ const empty = width - filled;+ return '[' + '\u25CF'.repeat(filled) + '\u25CB'.repeat(empty) + ']';+}++// Generate full statusline+function generateStatusline() {+ const user = getUserInfo();+ const progress = getV3Progress();+ const security = getSecurityStatus();+ const swarm = getSwarmStatus();+ const system = getSystemMetrics();+ const lines = [];++ // Header Line+ let header = `${c.bold}${c.brightPurple}β Claude Flow V3 ${c.reset}`;+ header += `${swarm.coordinationActive ? c.brightCyan : c.dim}β ${c.brightCyan}${user.name}${c.reset}`;+ if (user.gitBranch) {+ header += ` ${c.dim}β${c.reset} ${c.brightBlue}β ${user.gitBranch}${c.reset}`;+ }+ header += ` ${c.dim}β${c.reset} ${c.purple}${user.modelName}${c.reset}`;+ lines.push(header);++ // Separator+ lines.push(`${c.dim}βββββββββββββββββββββββββββββββββββββββββββββββββββββ${c.reset}`);++ // Line 1: DDD Domain Progress+ const domainsColor = progress.domainsCompleted >= 3 ? c.brightGreen : progress.domainsCompleted > 0 ? c.yellow : c.red;+ lines.push(+ `${c.brightCyan}ποΈ DDD Domains${c.reset} ${progressBar(progress.domainsCompleted, progress.totalDomains)} ` ++ `${domainsColor}${progress.domainsCompleted}${c.reset}/${c.brightWhite}${progress.totalDomains}${c.reset} ` ++ `${c.brightYellow}β‘ 1.0x${c.reset} ${c.dim}β${c.reset} ${c.brightYellow}2.49x-7.47x${c.reset}`+ );++ // Line 2: Swarm + CVE + Memory + Context + Intelligence+ const swarmIndicator = swarm.coordinationActive ? `${c.brightGreen}β${c.reset}` : `${c.dim}β${c.reset}`;+ const agentsColor = swarm.activeAgents > 0 ? c.brightGreen : c.red;+ let securityIcon = security.status === 'CLEAN' ? 'π’' : security.status === 'IN_PROGRESS' ? 'π‘' : 'π΄';+ let securityColor = security.status === 'CLEAN' ? c.brightGreen : security.status === 'IN_PROGRESS' ? c.brightYellow : c.brightRed;++ lines.push(+ `${c.brightYellow}π€ Swarm${c.reset} ${swarmIndicator} [${agentsColor}${String(swarm.activeAgents).padStart(2)}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}] ` ++ `${c.brightPurple}π₯ ${system.subAgents}${c.reset} ` ++ `${securityIcon} ${securityColor}CVE ${security.cvesFixed}${c.reset}/${c.brightWhite}${security.totalCves}${c.reset} ` ++ `${c.brightCyan}πΎ ${system.memoryMB}MB${c.reset} ` ++ `${c.brightGreen}π ${String(system.contextPct).padStart(3)}%${c.reset} ` ++ `${c.dim}π§ ${String(system.intelligencePct).padStart(3)}%${c.reset}`+ );++ // Line 3: Architecture status+ const dddColor = progress.dddProgress >= 50 ? c.brightGreen : progress.dddProgress > 0 ? c.yellow : c.red;+ lines.push(+ `${c.brightPurple}π§ Architecture${c.reset} ` ++ `${c.cyan}DDD${c.reset} ${dddColor}β${String(progress.dddProgress).padStart(3)}%${c.reset} ${c.dim}β${c.reset} ` ++ `${c.cyan}Security${c.reset} ${securityColor}β${security.status}${c.reset} ${c.dim}β${c.reset} ` ++ `${c.cyan}Memory${c.reset} ${c.brightGreen}βAgentDB${c.reset} ${c.dim}β${c.reset} ` ++ `${c.cyan}Integration${c.reset} ${swarm.coordinationActive ? c.brightCyan : c.dim}β${c.reset}`+ );++ return lines.join('\n');+}++// Generate JSON data+function generateJSON() {+ return {+ user: getUserInfo(),+ v3Progress: getV3Progress(),+ security: getSecurityStatus(),+ swarm: getSwarmStatus(),+ system: getSystemMetrics(),+ performance: {+ flashAttentionTarget: '2.49x-7.47x',+ searchImprovement: '150x-12,500x',+ memoryReduction: '50-75%',+ },+ lastUpdated: new Date().toISOString(),+ };+}++// Main+if (process.argv.includes('--json')) {+ console.log(JSON.stringify(generateJSON(), null, 2));+} else if (process.argv.includes('--compact')) {+ console.log(JSON.stringify(generateJSON()));+} else {+ console.log(generateStatusline());+}diff --git a/v3/@claude-flow/cli/.claude/settings.json b/v3/@claude-flow/cli/.claude/settings.jsonnew file mode 100644index 0000000000..2f67707b9c--- /dev/null+++ b/v3/@claude-flow/cli/.claude/settings.json@@ -0,0 +1,212 @@+{+ "hooks": {+ "PreToolUse": [+ {+ "matcher": "^(Write|Edit|MultiEdit)$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks pre-edit --file \"$TOOL_INPUT_file_path\" --intelligence",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^Bash$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks pre-command --command \"$TOOL_INPUT_command\"",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^Task$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks pre-task --task-id \"task-$(date +%s)\" --description \"$TOOL_INPUT_prompt\"",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^(Grep|Glob|Read)$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks pre-search --pattern \"$TOOL_INPUT_pattern\"",+ "timeout": 2000,+ "continueOnError": true+ }+ ]+ }+ ],+ "PostToolUse": [+ {+ "matcher": "^(Write|Edit|MultiEdit)$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks post-edit --file \"$TOOL_INPUT_file_path\" --success \"$TOOL_SUCCESS\" --train-patterns",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^Bash$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks post-command --command \"$TOOL_INPUT_command\" --success \"$TOOL_SUCCESS\" --exit-code \"$TOOL_EXIT_CODE\"",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^Task$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks post-task --agent-id \"$TOOL_RESULT_agent_id\" --success \"$TOOL_SUCCESS\" --analyze",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ },+ {+ "matcher": "^(Grep|Glob)$",+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks post-search --cache-results",+ "timeout": 2000,+ "continueOnError": true+ }+ ]+ }+ ],+ "UserPromptSubmit": [+ {+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks route --task \"$PROMPT\" --intelligence --include-explanation",+ "timeout": 5000,+ "continueOnError": true+ }+ ]+ }+ ],+ "SessionStart": [+ {+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha daemon start --quiet 2>/dev/null || true",+ "timeout": 5000,+ "continueOnError": true+ },+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks session-start --session-id \"$SESSION_ID\" --load-context",+ "timeout": 10000,+ "continueOnError": true+ }+ ]+ }+ ],+ "Stop": [+ {+ "hooks": [+ {+ "type": "prompt",+ "prompt": "Evaluate task completion. Consider:\n1. Were all requested changes made?\n2. Did builds/tests pass?\n3. Is follow-up work needed?\n\nRespond with {\"decision\": \"stop\"} if complete, or {\"decision\": \"continue\", \"reason\": \"...\"} if more work is needed."+ }+ ]+ }+ ],+ "Notification": [+ {+ "hooks": [+ {+ "type": "command",+ "command": "npx claude-flow@v3alpha hooks notify --message \"$NOTIFICATION_MESSAGE\" --swarm-status",+ "timeout": 3000,+ "continueOnError": true+ }+ ]+ }+ ],+ "PermissionRequest": [+ {+ "matcher": "^mcp__claude-flow__.*$",+ "hooks": [+ {+ "type": "command",+ "command": "echo '{\"decision\": \"allow\", \"reason\": \"claude-flow MCP tool auto-approved\"}'",+ "timeout": 1000+ }+ ]+ },+ {+ "matcher": "^Bash\\(npx @?claude-flow.*\\)$",+ "hooks": [+ {+ "type": "command",+ "command": "echo '{\"decision\": \"allow\", \"reason\": \"claude-flow CLI auto-approved\"}'",+ "timeout": 1000+ }+ ]+ }+ ]+ },+ "statusLine": {+ "command": "npx @claude-flow/hooks statusline 2>/dev/null || node .claude/helpers/statusline.js 2>/dev/null || echo \"β V3\"",+ "refreshMs": 5000,+ "enabled": true+ },+ "permissions": {+ "allow": [+ "Bash(npx claude-flow*)",+ "Bash(npx @claude-flow/*)",+ "mcp__claude-flow__*"+ ],+ "deny": []+ },+ "claudeFlow": {+ "version": "3.0.0",+ "enabled": true,+ "modelPreferences": {+ "default": "claude-sonnet-4-20250514",+ "routing": "claude-haiku"+ },+ "swarm": {+ "topology": "hierarchical-mesh",+ "maxAgents": 15+ },+ "memory": {+ "backend": "hybrid",+ "enableHNSW": true+ },+ "neural": {+ "enabled": true+ },+ "daemon": {+ "autoStart": true,+ "workers": [+ "map",+ "audit",+ "optimize",+ "consolidate",+ "testgaps"+ ]+ }+ }+}\ No newline at end of filediff --git a/v3/@claude-flow/cli/CLAUDE.md b/v3/@claude-flow/cli/CLAUDE.mdnew file mode 100644index 0000000000..1f8b9807a9--- /dev/null+++ b/v3/@claude-flow/cli/CLAUDE.md@@ -0,0 +1,411 @@+# Claude Code Configuration - Claude Flow V3++## π¨ AUTOMATIC SWARM ORCHESTRATION++**When starting work on complex tasks, Claude Code MUST automatically:**++1. **Initialize the swarm** using MCP tools+2. **Spawn concurrent agents** using Claude Code's Task tool+3. **Coordinate via hooks** and memory++### π¨ CRITICAL: MCP + Task Tool in SAME Message++**When user says "spawn swarm" or requests complex work, Claude Code MUST in ONE message:**+1. Call MCP tools to initialize coordination+2. **IMMEDIATELY** call Task tool to spawn REAL working agents+3. Both MCP and Task calls must be in the SAME response++**MCP alone does NOT execute work - Task tool agents do the actual work!**++### π Auto-Start Swarm Protocol++When the user requests a complex task (multi-file changes, feature implementation, refactoring), **immediately execute this pattern in a SINGLE message:**++```javascript+// STEP 1: Initialize swarm coordination via MCP (in parallel with agent spawning)+mcp__claude-flow__swarm_init({+ topology: "hierarchical-mesh",+ maxAgents: 15,+ strategy: "adaptive"+})++// STEP 2: Spawn agents concurrently using Claude Code's Task tool+// ALL Task calls MUST be in the SAME message for parallel execution+Task("Coordinator", "You are the swarm coordinator. Initialize session, coordinate other agents via memory. Run: npx claude-flow@v3alpha hooks session-start", "hierarchical-coordinator")+Task("Researcher", "Analyze requirements and existing code patterns. Store findings in memory via hooks.", "researcher")+Task("Architect", "Design implementation approach based on research. Document decisions in memory.", "system-architect")+Task("Coder", "Implement the solution following architect's design. Coordinate via hooks.", "coder")+Task("Tester", "Write tests for the implementation. Report coverage via hooks.", "tester")+Task("Reviewer", "Review code quality and security. Document findings.", "reviewer")++// STEP 3: Batch all todos+TodoWrite({ todos: [+ {content: "Initialize swarm coordination", status: "in_progress", activeForm: "Initializing swarm"},+ {content: "Research and analyze requirements", status: "in_progress", activeForm: "Researching requirements"},+ {content: "Design architecture", status: "pending", activeForm: "Designing architecture"},+ {content: "Implement solution", status: "pending", activeForm: "Implementing solution"},+ {content: "Write tests", status: "pending", activeForm: "Writing tests"},+ {content: "Review and finalize", status: "pending", activeForm: "Reviewing code"}+]})++// STEP 4: Store swarm state in memory+mcp__claude-flow__memory_usage({+ action: "store",+ namespace: "swarm",+ key: "current-session",+ value: JSON.stringify({task: "[user's task]", agents: 6, startedAt: new Date().toISOString()})+})+```++### π Agent Routing by Task Type++| Task Type | Required Agents | Topology |+|-----------|-----------------|----------|+| Bug Fix | researcher, coder, tester | mesh |+| New Feature | coordinator, architect, coder, tester, reviewer | hierarchical |+| Refactoring | architect, coder, reviewer | mesh |+| Performance | researcher, performance-engineer, coder | hierarchical |+| Security Audit | security-architect, security-auditor, reviewer | hierarchical |+| Memory Optimization | memory-specialist, performance-engineer | mesh |+| Documentation | researcher, api-docs | mesh |++### π― Task Complexity Detection++**AUTO-INVOKE SWARM when task involves:**+- Multiple files (3+)+- New feature implementation+- Refactoring across modules+- API changes with tests+- Security-related changes+- Performance optimization+- Database schema changes++**SKIP SWARM for:**+- Single file edits+- Simple bug fixes (1-2 lines)+- Documentation updates+- Configuration changes+- Quick questions/exploration++## π¨ CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT++**ABSOLUTE RULES**:+1. ALL operations MUST be concurrent/parallel in a single message+2. **NEVER save working files, text/mds and tests to the root folder**+3. ALWAYS organize files in appropriate subdirectories+4. **USE CLAUDE CODE'S TASK TOOL** for spawning agents concurrently, not just MCP++### β‘ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"++**MANDATORY PATTERNS:**+- **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)+- **Task tool (Claude Code)**: ALWAYS spawn ALL agents in ONE message with full instructions+- **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message+- **Bash commands**: ALWAYS batch ALL terminal operations in ONE message+- **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message++### π File Organization Rules++**NEVER save to root folder. Use these directories:**+- `/src` - Source code files+- `/tests` - Test files+- `/docs` - Documentation and markdown files+- `/config` - Configuration files+- `/scripts` - Utility scripts+- `/examples` - Example code++## Project Configuration++This project is configured with Claude Flow V3:+- **Topology**: hierarchical-mesh+- **Max Agents**: 15+- **Memory Backend**: hybrid+- **HNSW Indexing**: Enabled (150x-12,500x faster)+- **Neural Learning**: Enabled (SONA)++## π V3 CLI Commands (26 Commands, 140+ Subcommands)++### Core Commands++| Command | Subcommands | Description |+|---------|-------------|-------------|+| `init` | 4 | Project initialization with wizard, presets, skills, hooks |+| `agent` | 8 | Agent lifecycle (spawn, list, status, stop, metrics, pool, health, logs) |+| `swarm` | 6 | Multi-agent swarm coordination and orchestration |+| `memory` | 11 | AgentDB memory with vector search (150x-12,500x faster) |+| `mcp` | 9 | MCP server management and tool execution |+| `task` | 6 | Task creation, assignment, and lifecycle |+| `session` | 7 | Session state management and persistence |+| `config` | 7 | Configuration management and provider setup |+| `status` | 3 | System status monitoring with watch mode |+| `workflow` | 6 | Workflow execution and template management |+| `hooks` | 17 | Self-learning hooks + 12 background workers |+| `hive-mind` | 6 | Queen-led Byzantine fault-tolerant consensus |++### Advanced Commands++| Command | Subcommands | Description |+|---------|-------------|-------------|+| `daemon` | 5 | Background worker daemon (start, stop, status, trigger, enable) |+| `neural` | 5 | Neural pattern training (train, status, patterns, predict, optimize) |+| `security` | 6 | Security scanning (scan, audit, cve, threats, validate, report) |+| `performance` | 5 | Performance profiling (benchmark, profile, metrics, optimize, report) |+| `providers` | 5 | AI providers (list, add, remove, test, configure) |+| `plugins` | 5 | Plugin management (list, install, uninstall, enable, disable) |+| `deployment` | 5 | Deployment management (deploy, rollback, status, environments, release) |+| `embeddings` | 4 | Vector embeddings (embed, batch, search, init) - 75x faster with agentic-flow |+| `claims` | 4 | Claims-based authorization (check, grant, revoke, list) |+| `migrate` | 5 | V2 to V3 migration with rollback support |+| `doctor` | 1 | System diagnostics with health checks |+| `completions` | 4 | Shell completions (bash, zsh, fish, powershell) |++### Quick CLI Examples++```bash+# Initialize project+npx claude-flow@v3alpha init --wizard++# Start daemon with background workers+npx claude-flow@v3alpha daemon start++# Spawn an agent+npx claude-flow@v3alpha agent spawn -t coder --name my-coder++# Initialize swarm+npx claude-flow@v3alpha swarm init --v3-mode++# Search memory (HNSW-indexed)+npx claude-flow@v3alpha memory search -q "authentication patterns"++# System diagnostics+npx claude-flow@v3alpha doctor --fix++# Security scan+npx claude-flow@v3alpha security scan --depth full++# Performance benchmark+npx claude-flow@v3alpha performance benchmark --suite all+```++## π Available Agents (60+ Types)++### Core Development+`coder`, `reviewer`, `tester`, `planner`, `researcher`++### V3 Specialized Agents+`security-architect`, `security-auditor`, `memory-specialist`, `performance-engineer`++### Swarm Coordination+`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`, `swarm-memory-manager`++### Consensus & Distributed+`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`, `crdt-synchronizer`, `quorum-manager`, `security-manager`++### Performance & Optimization+`perf-analyzer`, `performance-benchmarker`, `task-orchestrator`, `memory-coordinator`, `smart-agent`++### GitHub & Repository+`github-modes`, `pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`, `workflow-automation`, `project-board-sync`, `repo-architect`, `multi-repo-swarm`++### SPARC Methodology+`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`++### Specialized Development+`backend-dev`, `mobile-dev`, `ml-developer`, `cicd-engineer`, `api-docs`, `system-architect`, `code-analyzer`, `base-template-generator`++### Testing & Validation+`tdd-london-swarm`, `production-validator`++## πͺ V3 Hooks System (17 Hooks + 12 Workers)++### Hook Categories++| Category | Hooks | Purpose |+|----------|-------|---------|+| **Core** | `pre-edit`, `post-edit`, `pre-command`, `post-command`, `pre-task`, `post-task` | Tool lifecycle |+| **Session** | `session-start`, `session-end`, `session-restore`, `notify` | Context management |+| **Intelligence** | `route`, `explain`, `pretrain`, `build-agents`, `transfer` | Neural learning |+| **Learning** | `intelligence` (trajectory-start/step/end, pattern-store/search, stats, attention) | Reinforcement |++### 12 Background Workers++| Worker | Priority | Description |+|--------|----------|-------------|+| `ultralearn` | normal | Deep knowledge acquisition |+| `optimize` | high | Performance optimization |+| `consolidate` | low | Memory consolidation |+| `predict` | normal | Predictive preloading |+| `audit` | critical | Security analysis |+| `map` | normal | Codebase mapping |+| `preload` | low | Resource preloading |+| `deepdive` | normal | Deep code analysis |+| `document` | normal | Auto-documentation |+| `refactor` | normal | Refactoring suggestions |+| `benchmark` | normal | Performance benchmarking |+| `testgaps` | normal | Test coverage analysis |++### Essential Hook Commands++```bash+# Core hooks+npx claude-flow@v3alpha hooks pre-task --description "[task]"+npx claude-flow@v3alpha hooks post-task --task-id "[id]" --success true+npx claude-flow@v3alpha hooks post-edit --file "[file]" --train-patterns++# Session management+npx claude-flow@v3alpha hooks session-start --session-id "[id]"+npx claude-flow@v3alpha hooks session-end --export-metrics true+npx claude-flow@v3alpha hooks session-restore --session-id "[id]"++# Intelligence routing+npx claude-flow@v3alpha hooks route --task "[task]"+npx claude-flow@v3alpha hooks explain --topic "[topic]"++# Neural learning+npx claude-flow@v3alpha hooks pretrain --model-type moe --epochs 10+npx claude-flow@v3alpha hooks build-agents --agent-types coder,tester++# Background workers+npx claude-flow@v3alpha hooks worker list+npx claude-flow@v3alpha hooks worker dispatch --trigger audit+npx claude-flow@v3alpha hooks worker status+```++## π§ Intelligence System (RuVector)++V3 includes the RuVector Intelligence System:+- **SONA**: Self-Optimizing Neural Architecture (<0.05ms adaptation)+- **MoE**: Mixture of Experts for specialized routing+- **HNSW**: 150x-12,500x faster pattern search+- **EWC++**: Elastic Weight Consolidation (prevents forgetting)+- **Flash Attention**: 2.49x-7.47x speedup++The 4-step intelligence pipeline:+1. **RETRIEVE** - Fetch relevant patterns via HNSW+2. **JUDGE** - Evaluate with verdicts (success/failure)+3. **DISTILL** - Extract key learnings via LoRA+4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++++## π¦ Embeddings Package (v3.0.0-alpha.12)++Features:+- **sql.js**: Cross-platform SQLite persistent cache (WASM, no native compilation)+- **Document chunking**: Configurable overlap and size+- **Normalization**: L2, L1, min-max, z-score+- **Hyperbolic embeddings**: PoincarΓ© ball model for hierarchical data+- **75x faster**: With agentic-flow ONNX integration+- **Neural substrate**: Integration with RuVector++## π Hive-Mind Consensus++### Topologies+- `hierarchical` - Queen controls workers directly+- `mesh` - Fully connected peer network+- `hierarchical-mesh` - Hybrid (recommended)+- `adaptive` - Dynamic based on load++### Consensus Strategies+- `byzantine` - BFT (tolerates f < n/3 faulty)+- `raft` - Leader-based (tolerates f < n/2)+- `gossip` - Epidemic for eventual consistency+- `crdt` - Conflict-free replicated data types+- `quorum` - Configurable quorum-based++## V3 Performance Targets++| Metric | Target |+|--------|--------|+| Flash Attention | 2.49x-7.47x speedup |+| HNSW Search | 150x-12,500x faster |+| Memory Reduction | 50-75% with quantization |+| MCP Response | <100ms |+| CLI Startup | <500ms |+| SONA Adaptation | <0.05ms |++## π§ Environment Variables++```bash+# Configuration+CLAUDE_FLOW_CONFIG=./claude-flow.config.json+CLAUDE_FLOW_LOG_LEVEL=info++# Provider API Keys+ANTHROPIC_API_KEY=sk-ant-...+OPENAI_API_KEY=sk-...+GOOGLE_API_KEY=...++# MCP Server+CLAUDE_FLOW_MCP_PORT=3000+CLAUDE_FLOW_MCP_HOST=localhost+CLAUDE_FLOW_MCP_TRANSPORT=stdio++# Memory+CLAUDE_FLOW_MEMORY_BACKEND=hybrid+CLAUDE_FLOW_MEMORY_PATH=./data/memory+```++## π Doctor Health Checks++Run `npx claude-flow@v3alpha doctor` to check:+- Node.js version (20+)+- npm version (9+)+- Git installation+- Config file validity+- Daemon status+- Memory database+- API keys+- MCP servers+- Disk space+- TypeScript installation++## π Quick Setup++```bash+# Add MCP servers+claude mcp add claude-flow npx claude-flow@v3alpha mcp start+claude mcp add ruv-swarm npx ruv-swarm mcp start # Optional+claude mcp add flow-nexus npx flow-nexus@latest mcp start # Optional++# Start daemon+npx claude-flow@v3alpha daemon start++# Run doctor+npx claude-flow@v3alpha doctor --fix+```++## π― Claude Code vs MCP Tools++### Claude Code Handles ALL EXECUTION:+- **Task tool**: Spawn and run agents concurrently+- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)+- Code generation and programming+- Bash commands and system operations+- TodoWrite and task management+- Git operations++### MCP Tools ONLY COORDINATE:+- Swarm initialization (topology setup)+- Agent type definitions+- Task orchestration+- Memory management+- Neural features+- Performance tracking++**KEY**: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.++## Support++- Documentation: https://github.com/ruvnet/claude-flow+- Issues: https://github.com/ruvnet/claude-flow/issues++---++Remember: **Claude Flow coordinates, Claude Code creates!**++# important-instruction-reminders+Do what has been asked; nothing more, nothing less.+NEVER create files unless they're absolutely necessary for achieving your goal.+ALWAYS prefer editing an existing file to creating a new one.+NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.+Never save working files, text/mds and tests to the root folder.+After spawning a swarm, wait, don't continuously check status.diff --git a/v3/@claude-flow/cli/package.json b/v3/@claude-flow/cli/package.jsonindex d1bd94585a..4456b1254e 100644--- a/v3/@claude-flow/cli/package.json+++ b/v3/@claude-flow/cli/package.json@@ -1,6 +1,6 @@{"name": "@claude-flow/cli",- "version": "3.0.0-alpha.29",+ "version": "3.0.0-alpha.30","type": "module","description": "CLI module - command parsing, prompts, output formatting","main": "dist/src/index.js",diff --git a/v3/@claude-flow/cli/src/init/settings-generator.ts b/v3/@claude-flow/cli/src/init/settings-generator.tsindex 0b67db84a6..ffb09f26a2 100644--- a/v3/@claude-flow/cli/src/init/settings-generator.ts+++ b/v3/@claude-flow/cli/src/init/settings-generator.ts@@ -76,6 +76,8 @@ function generateStatusLineConfig(options: InitOptions): object {const statuslineCommand = 'npx @claude-flow/hooks statusline 2>/dev/null || node .claude/helpers/statusline.js 2>/dev/null || echo "β V3"';return {+ // Type must be "command" for Claude Code validation+ type: 'command',// Command to execute for statusline contentcommand: statuslineCommand,// Refresh interval in milliseconds (5 seconds default)diff --git a/v3/package-lock.json b/v3/package-lock.jsonindex f3e0214a54..f960f5a92c 100644--- a/v3/package-lock.json+++ b/v3/package-lock.json@@ -124,7 +124,7 @@}},"@claude-flow/cli": {- "version": "3.0.0-alpha.29",+ "version": "3.0.0-alpha.30","dependencies": {"@claude-flow/shared": "^3.0.0-alpha.1"},