odd-flow 1.0.0

package/.claude/config/v3-performance-targets.json

@@ -0,0 +1,251 @@
+{
+  "v3PerformanceTargets": {
+    "version": "3.0.0",
+    "strategy": "phased_rollout",
+    "totalPhases": 4,
+    "riskMitigation": "progressive_targets",
+
+    "phases": {
+      "phase1": {
+        "name": "Security Foundation",
+        "duration": "weeks 1-3",
+        "description": "Conservative targets while establishing security baseline",
+        "targets": {
+          "flashAttention": {
+            "target": "2.49x minimum",
+            "description": "Conservative start, focus on stability",
+            "measurement": "baseline vs flash attention speedup",
+            "priority": "medium"
+          },
+          "searchImprovement": {
+            "target": "150x minimum",
+            "description": "Basic HNSW implementation",
+            "measurement": "vector search latency improvement",
+            "priority": "high"
+          },
+          "memoryReduction": {
+            "target": "40%",
+            "description": "Initial optimization, achievable target",
+            "measurement": "heap usage reduction",
+            "priority": "medium"
+          },
+          "startupTime": {
+            "target": "<750ms",
+            "description": "Less aggressive than final target",
+            "measurement": "CLI cold start time",
+            "priority": "high"
+          },
+          "securityScore": {
+            "target": "75/100",
+            "description": "Significant security improvement",
+            "measurement": "npm audit + custom security scans",
+            "priority": "critical"
+          }
+        },
+        "gates": {
+          "required": ["securityScore", "startupTime"],
+          "optional": ["flashAttention", "memoryReduction"]
+        }
+      },
+
+      "phase2": {
+        "name": "Core Systems Optimization",
+        "duration": "weeks 4-8",
+        "description": "Mid-range targets with core system optimizations",
+        "targets": {
+          "flashAttention": {
+            "target": "3.5x - 5.0x",
+            "description": "Mid-range optimization",
+            "measurement": "sequence processing speedup",
+            "priority": "high"
+          },
+          "searchImprovement": {
+            "target": "500x - 2000x",
+            "description": "Optimized HNSW with tuning",
+            "measurement": "vector search performance",
+            "priority": "high"
+          },
+          "memoryReduction": {
+            "target": "50%",
+            "description": "Enhanced optimization techniques",
+            "measurement": "memory usage efficiency",
+            "priority": "medium"
+          },
+          "startupTime": {
+            "target": "<500ms",
+            "description": "Target achieved with optimization",
+            "measurement": "CLI startup latency",
+            "priority": "high"
+          },
+          "swarmCoordination": {
+            "target": "<100ms",
+            "description": "15-agent coordination latency",
+            "measurement": "swarm consensus time",
+            "priority": "high"
+          },
+          "agentSpawnTime": {
+            "target": "<200ms",
+            "description": "Individual agent spawn latency",
+            "measurement": "agent initialization time",
+            "priority": "medium"
+          }
+        },
+        "gates": {
+          "required": ["flashAttention", "searchImprovement", "startupTime"],
+          "optional": ["swarmCoordination", "agentSpawnTime"]
+        }
+      },
+
+      "phase3": {
+        "name": "Integration Excellence",
+        "duration": "weeks 9-12",
+        "description": "High-performance targets with full integration",
+        "targets": {
+          "flashAttention": {
+            "target": "5.0x - 7.47x",
+            "description": "Near-maximum optimization",
+            "measurement": "attention mechanism performance",
+            "priority": "high"
+          },
+          "searchImprovement": {
+            "target": "2000x - 12,500x",
+            "description": "Maximum performance achieved",
+            "measurement": "vector database performance",
+            "priority": "high"
+          },
+          "memoryReduction": {
+            "target": "65%",
+            "description": "Advanced compression techniques",
+            "measurement": "overall memory efficiency",
+            "priority": "medium"
+          },
+          "startupTime": {
+            "target": "<350ms",
+            "description": "Excellence target achieved",
+            "measurement": "optimized CLI performance",
+            "priority": "medium"
+          },
+          "mcpResponseTime": {
+            "target": "<100ms p95",
+            "description": "MCP server optimization",
+            "measurement": "MCP tool execution latency",
+            "priority": "high"
+          },
+          "learningAdaptation": {
+            "target": "<0.05ms",
+            "description": "SONA micro-LoRA adaptation",
+            "measurement": "learning cycle latency",
+            "priority": "medium"
+          }
+        },
+        "gates": {
+          "required": ["flashAttention", "searchImprovement", "mcpResponseTime"],
+          "optional": ["memoryReduction", "learningAdaptation"]
+        }
+      },
+
+      "phase4": {
+        "name": "Excellence & Polish",
+        "duration": "weeks 13-16",
+        "description": "Stretch targets and final optimization",
+        "targets": {
+          "flashAttention": {
+            "target": "7.47x",
+            "description": "Maximum theoretical speedup",
+            "measurement": "peak attention performance",
+            "priority": "stretch"
+          },
+          "searchImprovement": {
+            "target": "12,500x",
+            "description": "Peak HNSW performance",
+            "measurement": "optimal vector search",
+            "priority": "stretch"
+          },
+          "memoryReduction": {
+            "target": "75%",
+            "description": "Maximum memory efficiency",
+            "measurement": "peak memory optimization",
+            "priority": "stretch"
+          },
+          "startupTime": {
+            "target": "<300ms",
+            "description": "Sub-300ms cold start",
+            "measurement": "peak startup performance",
+            "priority": "stretch"
+          },
+          "overallThroughput": {
+            "target": "10x",
+            "description": "Overall system throughput",
+            "measurement": "end-to-end performance",
+            "priority": "high"
+          },
+          "reliabilityScore": {
+            "target": "99.9%",
+            "description": "Three nines reliability",
+            "measurement": "system uptime and stability",
+            "priority": "high"
+          }
+        },
+        "gates": {
+          "required": ["overallThroughput", "reliabilityScore"],
+          "optional": ["flashAttention", "searchImprovement", "memoryReduction"]
+        }
+      }
+    },
+
+    "monitoring": {
+      "frequency": "continuous",
+      "alerting": {
+        "regressionThreshold": "10%",
+        "criticalThreshold": "25%",
+        "notificationChannels": ["console", "metrics"]
+      },
+      "benchmarks": {
+        "automated": true,
+        "schedule": "daily",
+        "regressionDetection": true
+      }
+    },
+
+    "rollbackTriggers": [
+      "Security score drops below 70/100",
+      "Startup time exceeds 1000ms",
+      "Memory usage increases by >50%",
+      "Critical functionality broken",
+      "Performance regression >25%"
+    ],
+
+    "success_metrics": {
+      "phase1_success": {
+        "security_baseline": "Achieved 75/100 security score",
+        "stability": "No critical regressions",
+        "performance": "Baseline improvements established"
+      },
+      "phase2_success": {
+        "performance": "Mid-range targets achieved",
+        "coordination": "15-agent swarm operational",
+        "optimization": "Core systems optimized"
+      },
+      "phase3_success": {
+        "integration": "agentic-flow integration complete",
+        "performance": "High-performance targets met",
+        "features": "All v3 features operational"
+      },
+      "phase4_success": {
+        "excellence": "Stretch targets achieved where possible",
+        "reliability": "Production-ready stability",
+        "optimization": "Peak performance validated"
+      }
+    },
+
+    "adaptive_strategy": {
+      "enabled": true,
+      "description": "Targets adjust based on actual achievement rates",
+      "rules": {
+        "if_ahead_of_schedule": "Attempt next phase targets early",
+        "if_behind_schedule": "Focus on required gates, defer optional",
+        "if_critical_issues": "Halt advancement, focus on resolution"
+      }
+    }
+  }
+}

package/.claude/helpers/README.md

@@ -0,0 +1,97 @@
+# RuFlo V3 Helpers
+
+This directory contains helper scripts and utilities for V3 development.
+
+## 🚀 Quick Start
+
+```bash
+# Initialize V3 development environment
+.claude/helpers/v3.sh init
+
+# Quick status check
+.claude/helpers/v3.sh status
+
+# Update progress metrics
+.claude/helpers/v3.sh update domain 3
+.claude/helpers/v3.sh update agent 8
+.claude/helpers/v3.sh update security 2
+```
+
+## Available Helpers
+
+### 🎛️ V3 Master Tool
+- **`v3.sh`** - Main command-line interface for all V3 operations
+  ```bash
+  .claude/helpers/v3.sh help           # Show all commands
+  .claude/helpers/v3.sh status         # Quick development status
+  .claude/helpers/v3.sh update domain 3 # Update specific metrics
+  .claude/helpers/v3.sh validate       # Validate configuration
+  .claude/helpers/v3.sh full-status    # Complete status overview
+  ```
+
+### 📊 V3 Progress Management
+- **`update-v3-progress.sh`** - Update V3 development metrics
+  ```bash
+  # Usage examples:
+  .claude/helpers/update-v3-progress.sh domain 3      # Mark 3 domains complete
+  .claude/helpers/update-v3-progress.sh agent 8       # 8 agents active
+  .claude/helpers/update-v3-progress.sh security 2    # 2 CVEs fixed
+  .claude/helpers/update-v3-progress.sh performance 2.5x # Performance boost
+  .claude/helpers/update-v3-progress.sh status        # Show current status
+  ```
+
+### 🔍 Configuration Validation
+- **`validate-v3-config.sh`** - Comprehensive environment validation
+  - Checks all required directories and files
+  - Validates JSON configuration files
+  - Verifies Node.js and development tools
+  - Confirms Git repository status
+  - Validates file permissions
+
+### ⚡ Quick Status
+- **`v3-quick-status.sh`** - Compact development progress overview
+  - Shows domain, agent, and DDD progress
+  - Displays security and performance metrics
+  - Color-coded status indicators
+  - Current Git branch information
+
+## Helper Script Standards
+
+### File Naming
+- Use kebab-case: `update-v3-progress.sh`
+- Include version prefix: `v3-*` for V3-specific helpers
+- Use descriptive names that indicate purpose
+
+### Script Requirements
+- Must be executable (`chmod +x`)
+- Include proper error handling (`set -e`)
+- Provide usage help when called without arguments
+- Use consistent exit codes (0 = success, non-zero = error)
+
+### Configuration Integration
+Helpers are configured in `.claude/settings.json`:
+```json
+{
+  "helpers": {
+    "directory": ".claude/helpers",
+    "enabled": true,
+    "v3ProgressUpdater": ".claude/helpers/update-v3-progress.sh"
+  }
+}
+```
+
+## Development Guidelines
+
+1. **Security First**: All helpers must validate inputs
+2. **Idempotent**: Scripts should be safe to run multiple times
+3. **Fast Execution**: Keep helper execution under 1 second when possible
+4. **Clear Output**: Provide clear success/error messages
+5. **JSON Safe**: When updating JSON files, use `jq` for safety
+
+## Adding New Helpers
+
+1. Create script in `.claude/helpers/`
+2. Make executable: `chmod +x script-name.sh`
+3. Add to settings.json helpers section
+4. Test thoroughly before committing
+5. Update this README with usage documentation

package/.claude/helpers/adr-compliance.sh

@@ -0,0 +1,186 @@
+#!/bin/bash
+# RuFlo V3 - ADR Compliance Checker Worker
+# Checks compliance with Architecture Decision Records
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+METRICS_DIR="$PROJECT_ROOT/.claude-flow/metrics"
+ADR_FILE="$METRICS_DIR/adr-compliance.json"
+LAST_RUN_FILE="$METRICS_DIR/.adr-last-run"
+
+mkdir -p "$METRICS_DIR"
+
+# V3 ADRs to check
+declare -A ADRS=(
+  ["ADR-001"]="agentic-flow as core foundation"
+  ["ADR-002"]="Domain-Driven Design structure"
+  ["ADR-003"]="Single coordination engine"
+  ["ADR-004"]="Plugin-based architecture"
+  ["ADR-005"]="MCP-first API design"
+  ["ADR-006"]="Unified memory service"
+  ["ADR-007"]="Event sourcing for state"
+  ["ADR-008"]="Vitest over Jest"
+  ["ADR-009"]="Hybrid memory backend"
+  ["ADR-010"]="Remove Deno support"
+)
+
+should_run() {
+  if [ ! -f "$LAST_RUN_FILE" ]; then return 0; fi
+  local last_run=$(cat "$LAST_RUN_FILE" 2>/dev/null || echo "0")
+  local now=$(date +%s)
+  [ $((now - last_run)) -ge 900 ]  # 15 minutes
+}
+
+check_adr_001() {
+  # ADR-001: agentic-flow as core foundation
+  local score=0
+
+  # Check package.json for agentic-flow dependency
+  grep -q "agentic-flow" "$PROJECT_ROOT/package.json" 2>/dev/null && score=$((score + 50))
+
+  # Check for imports from agentic-flow
+  local imports=$(grep -r "from.*agentic-flow\|require.*agentic-flow" "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" 2>/dev/null | grep -v node_modules | wc -l)
+  [ "$imports" -gt 5 ] && score=$((score + 50))
+
+  echo "$score"
+}
+
+check_adr_002() {
+  # ADR-002: Domain-Driven Design structure
+  local score=0
+
+  # Check for domain directories
+  [ -d "$PROJECT_ROOT/v3" ] || [ -d "$PROJECT_ROOT/src/domains" ] && score=$((score + 30))
+
+  # Check for bounded contexts
+  local contexts=$(find "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" -type d -name "domain" 2>/dev/null | wc -l)
+  [ "$contexts" -gt 0 ] && score=$((score + 35))
+
+  # Check for anti-corruption layers
+  local acl=$(grep -r "AntiCorruption\|Adapter\|Port" "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" 2>/dev/null | grep -v node_modules | wc -l)
+  [ "$acl" -gt 0 ] && score=$((score + 35))
+
+  echo "$score"
+}
+
+check_adr_003() {
+  # ADR-003: Single coordination engine
+  local score=0
+
+  # Check for unified SwarmCoordinator
+  grep -rq "SwarmCoordinator\|UnifiedCoordinator" "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" 2>/dev/null && score=$((score + 50))
+
+  # Check for no duplicate coordinators
+  local coordinators=$(grep -r "class.*Coordinator" "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" 2>/dev/null | grep -v node_modules | grep -v ".test." | wc -l)
+  [ "$coordinators" -le 3 ] && score=$((score + 50))
+
+  echo "$score"
+}
+
+check_adr_005() {
+  # ADR-005: MCP-first API design
+  local score=0
+
+  # Check for MCP server implementation
+  [ -d "$PROJECT_ROOT/v3/@claude-flow/mcp" ] && score=$((score + 40))
+
+  # Check for MCP tools
+  local tools=$(grep -r "tool.*name\|registerTool" "$PROJECT_ROOT/v3" 2>/dev/null | wc -l)
+  [ "$tools" -gt 5 ] && score=$((score + 30))
+
+  # Check for MCP schemas
+  grep -rq "schema\|jsonSchema" "$PROJECT_ROOT/v3/@claude-flow/mcp" 2>/dev/null && score=$((score + 30))
+
+  echo "$score"
+}
+
+check_adr_008() {
+  # ADR-008: Vitest over Jest
+  local score=0
+
+  # Check for vitest in package.json
+  grep -q "vitest" "$PROJECT_ROOT/package.json" 2>/dev/null && score=$((score + 50))
+
+  # Check for no jest references
+  local jest_refs=$(grep -r "from.*jest\|jest\." "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" 2>/dev/null | grep -v node_modules | grep -v "vitest" | wc -l)
+  [ "$jest_refs" -eq 0 ] && score=$((score + 50))
+
+  echo "$score"
+}
+
+check_compliance() {
+  echo "[$(date +%H:%M:%S)] Checking ADR compliance..."
+
+  local total_score=0
+  local compliant_count=0
+  local results=""
+
+  # Check each ADR
+  local adr_001=$(check_adr_001)
+  local adr_002=$(check_adr_002)
+  local adr_003=$(check_adr_003)
+  local adr_005=$(check_adr_005)
+  local adr_008=$(check_adr_008)
+
+  # Simple checks for others (assume partial compliance)
+  local adr_004=50  # Plugin architecture
+  local adr_006=50  # Unified memory
+  local adr_007=50  # Event sourcing
+  local adr_009=75  # Hybrid memory
+  local adr_010=100 # No Deno (easy to verify)
+
+  # Calculate totals
+  for score in $adr_001 $adr_002 $adr_003 $adr_004 $adr_005 $adr_006 $adr_007 $adr_008 $adr_009 $adr_010; do
+    total_score=$((total_score + score))
+    [ "$score" -ge 50 ] && compliant_count=$((compliant_count + 1))
+  done
+
+  local avg_score=$((total_score / 10))
+
+  # Write ADR compliance metrics
+  cat > "$ADR_FILE" << EOF
+{
+  "timestamp": "$(date -Iseconds)",
+  "overallCompliance": $avg_score,
+  "compliantCount": $compliant_count,
+  "totalADRs": 10,
+  "adrs": {
+    "ADR-001": {"score": $adr_001, "title": "agentic-flow as core foundation"},
+    "ADR-002": {"score": $adr_002, "title": "Domain-Driven Design structure"},
+    "ADR-003": {"score": $adr_003, "title": "Single coordination engine"},
+    "ADR-004": {"score": $adr_004, "title": "Plugin-based architecture"},
+    "ADR-005": {"score": $adr_005, "title": "MCP-first API design"},
+    "ADR-006": {"score": $adr_006, "title": "Unified memory service"},
+    "ADR-007": {"score": $adr_007, "title": "Event sourcing for state"},
+    "ADR-008": {"score": $adr_008, "title": "Vitest over Jest"},
+    "ADR-009": {"score": $adr_009, "title": "Hybrid memory backend"},
+    "ADR-010": {"score": $adr_010, "title": "Remove Deno support"}
+  }
+}
+EOF
+
+  echo "[$(date +%H:%M:%S)] ✓ ADR Compliance: ${avg_score}% | Compliant: $compliant_count/10"
+
+  date +%s > "$LAST_RUN_FILE"
+}
+
+case "${1:-check}" in
+  "run") check_compliance ;;
+  "check") should_run && check_compliance || echo "[$(date +%H:%M:%S)] Skipping (throttled)" ;;
+  "force") rm -f "$LAST_RUN_FILE"; check_compliance ;;
+  "status")
+    if [ -f "$ADR_FILE" ]; then
+      jq -r '"Compliance: \(.overallCompliance)% | Compliant: \(.compliantCount)/\(.totalADRs)"' "$ADR_FILE"
+    else
+      echo "No ADR data available"
+    fi
+    ;;
+  "details")
+    if [ -f "$ADR_FILE" ]; then
+      jq -r '.adrs | to_entries[] | "\(.key): \(.value.score)% - \(.value.title)"' "$ADR_FILE"
+    fi
+    ;;
+  *) echo "Usage: $0 [run|check|force|status|details]" ;;
+esac

package/.claude/helpers/aggressive-microcompact.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Aggressive Micro-Compaction Preload
+ *
+ * Claude Code's micro-compaction (Vd function) only prunes old tool results
+ * when context is above the warning threshold (~80%) and only if it can save
+ * at least 20K tokens. These hardcoded thresholds mean context can grow large
+ * before any pruning happens.
+ *
+ * This script patches the environment to make micro-compaction more aggressive
+ * by lowering the threshold at which it activates. It works by setting
+ * CLAUDE_AUTOCOMPACT_PCT_OVERRIDE to trigger compaction earlier if micro-compaction
+ * isn't enough, but the real win is keeping context lean through early pruning.
+ *
+ * The micro-compact function Vd() works like this:
+ *   1. Collects all tool results from: Read, Bash, Grep, Glob, WebSearch, WebFetch, Edit, Write
+ *   2. Keeps the last 3 tool results intact (Ly5=3)
+ *   3. If total tool result tokens > 40K (Ny5) AND context is above warning threshold:
+ *      - Replaces old results with "[Old tool result content cleared]"
+ *      - Only if savings >= 20K tokens (qy5)
+ *   4. This runs on EVERY query — it IS automatic pruning
+ *
+ * The problem: Ny5=40000 and qy5=20000 are hardcoded. We can't change them.
+ * The solution: Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50 so the warning/error
+ * thresholds drop, which makes micro-compaction activate much earlier.
+ */
+
+// This file is sourced by settings.json hooks to document the strategy.
+// The actual configuration is in settings.json env vars:
+//   CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50  → lowers all thresholds
+//   autoCompactEnabled=true             → enables the auto-compact fallback
+
+console.log('[AggressiveMicrocompact] Strategy: CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=50');
+console.log('[AggressiveMicrocompact] Micro-compact activates when tokens > warning threshold');
+console.log('[AggressiveMicrocompact] Warning threshold = maxTokens - 20K (relative to override)');
+console.log('[AggressiveMicrocompact] Effect: pruning starts at ~45% instead of ~80%');