moflo 4.7.8 → 4.8.1

package/src/@claude-flow/cli/dist/src/services/daemon-lock.js

@@ -0,0 +1,213 @@
+/**
+ * Atomic daemon lock — prevents duplicate daemon processes.
+ *
+ * Uses fs.writeFileSync with { flag: 'wx' } (O_CREAT | O_EXCL) which is
+ * atomic on all platforms: the write fails immediately if the file exists,
+ * eliminating the TOCTOU race in the old PID-file approach.
+ *
+ * Also solves Windows PID recycling by storing a label in the lock payload
+ * and verifying the process command line before trusting a "live" PID.
+ */
+import * as fs from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+const LOCK_FILENAME = 'daemon.lock';
+const LOCK_LABEL = 'moflo-daemon';
+/** Resolve the lock file path for a project root. */
+export function lockPath(projectRoot) {
+    return join(projectRoot, '.claude-flow', LOCK_FILENAME);
+}
+/**
+ * Try to acquire the daemon lock atomically.
+ *
+ * @returns `{ acquired: true }` on success,
+ *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
+ */
+export function acquireDaemonLock(projectRoot, pid = process.pid) {
+    const lock = lockPath(projectRoot);
+    const stateDir = join(projectRoot, '.claude-flow');
+    // Ensure state directory exists
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }
+    const payload = {
+        pid,
+        startedAt: Date.now(),
+        label: LOCK_LABEL,
+    };
+    // Attempt 1: atomic exclusive create
+    const result = tryExclusiveWrite(lock, payload);
+    if (result === 'ok') {
+        return { acquired: true };
+    }
+    // File already exists — check if the holder is still a live daemon
+    const existing = readLockPayload(lock);
+    if (!existing) {
+        // Corrupt or unreadable — remove and retry once
+        safeUnlink(lock);
+        return tryExclusiveWrite(lock, payload) === 'ok'
+            ? { acquired: true }
+            : { acquired: false, holder: -1 };
+    }
+    // Same PID as us? We already hold it (re-entrant).
+    if (existing.pid === pid) {
+        return { acquired: true };
+    }
+    // Is the process alive AND actually a moflo daemon?
+    if (isProcessAlive(existing.pid) && isDaemonProcess(existing.pid)) {
+        return { acquired: false, holder: existing.pid };
+    }
+    // Stale lock (dead process or recycled PID) — remove and retry once
+    safeUnlink(lock);
+    return tryExclusiveWrite(lock, payload) === 'ok'
+        ? { acquired: true }
+        : { acquired: false, holder: -1 };
+}
+/**
+ * Release the daemon lock. Only removes if we own it (or force = true).
+ */
+export function releaseDaemonLock(projectRoot, pid = process.pid, force = false) {
+    const lock = lockPath(projectRoot);
+    if (!fs.existsSync(lock))
+        return;
+    if (force) {
+        safeUnlink(lock);
+        return;
+    }
+    const existing = readLockPayload(lock);
+    if (existing && existing.pid === pid) {
+        safeUnlink(lock);
+    }
+}
+/**
+ * Check if the daemon lock is currently held by a live daemon.
+ * Returns the holder PID or null.
+ */
+export function getDaemonLockHolder(projectRoot) {
+    const lock = lockPath(projectRoot);
+    if (!fs.existsSync(lock))
+        return null;
+    const existing = readLockPayload(lock);
+    if (!existing) {
+        // Corrupt lock file — clean it up
+        safeUnlink(lock);
+        return null;
+    }
+    if (isProcessAlive(existing.pid) && isDaemonProcess(existing.pid)) {
+        return existing.pid;
+    }
+    // Stale — clean it up opportunistically
+    safeUnlink(lock);
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function tryExclusiveWrite(path, payload) {
+    try {
+        fs.writeFileSync(path, JSON.stringify(payload), { flag: 'wx' });
+        return 'ok';
+    }
+    catch (err) {
+        if (err.code === 'EEXIST')
+            return 'exists';
+        // Other errors (permissions, disk full) — treat as failure to acquire
+        return 'exists';
+    }
+}
+function readLockPayload(path) {
+    try {
+        const raw = fs.readFileSync(path, 'utf-8');
+        const data = JSON.parse(raw);
+        if (typeof data.pid === 'number' && typeof data.startedAt === 'number') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function safeUnlink(path) {
+    try {
+        fs.unlinkSync(path);
+    }
+    catch { /* ignore — file may already be gone */ }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Cross-platform check: is this PID actually a moflo/claude-flow daemon?
+ *
+ * This prevents false positives from Windows PID recycling, where a dead
+ * daemon's PID gets reused by an unrelated process (e.g. Chrome).
+ *
+ * - Windows: uses `tasklist /FI` to check the process image + command line
+ * - Linux:   reads /proc/<pid>/cmdline
+ * - macOS:   uses `ps -p <pid> -o command=`
+ *
+ * Falls back to `true` (trust process.kill) if the platform check fails,
+ * to avoid accidentally allowing duplicates on exotic platforms.
+ */
+function isDaemonProcess(pid) {
+    try {
+        if (process.platform === 'win32') {
+            return isDaemonProcessWindows(pid);
+        }
+        else if (process.platform === 'linux') {
+            return isDaemonProcessLinux(pid);
+        }
+        else {
+            // macOS and others
+            return isDaemonProcessUnix(pid);
+        }
+    }
+    catch {
+        // If platform check fails, trust the kill(0) result to avoid
+        // accidentally allowing duplicates
+        return true;
+    }
+}
+function isDaemonProcessWindows(pid) {
+    try {
+        const result = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: 'utf-8', timeout: 3000, windowsHide: true });
+        // tasklist returns the image name + PID in CSV; check it's a node process
+        // and then verify via wmic/powershell that the command line contains daemon keywords
+        if (!result.includes('node'))
+            return false;
+        const cmdResult = execSync(`powershell -NoProfile -Command "(Get-CimInstance Win32_Process -Filter \\"ProcessId=${pid}\\").CommandLine"`, { encoding: 'utf-8', timeout: 5000, windowsHide: true });
+        return /daemon\s+start|moflo|claude-flow/i.test(cmdResult);
+    }
+    catch {
+        return true; // fallback: trust kill(0)
+    }
+}
+function isDaemonProcessLinux(pid) {
+    try {
+        const cmdline = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf-8');
+        return /daemon.*start|moflo|claude-flow/i.test(cmdline);
+    }
+    catch {
+        return true; // fallback
+    }
+}
+function isDaemonProcessUnix(pid) {
+    try {
+        const result = execSync(`ps -p ${pid} -o command=`, {
+            encoding: 'utf-8',
+            timeout: 3000,
+        });
+        return /daemon.*start|moflo|claude-flow/i.test(result);
+    }
+    catch {
+        return true; // fallback
+    }
+}
+//# sourceMappingURL=daemon-lock.js.map

package/src/@claude-flow/cli/dist/src/services/learning-service.js

@@ -14,6 +14,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { mofloImport } from './moflo-require.js';
 // ============================================================================
 // Configuration
 // ============================================================================
@@ -210,7 +211,7 @@ class HNSWIndex {
 }
 async function loadSqlJs() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const initSqlJs = (await import('sql.js')).default;
+    const initSqlJs = (await mofloImport('sql.js')).default;
     return initSqlJs();
 }
 function dbAll(db, sql, params = []) {

package/src/@claude-flow/cli/dist/src/services/moflo-require.d.ts

@@ -0,0 +1,34 @@
+/**
+ * moflo-require — Resolve moflo's own dependencies from its own node_modules.
+ *
+ * When moflo runs via `npx` in a consuming project, bare `await import('sql.js')`
+ * resolves from the *consuming project's* node_modules, not moflo's.  Since moflo
+ * ships these dependencies itself, we always resolve from moflo's own context first
+ * and only fall back to a bare import as a last resort.
+ *
+ * Usage:
+ *   import { mofloImport } from '../services/moflo-require.js';
+ *   const sqlJs = await mofloImport('sql.js');
+ *   const transformers = await mofloImport('@xenova/transformers');
+ */
+/**
+ * Dynamically import a package, resolving from moflo's own node_modules first.
+ * Falls back to bare import only if local resolution fails (e.g. monorepo hoisting).
+ *
+ * On Windows, `createRequire.resolve()` returns a native path (C:\...) which
+ * `import()` rejects — it requires a file:// URL.  We convert via pathToFileURL.
+ *
+ * @param specifier  Package specifier, e.g. 'sql.js' or '@xenova/transformers'
+ * @returns          The imported module, or null if not available
+ */
+export declare function mofloImport(specifier: string): Promise<any>;
+/**
+ * Like mofloImport but throws if the package is not found (for required deps).
+ */
+export declare function mofloImportRequired(specifier: string): Promise<any>;
+/**
+ * Resolve a package path without importing (useful for WASM file paths etc).
+ * Returns the resolved path, or null if not found.
+ */
+export declare function mofloResolve(specifier: string): string | null;
+//# sourceMappingURL=moflo-require.d.ts.map

package/src/@claude-flow/cli/dist/src/services/moflo-require.js

@@ -0,0 +1,67 @@
+/**
+ * moflo-require — Resolve moflo's own dependencies from its own node_modules.
+ *
+ * When moflo runs via `npx` in a consuming project, bare `await import('sql.js')`
+ * resolves from the *consuming project's* node_modules, not moflo's.  Since moflo
+ * ships these dependencies itself, we always resolve from moflo's own context first
+ * and only fall back to a bare import as a last resort.
+ *
+ * Usage:
+ *   import { mofloImport } from '../services/moflo-require.js';
+ *   const sqlJs = await mofloImport('sql.js');
+ *   const transformers = await mofloImport('@xenova/transformers');
+ */
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+// createRequire anchored to this file — resolves from moflo's own node_modules
+const mofloRequire = createRequire(fileURLToPath(import.meta.url));
+/**
+ * Dynamically import a package, resolving from moflo's own node_modules first.
+ * Falls back to bare import only if local resolution fails (e.g. monorepo hoisting).
+ *
+ * On Windows, `createRequire.resolve()` returns a native path (C:\...) which
+ * `import()` rejects — it requires a file:// URL.  We convert via pathToFileURL.
+ *
+ * @param specifier  Package specifier, e.g. 'sql.js' or '@xenova/transformers'
+ * @returns          The imported module, or null if not available
+ */
+export async function mofloImport(specifier) {
+    try {
+        const resolved = mofloRequire.resolve(specifier);
+        // Convert native path → file:// URL (required on Windows for ESM import())
+        const url = pathToFileURL(resolved).href;
+        return await import(url);
+    }
+    catch {
+        // Local resolution failed — try bare import as last resort
+        try {
+            return await import(specifier);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Like mofloImport but throws if the package is not found (for required deps).
+ */
+export async function mofloImportRequired(specifier) {
+    const mod = await mofloImport(specifier);
+    if (mod === null) {
+        throw new Error(`Required dependency '${specifier}' not found in moflo's node_modules`);
+    }
+    return mod;
+}
+/**
+ * Resolve a package path without importing (useful for WASM file paths etc).
+ * Returns the resolved path, or null if not found.
+ */
+export function mofloResolve(specifier) {
+    try {
+        return mofloRequire.resolve(specifier);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=moflo-require.js.map

package/src/@claude-flow/cli/dist/src/services/ruvector-training.js

@@ -53,18 +53,20 @@ export async function initializeTraining(config = {}) {
     try {
         // Initialize MicroLoRA with direct WASM loading (Node.js compatible)
         const fs = await import('fs');
-        const { createRequire } = await import('module');
-        const require = createRequire(import.meta.url);
+        const { mofloResolve, mofloImportRequired } = await import('./moflo-require.js');
         // Load WASM file directly instead of using fetch
-        const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+        const wasmPath = mofloResolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+        if (!wasmPath)
+            throw new Error('@ruvector/learning-wasm not found');
         const wasmBuffer = fs.readFileSync(wasmPath);
-        const learningWasm = await import('@ruvector/learning-wasm');
+        const learningWasm = await mofloImportRequired('@ruvector/learning-wasm');
         learningWasm.initSync({ module: wasmBuffer });
         microLoRA = new learningWasm.WasmMicroLoRA(dim, alpha, lr);
         features.push(`MicroLoRA (${dim}-dim, <1μs adaptation)`);
         // Initialize ScopedLoRA for per-operator learning
-        scopedLoRA = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
-        scopedLoRA.set_category_fallback(true);
+        const scoped = new learningWasm.WasmScopedLoRA(dim, alpha, lr);
+        scoped.set_category_fallback(true);
+        scopedLoRA = scoped;
         features.push('ScopedLoRA (17 operators)');
         // Initialize trajectory buffer
         trajectoryBuffer = new learningWasm.WasmTrajectoryBuffer(config.trajectoryCapacity || 10000, dim);

package/src/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.7.8",
+  "version": "4.8.1",
   "type": "module",
   "description": "MoFlo CLI — AI agent orchestration with specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -88,12 +88,12 @@
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
-    "@claude-flow/aidefence": "^3.0.2",
-    "@claude-flow/embeddings": "^3.0.0-alpha.12",
-    "@claude-flow/guidance": "^3.0.0-alpha.1",
-    "@claude-flow/memory": "^3.0.0-alpha.11",
+    "@claude-flow/aidefence": "file:../aidefence",
+    "@claude-flow/embeddings": "file:../embeddings",
+    "@claude-flow/guidance": "file:../guidance",
+    "@claude-flow/memory": "file:../memory",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
-    "agentic-flow": "^3.0.0-alpha.1",
+    "agentic-flow": "^2.0.7",
     "@ruvector/attention": "^0.1.4",
     "@ruvector/learning-wasm": "^0.1.29",
     "@ruvector/router": "^0.1.27",

package/.claude/helpers/README.md

@@ -1,97 +0,0 @@
-# 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

@@ -1,186 +0,0 @@
-#!/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