@sparkleideas/cli 3.1.0-alpha.21 → 3.1.0-alpha.23

package/.claude/helpers/learning-service.mjs

@@ -7,7 +7,7 @@
  * Features:
  * - Persistent pattern storage via AgentDB
  * - HNSW indexing for 150x-12,500x faster search
- * - ONNX embeddings via @sparkleideas/agentic-flow@alpha
+ * - ONNX embeddings via agentic-flow@alpha
  * - Session-level pattern loading and consolidation
  * - Short-term → Long-term pattern promotion
  *
@@ -27,7 +27,7 @@ import Database from 'better-sqlite3';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PROJECT_ROOT = join(__dirname, '../..');
-const DATA_DIR = join(PROJECT_ROOT, '.@sparkleideas/claude-flow/learning');
+const DATA_DIR = join(PROJECT_ROOT, '.claude-flow/learning');
 const DB_PATH = join(DATA_DIR, 'patterns.db');
 const METRICS_PATH = join(DATA_DIR, 'learning-metrics.json');
 
@@ -444,7 +444,7 @@ class HNSWIndex {
 }
 
 // =============================================================================
-// Embedding Service (ONNX via @sparkleideas/agentic-flow@alpha OptimizedEmbedder)
+// Embedding Service (ONNX via agentic-flow@alpha OptimizedEmbedder)
 // =============================================================================
 
 class EmbeddingService {
@@ -460,7 +460,7 @@ class EmbeddingService {
     if (this.initialized) return;
 
     try {
-      // Dynamically import @sparkleideas/agentic-flow OptimizedEmbedder
+      // Dynamically import agentic-flow OptimizedEmbedder
       const agenticFlowPath = join(PROJECT_ROOT, 'node_modules/agentic-flow/dist/embeddings/optimized-embedder.js');
 
       if (existsSync(agenticFlowPath)) {
@@ -474,10 +474,10 @@ class EmbeddingService {
 
         await this.embedder.init();
         this.useAgenticFlow = true;
-        console.log('[Embedding] Initialized: @sparkleideas/agentic-flow OptimizedEmbedder (ONNX)');
+        console.log('[Embedding] Initialized: agentic-flow OptimizedEmbedder (ONNX)');
       } else {
         this.useAgenticFlow = false;
-        console.log('[Embedding] @sparkleideas/agentic-flow not found, using fallback hash embeddings');
+        console.log('[Embedding] agentic-flow not found, using fallback hash embeddings');
       }
 
       this.initialized = true;
@@ -501,7 +501,7 @@ class EmbeddingService {
 
     if (this.useAgenticFlow && this.embedder) {
       try {
-        // Use @sparkleideas/agentic-flow OptimizedEmbedder
+        // Use agentic-flow OptimizedEmbedder
         embedding = await this.embedder.embed(text.slice(0, 500));
       } catch (e) {
         console.log(`[Embedding] ONNX failed, using fallback: ${e.message}`);

package/.claude/helpers/memory.js

@@ -7,7 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const MEMORY_DIR = path.join(process.cwd(), '.@sparkleideas/claude-flow', 'data');
+const MEMORY_DIR = path.join(process.cwd(), '.claude-flow', 'data');
 const MEMORY_FILE = path.join(MEMORY_DIR, 'memory.json');
 
 function loadMemory() {

package/.claude/helpers/metrics-db.mjs

@@ -14,7 +14,7 @@ import { execSync } from 'child_process';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = join(__dirname, '../..');
 const V3_DIR = join(PROJECT_ROOT, 'v3');
-const DB_PATH = join(PROJECT_ROOT, '.@sparkleideas/claude-flow', 'metrics.db');
+const DB_PATH = join(PROJECT_ROOT, '.claude-flow', 'metrics.db');
 
 // Ensure directory exists
 const dbDir = dirname(DB_PATH);
@@ -255,7 +255,7 @@ async function syncMetrics() {
   if (existsSync(modulesDir)) {
     const entries = readdirSync(modulesDir, { withFileTypes: true });
     for (const entry of entries) {
-      // Skip hidden directories (like .@sparkleideas/agentic-flow, .@sparkleideas/claude-flow)
+      // Skip hidden directories (like .agentic-flow, .claude-flow)
       if (entry.isDirectory() && !entry.name.startsWith('.')) {
         const moduleDir = join(modulesDir, entry.name);
         const { files, lines } = countFilesAndLines(moduleDir);
@@ -388,8 +388,8 @@ function getMetricsJSON() {
  */
 function exportToJSON() {
   const metrics = getMetricsJSON();
-  const metricsDir = join(PROJECT_ROOT, '.@sparkleideas/claude-flow/metrics');
-  const securityDir = join(PROJECT_ROOT, '.@sparkleideas/claude-flow/security');
+  const metricsDir = join(PROJECT_ROOT, '.claude-flow/metrics');
+  const securityDir = join(PROJECT_ROOT, '.claude-flow/security');
 
   if (!existsSync(metricsDir)) mkdirSync(metricsDir, { recursive: true });
   if (!existsSync(securityDir)) mkdirSync(securityDir, { recursive: true });

package/.claude/helpers/session.js

@@ -7,7 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const SESSION_DIR = path.join(process.cwd(), '.@sparkleideas/claude-flow', 'sessions');
+const SESSION_DIR = path.join(process.cwd(), '.claude-flow', 'sessions');
 const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
 
 const commands = {
@@ -100,6 +100,14 @@ const commands = {
     return session;
   },
 
+  get: (key) => {
+    if (!fs.existsSync(SESSION_FILE)) return null;
+    try {
+      const session = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+      return key ? (session.context || {})[key] : session.context;
+    } catch { return null; }
+  },
+
   metric: (name) => {
     if (!fs.existsSync(SESSION_FILE)) {
       return null;

package/.claude/helpers/statusline.cjs

@@ -135,48 +135,104 @@ function getUserInfo() {
   return { name, gitBranch, modelName };
 }
 
-// Get learning stats from memory database
+// Get learning stats from intelligence loop data (ADR-050)
 function getLearningStats() {
-  const memoryPaths = [
-    path.join(process.cwd(), '.swarm', 'memory.db'),
-    path.join(process.cwd(), '.claude', 'memory.db'),
-    path.join(process.cwd(), 'data', 'memory.db'),
-  ];
-
   let patterns = 0;
   let sessions = 0;
   let trajectories = 0;
+  let edges = 0;
+  let confidenceMean = 0;
+  let accessedCount = 0;
+  let trend = 'STABLE';
+
+  // PRIMARY: Read from intelligence loop data files
+  const dataDir = path.join(process.cwd(), '.claude-flow', 'data');
+
+  // 1. graph-state.json — authoritative node/edge counts
+  const graphPath = path.join(dataDir, 'graph-state.json');
+  if (fs.existsSync(graphPath)) {
+    try {
+      const graph = JSON.parse(fs.readFileSync(graphPath, 'utf-8'));
+      patterns = graph.nodes ? Object.keys(graph.nodes).length : 0;
+      edges = Array.isArray(graph.edges) ? graph.edges.length : 0;
+    } catch (e) { /* ignore */ }
+  }
+
+  // 2. ranked-context.json — confidence and access data
+  const rankedPath = path.join(dataDir, 'ranked-context.json');
+  if (fs.existsSync(rankedPath)) {
+    try {
+      const ranked = JSON.parse(fs.readFileSync(rankedPath, 'utf-8'));
+      if (ranked.entries && ranked.entries.length > 0) {
+        patterns = Math.max(patterns, ranked.entries.length);
+        let confSum = 0;
+        let accCount = 0;
+        for (let i = 0; i < ranked.entries.length; i++) {
+          confSum += (ranked.entries[i].confidence || 0);
+          if ((ranked.entries[i].accessCount || 0) > 0) accCount++;
+        }
+        confidenceMean = confSum / ranked.entries.length;
+        accessedCount = accCount;
+      }
+    } catch (e) { /* ignore */ }
+  }
 
-  // Try to read from sqlite database
-  for (const dbPath of memoryPaths) {
-    if (fs.existsSync(dbPath)) {
+  // 3. intelligence-snapshot.json — trend history
+  const snapshotPath = path.join(dataDir, 'intelligence-snapshot.json');
+  if (fs.existsSync(snapshotPath)) {
+    try {
+      const snapshot = JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
+      if (snapshot.history && snapshot.history.length >= 2) {
+        const first = snapshot.history[0];
+        const last = snapshot.history[snapshot.history.length - 1];
+        const confDrift = (last.confidenceMean || 0) - (first.confidenceMean || 0);
+        trend = confDrift > 0.01 ? 'IMPROVING' : confDrift < -0.01 ? 'DECLINING' : 'STABLE';
+        sessions = Math.max(sessions, snapshot.history.length);
+      }
+    } catch (e) { /* ignore */ }
+  }
+
+  // 4. auto-memory-store.json — fallback entry count
+  if (patterns === 0) {
+    const autoMemPath = path.join(dataDir, 'auto-memory-store.json');
+    if (fs.existsSync(autoMemPath)) {
       try {
-        // Count entries in memory file (rough estimate from file size)
-        const stats = fs.statSync(dbPath);
-        const sizeKB = stats.size / 1024;
-        // Estimate: ~2KB per pattern on average
-        patterns = Math.floor(sizeKB / 2);
-        sessions = Math.max(1, Math.floor(patterns / 10));
-        trajectories = Math.floor(patterns / 5);
-        break;
-      } catch (e) {
-        // Ignore
+        const data = JSON.parse(fs.readFileSync(autoMemPath, 'utf-8'));
+        patterns = Array.isArray(data) ? data.length : (data.entries ? data.entries.length : 0);
+      } catch (e) { /* ignore */ }
+    }
+  }
+
+  // FALLBACK: Legacy memory.db file-size estimation
+  if (patterns === 0) {
+    const memoryPaths = [
+      path.join(process.cwd(), '.swarm', 'memory.db'),
+      path.join(process.cwd(), '.claude', 'memory.db'),
+      path.join(process.cwd(), 'data', 'memory.db'),
+    ];
+    for (let j = 0; j < memoryPaths.length; j++) {
+      if (fs.existsSync(memoryPaths[j])) {
+        try {
+          const dbStats = fs.statSync(memoryPaths[j]);
+          patterns = Math.floor(dbStats.size / 1024 / 2);
+          break;
+        } catch (e) { /* ignore */ }
       }
     }
   }
 
-  // Also check for session files
+  // Session count from session files
   const sessionsPath = path.join(process.cwd(), '.claude', 'sessions');
   if (fs.existsSync(sessionsPath)) {
     try {
       const sessionFiles = fs.readdirSync(sessionsPath).filter(f => f.endsWith('.json'));
       sessions = Math.max(sessions, sessionFiles.length);
-    } catch (e) {
-      // Ignore
-    }
+    } catch (e) { /* ignore */ }
   }
 
-  return { patterns, sessions, trajectories };
+  trajectories = Math.floor(patterns / 5);
+
+  return { patterns, sessions, trajectories, edges, confidenceMean, accessedCount, trend };
 }
 
 // Get V3 progress from learning state (grows as system learns)
@@ -250,10 +306,10 @@ function getSwarmStatus() {
   try {
     if (isWindows) {
       // Windows: use tasklist and findstr
-      const ps = execSync('tasklist 2>NUL | findstr /I "@sparkleideas/agentic-flow" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
+      const ps = execSync('tasklist 2>NUL | findstr /I "agentic-flow" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
       activeAgents = Math.max(0, parseInt(ps.trim()) || 0);
     } else {
-      const ps = execSync('ps aux 2>/dev/null | grep -c @sparkleideas/agentic-flow || echo "0"', { encoding: 'utf-8' });
+      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;
@@ -290,20 +346,32 @@ function getSystemMetrics() {
   // Get learning stats for intelligence %
   const learning = getLearningStats();
 
-  // Intelligence % based on learned patterns (0 patterns = 0%, 1000+ = 100%)
-  const intelligencePct = Math.min(100, Math.floor((learning.patterns / 10) * 1));
+  // Intelligence % from REAL intelligence loop data (ADR-050)
+  // Composite: 40% confidence mean + 30% access ratio + 30% pattern density
+  let intelligencePct = 0;
+  if (learning.confidenceMean > 0 || (learning.patterns > 0 && learning.accessedCount > 0)) {
+    const confScore = Math.min(100, Math.floor(learning.confidenceMean * 100));
+    const accessRatio = learning.patterns > 0 ? (learning.accessedCount / learning.patterns) : 0;
+    const accessScore = Math.min(100, Math.floor(accessRatio * 100));
+    const densityScore = Math.min(100, Math.floor(learning.patterns / 5));
+    intelligencePct = Math.floor(confScore * 0.4 + accessScore * 0.3 + densityScore * 0.3);
+  }
+  // Fallback: legacy pattern count
+  if (intelligencePct === 0 && learning.patterns > 0) {
+    intelligencePct = Math.min(100, Math.floor(learning.patterns / 10));
+  }
 
-  // Context % based on session history (0 sessions = 0%, grows with usage)
+  // Context % based on session history
   const contextPct = Math.min(100, Math.floor(learning.sessions * 5));
 
   // Count active sub-agents from process list
   try {
     if (isWindows) {
       // Windows: use tasklist and findstr for agent counting
-      const agents = execSync('tasklist 2>NUL | findstr /I "@sparkleideas/claude-flow" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
+      const agents = execSync('tasklist 2>NUL | findstr /I "claude-flow" 2>NUL | find /C /V "" 2>NUL || echo 0', { encoding: 'utf-8' });
       subAgents = Math.max(0, parseInt(agents.trim()) || 0);
     } else {
-      const agents = execSync('ps aux 2>/dev/null | grep -c "@sparkleideas/claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
+      const agents = execSync('ps aux 2>/dev/null | grep -c "claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
       subAgents = Math.max(0, parseInt(agents.trim()) - 1);
     }
   } catch (e) {

package/.claude/helpers/statusline.js

@@ -172,7 +172,7 @@ function getSwarmStatus() {
   let coordinationActive = false;
 
   try {
-    const ps = execSync('ps aux 2>/dev/null | grep -c @sparkleideas/agentic-flow || echo "0"', { encoding: 'utf-8' });
+    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) {
@@ -210,7 +210,7 @@ function getSystemMetrics() {
 
   // Count active sub-agents from process list
   try {
-    const agents = execSync('ps aux 2>/dev/null | grep -c "@sparkleideas/claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
+    const agents = execSync('ps aux 2>/dev/null | grep -c "claude-flow.*agent" || echo "0"', { encoding: 'utf-8' });
     subAgents = Math.max(0, parseInt(agents.trim()) - 1);
   } catch (e) {
     // Ignore

package/.claude/settings.json

@@ -1,123 +1,95 @@
 {
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1",
+    "CLAUDE_FLOW_V3_ENABLED": "true",
+    "CLAUDE_FLOW_HOOKS_ENABLED": "true"
+  },
   "hooks": {
     "PreToolUse": [
       {
-        "matcher": "^(Write|Edit|MultiEdit)$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "[ -n \"$TOOL_INPUT_file_path\" ] && npx @sparkleideas/cli@latest hooks pre-edit --file \"$TOOL_INPUT_file_path\" 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
-          }
-        ]
-      },
-      {
-        "matcher": "^Bash$",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "[ -n \"$TOOL_INPUT_command\" ] && npx @sparkleideas/cli@latest hooks pre-command --command \"$TOOL_INPUT_command\" 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
-          }
-        ]
-      },
-      {
-        "matcher": "^Task$",
+        "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "[ -n \"$TOOL_INPUT_prompt\" ] && npx @sparkleideas/cli@latest hooks pre-task --task-id \"task-$(date +%s)\" --description \"$TOOL_INPUT_prompt\" 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
+            "command": "node .claude/helpers/hook-handler.cjs pre-bash",
+            "timeout": 5000
           }
         ]
       }
     ],
     "PostToolUse": [
       {
-        "matcher": "^(Write|Edit|MultiEdit)$",
+        "matcher": "Write|Edit|MultiEdit",
         "hooks": [
           {
             "type": "command",
-            "command": "[ -n \"$TOOL_INPUT_file_path\" ] && npx @sparkleideas/cli@latest hooks post-edit --file \"$TOOL_INPUT_file_path\" --success \"${TOOL_SUCCESS:-true}\" 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
+            "command": "node .claude/helpers/hook-handler.cjs post-edit",
+            "timeout": 10000
           }
         ]
-      },
+      }
+    ],
+    "UserPromptSubmit": [
       {
-        "matcher": "^Bash$",
         "hooks": [
           {
             "type": "command",
-            "command": "[ -n \"$TOOL_INPUT_command\" ] && npx @sparkleideas/cli@latest hooks post-command --command \"$TOOL_INPUT_command\" --success \"${TOOL_SUCCESS:-true}\" 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
+            "command": "node .claude/helpers/hook-handler.cjs route",
+            "timeout": 10000
           }
         ]
-      },
+      }
+    ],
+    "SessionStart": [
       {
-        "matcher": "^Task$",
+        "matcher": "startup|resume",
         "hooks": [
           {
             "type": "command",
-            "command": "[ -n \"$TOOL_RESULT_agent_id\" ] && npx @sparkleideas/cli@latest hooks post-task --task-id \"$TOOL_RESULT_agent_id\" --success \"${TOOL_SUCCESS:-true}\" 2>/dev/null || true",
-            "timeout": 5000,
+            "command": "node .claude/helpers/hook-handler.cjs session-restore",
+            "timeout": 15000,
             "continueOnError": true
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
+          },
           {
             "type": "command",
-            "command": "[ -n \"$PROMPT\" ] && npx @sparkleideas/cli@latest hooks route --task \"$PROMPT\" || true",
-            "timeout": 5000,
+            "command": "node .claude/helpers/auto-memory-hook.mjs import",
+            "timeout": 8000,
             "continueOnError": true
           }
         ]
       }
     ],
-    "SessionStart": [
+    "SessionEnd": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "npx @sparkleideas/cli@latest daemon start --quiet 2>/dev/null || true",
-            "timeout": 5000,
-            "continueOnError": true
-          },
-          {
-            "type": "command",
-            "command": "[ -n \"$SESSION_ID\" ] && npx @sparkleideas/cli@latest hooks session-restore --session-id \"$SESSION_ID\" 2>/dev/null || true",
+            "command": "node .claude/helpers/hook-handler.cjs session-end",
             "timeout": 10000,
             "continueOnError": true
           }
         ]
       }
     ],
-    "Stop": [
+    "SubagentStart": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "echo '{\"ok\": true}'",
-            "timeout": 1000
+            "command": "node .claude/helpers/hook-handler.cjs status",
+            "timeout": 3000,
+            "continueOnError": true
           }
         ]
       }
     ],
-    "Notification": [
+    "Stop": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "[ -n \"$NOTIFICATION_MESSAGE\" ] && npx @sparkleideas/cli@latest memory store --namespace notifications --key \"notify-$(date +%s)\" --value \"$NOTIFICATION_MESSAGE\" 2>/dev/null || true",
-            "timeout": 3000,
+            "command": "node .claude/helpers/auto-memory-hook.mjs sync",
+            "timeout": 10000,
             "continueOnError": true
           }
         ]
@@ -126,24 +98,44 @@
   },
   "statusLine": {
     "type": "command",
-    "command": "npx @sparkleideas/cli@latest hooks statusline 2>/dev/null || node .claude/helpers/statusline.cjs 2>/dev/null || echo \"▊ Claude Flow V3\"",
+    "command": "node .claude/helpers/statusline.cjs",
     "refreshMs": 5000,
     "enabled": true
   },
   "permissions": {
     "allow": [
-      "Bash(npx @sparkleideas/claude-flow:*)",
-      "Bash(npx @sparkleideas/cli:*)",
+      "Bash(npx @claude-flow*)",
+      "Bash(npx claude-flow*)",
+      "Bash(node .claude/*)",
       "mcp__claude-flow__:*"
     ],
-    "deny": []
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.*)"
+    ]
+  },
+  "attribution": {
+    "commit": "Co-Authored-By: claude-flow <ruv@ruv.net>",
+    "pr": "Generated with [claude-flow](https://github.com/ruvnet/claude-flow)"
   },
   "claudeFlow": {
-    "version": "3.0.0",
+    "version": "3.1.0",
     "enabled": true,
     "modelPreferences": {
-      "default": "claude-opus-4-5-20251101",
-      "routing": "claude-3-5-haiku-20241022"
+      "default": "claude-opus-4-6",
+      "routing": "claude-haiku-4-5-20251001"
+    },
+    "agentTeams": {
+      "enabled": true,
+      "teammateMode": "auto",
+      "taskListEnabled": true,
+      "mailboxEnabled": true,
+      "coordination": {
+        "autoAssignOnIdle": true,
+        "trainPatternsOnComplete": true,
+        "notifyLeadOnComplete": true,
+        "sharedMemoryNamespace": "agent-teams"
+      }
     },
     "swarm": {
       "topology": "hierarchical-mesh",
@@ -151,87 +143,40 @@
     },
     "memory": {
       "backend": "hybrid",
-      "enableHNSW": true
+      "enableHNSW": true,
+      "learningBridge": {
+        "enabled": true,
+        "sonaMode": "balanced",
+        "confidenceDecayRate": 0.005,
+        "accessBoostAmount": 0.03,
+        "consolidationThreshold": 10
+      },
+      "memoryGraph": {
+        "enabled": true,
+        "pageRankDamping": 0.85,
+        "communityAlgorithm": "label-propagation"
+      },
+      "agentScopes": {
+        "enabled": true,
+        "scopes": ["project", "local", "user"]
+      }
     },
     "neural": {
       "enabled": true
     },
+    "security": {
+      "autoScan": true,
+      "scanOnEdit": true,
+      "cveCheck": true
+    },
     "daemon": {
       "autoStart": true,
-      "workers": [
-        "map",
-        "audit",
-        "optimize",
-        "consolidate",
-        "testgaps",
-        "ultralearn",
-        "deepdive",
-        "document",
-        "refactor",
-        "benchmark"
-      ],
-      "schedules": {
-        "audit": {
-          "interval": "1h",
-          "priority": "critical"
-        },
-        "optimize": {
-          "interval": "30m",
-          "priority": "high"
-        },
-        "consolidate": {
-          "interval": "2h",
-          "priority": "low"
-        },
-        "document": {
-          "interval": "1h",
-          "priority": "normal",
-          "triggers": [
-            "adr-update",
-            "api-change"
-          ]
-        },
-        "deepdive": {
-          "interval": "4h",
-          "priority": "normal",
-          "triggers": [
-            "complex-change"
-          ]
-        },
-        "ultralearn": {
-          "interval": "1h",
-          "priority": "normal"
-        }
-      }
+      "workers": ["map", "audit", "optimize", "consolidate", "testgaps", "ultralearn"]
     },
     "learning": {
       "enabled": true,
       "autoTrain": true,
-      "patterns": [
-        "coordination",
-        "optimization",
-        "prediction"
-      ],
-      "retention": {
-        "shortTerm": "24h",
-        "longTerm": "30d"
-      }
-    },
-    "adr": {
-      "autoGenerate": true,
-      "directory": "/docs/adr",
-      "template": "madr"
-    },
-    "ddd": {
-      "trackDomains": true,
-      "validateBoundedContexts": true,
-      "directory": "/docs/ddd"
-    },
-    "security": {
-      "autoScan": true,
-      "scanOnEdit": true,
-      "cveCheck": true,
-      "threatModel": true
+      "patterns": ["coordination", "optimization", "prediction"]
     }
   }
-}
+}

package/.claude/skills/reasoningbank-intelligence/SKILL.md

@@ -11,8 +11,8 @@ Implements ReasoningBank's adaptive learning system for AI agents to learn from
 
 ## Prerequisites
 
-- agentic-flow v1.5.11+
-- AgentDB v1.0.4+ (for persistence)
+- agentic-flow v3.0.0-alpha.1+
+- AgentDB v3.0.0-alpha.10+ (for persistence)
 - Node.js 18+
 
 ## Quick Start

package/.claude/skills/skill-builder/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}