@sparkleideas/agentic-flow 2.0.2-alpha-patch.1

package/agentic-flow/.claude/skills/sparc-methodology/skill.md

@@ -0,0 +1,137 @@
+---
+name: sparc-methodology
+description: SPARC development methodology for systematic test-driven development
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - specification
+  - pseudocode
+  - architecture
+  - refinement
+  - completion
+---
+
+# SPARC Methodology Skill
+
+Systematic Test-Driven Development using SPARC (Specification, Pseudocode, Architecture, Refinement, Completion).
+
+## Quick Commands
+
+```bash
+# Run complete TDD workflow
+npx agentic-flow@alpha sparc tdd "implement user authentication"
+
+# Run specific phase
+npx agentic-flow@alpha sparc run specification "auth system"
+npx agentic-flow@alpha sparc run pseudocode "auth system"
+npx agentic-flow@alpha sparc run architect "auth system"
+npx agentic-flow@alpha sparc run refinement "auth system"
+npx agentic-flow@alpha sparc run completion "auth system"
+
+# Batch execution
+npx agentic-flow@alpha sparc batch "spec-pseudocode,architect" "feature X"
+```
+
+## SPARC Phases
+
+### 1. Specification (spec)
+Define requirements and acceptance criteria.
+
+**Agent**: `specification`
+**Output**: Requirements doc, test cases
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run spec "user login feature"
+```
+
+### 2. Pseudocode (pseudo)
+Design algorithms and logic flow.
+
+**Agent**: `pseudocode`
+**Output**: Algorithm design, flow diagrams
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run pseudo "auth flow"
+```
+
+### 3. Architecture (arch)
+System design and component structure.
+
+**Agent**: `architecture`
+**Output**: Component diagram, API design
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run arch "microservices layout"
+```
+
+### 4. Refinement (refine)
+Iterative TDD implementation.
+
+**Agent**: `refinement`
+**Output**: Tests + Implementation
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run refine "auth module"
+```
+
+### 5. Completion (complete)
+Integration and deployment.
+
+**Agent**: `completion`
+**Output**: Integrated system, docs
+**Command**:
+```bash
+npx agentic-flow@alpha sparc run complete "auth system"
+```
+
+## SPARC Modes
+
+Additional specialized modes:
+
+| Mode | Description |
+|------|-------------|
+| `dev` | General development |
+| `api` | API design |
+| `ui` | UI/UX development |
+| `test` | Testing focus |
+| `refactor` | Code improvement |
+| `debug` | Bug investigation |
+| `security` | Security review |
+| `devops` | CI/CD setup |
+
+## TDD Workflow
+
+```bash
+# Full TDD cycle
+npx agentic-flow@alpha sparc tdd "implement OAuth2"
+
+# This runs:
+# 1. Specification: Define requirements
+# 2. Pseudocode: Design algorithm
+# 3. Architecture: Plan structure
+# 4. Refinement: Write tests first, then implement
+# 5. Completion: Integrate and document
+```
+
+## Agent Integration
+
+SPARC uses specialized agents:
+
+```javascript
+// Via Claude Code Task tool
+Task("Specification agent", "Define requirements for OAuth", "specification")
+Task("Architecture agent", "Design OAuth architecture", "architecture")
+Task("Coder agent", "Implement OAuth with TDD", "sparc-coder")
+Task("Tester agent", "Verify OAuth implementation", "tester")
+Task("Reviewer agent", "Review OAuth code quality", "reviewer")
+```
+
+## Best Practices
+
+1. **Start with specification**: Clear requirements first
+2. **Write tests first**: TDD in refinement phase
+3. **Iterate small**: Small increments
+4. **Document as you go**: Keep docs updated
+5. **Review at each phase**: Quality gates
+6. **Use parallel execution**: Multiple agents

package/agentic-flow/.claude/skills/swarm-coordination/skill.md

@@ -0,0 +1,94 @@
+---
+name: swarm-coordination
+description: Orchestrate multi-agent swarms for complex parallel task execution
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - swarm_init
+  - agent_spawn
+  - task_orchestration
+  - topology_optimization
+---
+
+# Swarm Coordination Skill
+
+Coordinate multi-agent swarms for parallel task execution with intelligent topology selection.
+
+## Quick Start
+
+```bash
+# Initialize a mesh swarm with 5 agents
+npx agentic-flow@alpha swarm init --topology mesh --agents 5
+
+# Spawn specialized agents
+npx agentic-flow@alpha swarm spawn --type researcher --name "Research Agent"
+npx agentic-flow@alpha swarm spawn --type coder --name "Code Agent"
+
+# Orchestrate a task
+npx agentic-flow@alpha swarm orchestrate "Implement feature X with tests"
+
+# Check swarm status
+npx agentic-flow@alpha swarm status
+```
+
+## Topologies
+
+### Mesh (Default)
+- All agents communicate directly
+- Best for: Collaborative tasks, code review
+- Latency: Low
+- Scalability: Medium
+
+### Hierarchical
+- Tree structure with coordinator
+- Best for: Large projects, delegation
+- Latency: Medium
+- Scalability: High
+
+### Ring
+- Sequential communication
+- Best for: Pipeline processing, CI/CD
+- Latency: Higher
+- Scalability: Medium
+
+### Star
+- Central hub coordinates all
+- Best for: Simple coordination
+- Latency: Low
+- Scalability: Low
+
+## Agent Types
+
+| Type | Description | Use Case |
+|------|-------------|----------|
+| researcher | Deep analysis | Requirements gathering |
+| coder | Implementation | Feature development |
+| tester | Quality assurance | Test creation |
+| reviewer | Code quality | PR review |
+| architect | System design | Architecture decisions |
+| coordinator | Task routing | Complex workflows |
+
+## MCP Tools
+
+```javascript
+// Initialize swarm
+mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 8 })
+
+// Spawn agent
+mcp__claude-flow__agent_spawn({ type: "coder", name: "Feature Dev" })
+
+// Orchestrate task
+mcp__claude-flow__task_orchestrate({
+  task: "Implement OAuth",
+  strategy: "parallel"
+})
+```
+
+## Best Practices
+
+1. **Right-size your swarm**: Start with 3-5 agents
+2. **Choose topology wisely**: Match to task structure
+3. **Use Claude Code Task tool**: For actual agent spawning
+4. **Monitor status**: Check for bottlenecks
+5. **Clean up**: Destroy swarm when done

package/agentic-flow/.claude/skills/worker-benchmarks/skill.md

@@ -0,0 +1,135 @@
+---
+name: worker-benchmarks
+description: Run comprehensive worker system benchmarks and performance analysis
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - performance_testing
+  - metrics_collection
+  - optimization_recommendations
+---
+
+# Worker Benchmarks Skill
+
+Run comprehensive performance benchmarks for the agentic-flow worker system.
+
+## Quick Start
+
+```bash
+# Run full benchmark suite
+npx agentic-flow workers benchmark
+
+# Run specific benchmark
+npx agentic-flow workers benchmark --type trigger-detection
+npx agentic-flow workers benchmark --type registry
+npx agentic-flow workers benchmark --type agent-selection
+npx agentic-flow workers benchmark --type concurrent
+```
+
+## Benchmark Types
+
+### 1. Trigger Detection (`trigger-detection`)
+Tests keyword detection speed across 12 worker triggers.
+- **Target**: p95 < 5ms
+- **Iterations**: 1000
+- **Metrics**: latency, throughput, histogram
+
+### 2. Worker Registry (`registry`)
+Tests CRUD operations on worker entries.
+- **Target**: p95 < 10ms
+- **Iterations**: 500 creates, gets, updates
+- **Metrics**: per-operation latency breakdown
+
+### 3. Agent Selection (`agent-selection`)
+Tests performance-based agent selection.
+- **Target**: p95 < 1ms
+- **Iterations**: 1000
+- **Metrics**: selection confidence, agent scores
+
+### 4. Model Cache (`cache`)
+Tests model caching performance.
+- **Target**: p95 < 0.5ms
+- **Metrics**: hit rate, cache size, eviction stats
+
+### 5. Concurrent Workers (`concurrent`)
+Tests parallel worker creation and updates.
+- **Target**: < 1000ms for 10 workers
+- **Metrics**: per-worker latency, memory usage
+
+### 6. Memory Key Generation (`memory-keys`)
+Tests memory pattern key generation.
+- **Target**: p95 < 0.1ms
+- **Iterations**: 5000
+- **Metrics**: unique patterns, throughput
+
+## Output Format
+
+```
+═══════════════════════════════════════════════════════════
+📈 BENCHMARK RESULTS
+═══════════════════════════════════════════════════════════
+
+✅ Trigger Detection
+   Operation: detect
+   Count: 1,000
+   Avg: 0.045ms | p95: 0.120ms (target: 5ms)
+   Throughput: 22,222 ops/s
+   Memory Δ: 0.12MB
+
+✅ Worker Registry
+   Operation: crud
+   Count: 1,500
+   Avg: 1.234ms | p95: 3.456ms (target: 10ms)
+   Throughput: 810 ops/s
+   Memory Δ: 2.34MB
+
+───────────────────────────────────────────────────────────
+📊 SUMMARY
+───────────────────────────────────────────────────────────
+Total Tests: 6
+Passed: 6 | Failed: 0
+Avg Latency: 0.567ms
+Total Duration: 2345ms
+Peak Memory: 8.90MB
+═══════════════════════════════════════════════════════════
+```
+
+## Integration with Settings
+
+Benchmark thresholds are configured in `.claude/settings.json`:
+
+```json
+{
+  "performance": {
+    "benchmarkThresholds": {
+      "triggerDetection": { "p95Ms": 5 },
+      "workerRegistry": { "p95Ms": 10 },
+      "agentSelection": { "p95Ms": 1 },
+      "memoryKeyGeneration": { "p95Ms": 0.1 },
+      "concurrentWorkers": { "totalMs": 1000 }
+    }
+  }
+}
+```
+
+## Programmatic Usage
+
+```typescript
+import { workerBenchmarks, runBenchmarks } from 'agentic-flow/workers/worker-benchmarks';
+
+// Run full suite
+const suite = await runBenchmarks();
+console.log(suite.summary);
+
+// Run individual benchmarks
+const triggerResult = await workerBenchmarks.benchmarkTriggerDetection(1000);
+const registryResult = await workerBenchmarks.benchmarkRegistryOperations(500);
+```
+
+## Performance Optimization Tips
+
+1. **Model Cache**: Enable with `CLAUDE_FLOW_MODEL_CACHE_MB=512`
+2. **Parallel Workers**: Enable with `CLAUDE_FLOW_WORKER_PARALLEL=true`
+3. **Warning Suppression**: Enable with `CLAUDE_FLOW_SUPPRESS_WARNINGS=true`
+4. **SQLite WAL Mode**: Automatic for better concurrent performance

package/agentic-flow/.claude/skills/worker-integration/skill.md

@@ -0,0 +1,154 @@
+---
+name: worker-integration
+description: Worker-Agent integration for intelligent task dispatch and performance tracking
+version: 1.0.0
+invocable: true
+author: agentic-flow
+capabilities:
+  - agent_selection
+  - performance_tracking
+  - memory_coordination
+  - self_learning
+---
+
+# Worker-Agent Integration Skill
+
+Intelligent coordination between background workers and specialized agents.
+
+## Quick Start
+
+```bash
+# View agent recommendations for a trigger
+npx agentic-flow workers agents ultralearn
+npx agentic-flow workers agents optimize
+
+# View performance metrics
+npx agentic-flow workers metrics
+
+# View integration stats
+npx agentic-flow workers stats --integration
+```
+
+## Agent Mappings
+
+Workers automatically dispatch to optimal agents based on trigger type:
+
+| Trigger | Primary Agents | Fallback | Pipeline Phases |
+|---------|---------------|----------|-----------------|
+| `ultralearn` | researcher, coder | planner | discovery → patterns → vectorization → summary |
+| `optimize` | performance-analyzer, coder | researcher | static-analysis → performance → patterns |
+| `audit` | security-analyst, tester | reviewer | security → secrets → vulnerability-scan |
+| `benchmark` | performance-analyzer | coder, tester | performance → metrics → report |
+| `testgaps` | tester | coder | discovery → coverage → gaps |
+| `document` | documenter, researcher | coder | api-discovery → patterns → indexing |
+| `deepdive` | researcher, security-analyst | coder | call-graph → deps → trace |
+| `refactor` | coder, reviewer | researcher | complexity → smells → patterns |
+
+## Performance-Based Selection
+
+The system learns from execution history to improve agent selection:
+
+```typescript
+// Agent selection considers:
+// 1. Quality score (0-1)
+// 2. Success rate
+// 3. Average latency
+// 4. Execution count
+
+const { agent, confidence, reasoning } = selectBestAgent('optimize');
+// agent: "performance-analyzer"
+// confidence: 0.87
+// reasoning: "Selected based on 45 executions with 94.2% success"
+```
+
+## Memory Key Patterns
+
+Workers store results using consistent patterns:
+
+```
+{trigger}/{topic}/{phase}
+
+Examples:
+- ultralearn/auth-module/analysis
+- optimize/database/performance
+- audit/payment/vulnerabilities
+- benchmark/api/metrics
+```
+
+## Benchmark Thresholds
+
+Agents are monitored against performance thresholds:
+
+```json
+{
+  "researcher": {
+    "p95_latency": "<500ms",
+    "memory_mb": "<256MB"
+  },
+  "coder": {
+    "p95_latency": "<300ms",
+    "quality_score": ">0.85"
+  },
+  "security-analyst": {
+    "scan_coverage": ">95%",
+    "p95_latency": "<1000ms"
+  }
+}
+```
+
+## Feedback Loop
+
+Workers provide feedback for continuous improvement:
+
+```typescript
+import { workerAgentIntegration } from 'agentic-flow/workers/worker-agent-integration';
+
+// Record execution feedback
+workerAgentIntegration.recordFeedback(
+  'optimize',           // trigger
+  'coder',              // agent
+  true,                 // success
+  245,                  // latency ms
+  0.92                  // quality score
+);
+
+// Check compliance
+const { compliant, violations } = workerAgentIntegration.checkBenchmarkCompliance('coder');
+```
+
+## Integration Statistics
+
+```bash
+$ npx agentic-flow workers stats --integration
+
+Worker-Agent Integration Stats
+══════════════════════════════
+Total Agents:       6
+Tracked Agents:     4
+Total Feedback:     156
+Avg Quality Score:  0.89
+
+Model Cache Stats
+─────────────────
+Hits:     1,234
+Misses:   45
+Hit Rate: 96.5%
+```
+
+## Configuration
+
+Enable integration features in `.claude/settings.json`:
+
+```json
+{
+  "workers": {
+    "enabled": true,
+    "parallel": true,
+    "memoryDepositEnabled": true,
+    "agentMappings": {
+      "ultralearn": ["researcher", "coder"],
+      "optimize": ["performance-analyzer", "coder"]
+    }
+  }
+}
+```

package/agentic-flow/.claude/statusline.mjs

@@ -0,0 +1,109 @@
+/**
+ * Agentic Flow Statusline for Claude Code
+ * Shows model, tokens, cost, swarm status, and memory usage
+ */
+
+import { execSync } from 'child_process';
+
+// Cache for expensive operations
+let lastSwarmCheck = 0;
+let cachedSwarmStatus = null;
+const CACHE_TTL = 5000; // 5 seconds
+
+/**
+ * Get swarm status (cached)
+ */
+function getSwarmStatus() {
+  const now = Date.now();
+  if (cachedSwarmStatus && (now - lastSwarmCheck) < CACHE_TTL) {
+    return cachedSwarmStatus;
+  }
+
+  try {
+    const result = execSync('npx @sparkleideas/agentic-flow@alpha mcp status 2>/dev/null || echo "idle"', {
+      encoding: 'utf-8',
+      timeout: 2000
+    }).trim();
+
+    cachedSwarmStatus = result.includes('running') ? '🐝' : '⚡';
+    lastSwarmCheck = now;
+    return cachedSwarmStatus;
+  } catch {
+    cachedSwarmStatus = '⚡';
+    lastSwarmCheck = now;
+    return cachedSwarmStatus;
+  }
+}
+
+/**
+ * Format token count
+ */
+function formatTokens(tokens) {
+  if (tokens >= 1000000) {
+    return `${(tokens / 1000000).toFixed(1)}M`;
+  }
+  if (tokens >= 1000) {
+    return `${(tokens / 1000).toFixed(1)}K`;
+  }
+  return String(tokens);
+}
+
+/**
+ * Format cost
+ */
+function formatCost(cost) {
+  if (cost >= 1) {
+    return `$${cost.toFixed(2)}`;
+  }
+  return `$${cost.toFixed(4)}`;
+}
+
+/**
+ * Main statusline export
+ */
+export default function statusline(context) {
+  const parts = [];
+
+  // Agentic Flow indicator
+  parts.push('🤖');
+
+  // Model name (shortened)
+  if (context.model) {
+    const model = context.model
+      .replace('claude-', '')
+      .replace('-20250514', '')
+      .replace('sonnet-4', 'S4')
+      .replace('opus-4', 'O4')
+      .replace('haiku-3.5', 'H3.5');
+    parts.push(model);
+  }
+
+  // Token usage
+  if (context.inputTokens !== undefined || context.outputTokens !== undefined) {
+    const input = formatTokens(context.inputTokens || 0);
+    const output = formatTokens(context.outputTokens || 0);
+    parts.push(`↑${input} ↓${output}`);
+  }
+
+  // Cost
+  if (context.totalCost !== undefined && context.totalCost > 0) {
+    parts.push(formatCost(context.totalCost));
+  }
+
+  // Swarm/MCP status indicator
+  parts.push(getSwarmStatus());
+
+  // Session time
+  if (context.sessionStartTime) {
+    const elapsed = Math.floor((Date.now() - context.sessionStartTime) / 1000);
+    const mins = Math.floor(elapsed / 60);
+    const secs = elapsed % 60;
+    if (mins > 0) {
+      parts.push(`${mins}m${secs}s`);
+    } else {
+      parts.push(`${secs}s`);
+    }
+  }
+
+  return parts.join(' │ ');
+}

package/agentic-flow/.claude/statusline.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Agentic Flow Intelligence Status Line
+# Shows real-time learning metrics from SONA + HNSW + ReasoningBank
+
+INTEL_FILE=".agentic-flow/intelligence.json"
+INTEL_DB=".agentic-flow/intelligence.db"
+
+# Default values
+PATTERNS=0
+MEMORIES=0
+ROUTES=0
+TRAJECTORIES=0
+LEARNING_RATE=10
+EPSILON=10
+
+# Get current git branch
+GIT_BRANCH=""
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  GIT_BRANCH=$(git branch --show-current 2>/dev/null || echo "")
+fi
+
+# Read intelligence metrics
+if [ -f "$INTEL_FILE" ]; then
+  PATTERNS=$(jq -r '.patterns | length // 0' "$INTEL_FILE" 2>/dev/null || echo "0")
+  MEMORIES=$(jq -r '.memories | length // 0' "$INTEL_FILE" 2>/dev/null || echo "0")
+  ROUTES=$(jq -r '.metrics.totalRoutes // 0' "$INTEL_FILE" 2>/dev/null || echo "0")
+  TRAJECTORIES=$(jq -r '.trajectories | length // 0' "$INTEL_FILE" 2>/dev/null || echo "0")
+
+  # Get learning parameters
+  LR=$(jq -r '.config.learningRate // 0.1' "$INTEL_FILE" 2>/dev/null || echo "0.1")
+  EPS=$(jq -r '.config.epsilon // 0.1' "$INTEL_FILE" 2>/dev/null || echo "0.1")
+  [ -z "$LR" ] || [ "$LR" = "null" ] && LR="0.1"
+  [ -z "$EPS" ] || [ "$EPS" = "null" ] && EPS="0.1"
+  LEARNING_RATE=$(awk "BEGIN {printf \"%.0f\", $LR * 100}" 2>/dev/null || echo "10")
+  EPSILON=$(awk "BEGIN {printf \"%.0f\", $EPS * 100}" 2>/dev/null || echo "10")
+
+  # Get active count
+  ACTIVE=$(jq -r '[.trajectories // {} | to_entries[] | select(.value.status == "active")] | length' "$INTEL_FILE" 2>/dev/null || echo "0")
+fi
+
+# Attention mechanism status (check which are enabled)
+NEURAL="●Neural"
+DAG="◐DAG"
+GRAPH="○Graph"
+SSM="●SSM"
+
+# Check DB for vector count
+VECTOR_COUNT=0
+if [ -f "$INTEL_DB" ]; then
+  VECTOR_COUNT=$(sqlite3 "$INTEL_DB" "SELECT COUNT(*) FROM vectors;" 2>/dev/null || echo "0")
+fi
+
+# Build output
+OUTPUT=""
+
+# Line 1: Model + Project + Branch
+OUTPUT="Opus 4.5 in agentic-flow"
+if [ -n "$GIT_BRANCH" ]; then
+  OUTPUT="${OUTPUT} on ⎇ ${GIT_BRANCH}"
+fi
+
+# Line 2: Agentic Flow metrics
+OUTPUT="${OUTPUT}\n🧠 Agentic Flow ◆ ${PATTERNS} patterns ⬡ ${MEMORIES} mem ↝${ROUTES} #${TRAJECTORIES}"
+
+# Line 3: Agent routing/learning metrics
+OUTPUT="${OUTPUT}\n🎯 Agent Routing q-learning lr:${LEARNING_RATE}% ε:${EPSILON}%"
+
+# Line 4: Swarm coordination mechanisms
+OUTPUT="${OUTPUT}\n⚡ Swarm: ●Neural ◐DAG ○Graph ●SSM"
+
+printf "%b\n" "$OUTPUT"