moflo 4.7.7 → 4.8.0

package/src/@claude-flow/cli/dist/src/memory/memory-bridge.js

@@ -388,6 +388,9 @@ export async function bridgeStoreEntry(options) {
         await cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson });
         // Phase 4: AttestationLog write audit
         await logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson });
+        // Update statusline vector stats cache (debounced)
+        if (embeddingJson)
+            refreshVectorStatsCache();
         return {
             success: true,
             id,
@@ -690,6 +693,9 @@ export async function bridgeDeleteEntry(options) {
         catch {
             // Non-fatal
         }
+        // Update statusline vector stats cache (debounced)
+        if (changes > 0)
+            refreshVectorStatsCache();
         return {
             success: true,
             deleted: changes > 0,
@@ -1547,4 +1553,64 @@ function cosineSim(a, b) {
     const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
+// ===== Vector stats cache for statusline =====
+// Written after memory mutations so the statusline can read stats without
+// spawning a subprocess. Debounced to avoid thrashing during batch operations.
+/**
+ * Write vector-stats.json cache file used by the statusline.
+ * Synchronous — safe to call from short-lived CLI commands.
+ * Uses the already-initialized registry; no-ops if registry isn't loaded.
+ */
+export function refreshVectorStatsCache(dbPathOverride) {
+    try {
+        const registry = registryInstance; // Use existing instance only, don't init
+        if (!registry)
+            return;
+        const ctx = getDb(registry);
+        if (!ctx?.db)
+            return;
+        let vectorCount = 0;
+        let namespaces = 0;
+        let dbSizeKB = 0;
+        let hasHnsw = false;
+        try {
+            const countRow = ctx.db.prepare('SELECT COUNT(*) as c FROM memory_entries WHERE status = ? AND embedding IS NOT NULL').get('active');
+            vectorCount = countRow?.c ?? 0;
+            const nsRow = ctx.db.prepare('SELECT COUNT(DISTINCT namespace) as n FROM memory_entries WHERE status = ?').get('active');
+            namespaces = nsRow?.n ?? 0;
+        }
+        catch {
+            // Table may not exist yet
+        }
+        // DB file size
+        const dbFile = dbPathOverride || getDbPath();
+        try {
+            const stat = fs.statSync(dbFile);
+            dbSizeKB = Math.floor(stat.size / 1024);
+        }
+        catch { /* file may not exist */ }
+        // HNSW index presence
+        const root = getProjectRoot();
+        const hnswPaths = [
+            path.join(root, '.swarm', 'hnsw.index'),
+            path.join(root, '.claude-flow', 'hnsw.index'),
+        ];
+        for (const p of hnswPaths) {
+            try {
+                fs.statSync(p);
+                hasHnsw = true;
+                break;
+            }
+            catch { /* nope */ }
+        }
+        // Write cache file
+        const cacheDir = path.join(root, '.claude-flow');
+        if (!fs.existsSync(cacheDir))
+            fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(path.join(cacheDir, 'vector-stats.json'), JSON.stringify({ vectorCount, dbSizeKB, namespaces, hasHnsw, updatedAt: Date.now() }));
+    }
+    catch {
+        // Non-fatal — statusline falls back to file size estimate
+    }
+}
 //# sourceMappingURL=memory-bridge.js.map

package/src/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -10,6 +10,41 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+/**
+ * Write vector-stats.json cache for the statusline (no subprocess needed).
+ * Called after memory store/delete to keep the cache fresh.
+ * @param dbPath - path to the SQLite database file
+ * @param stats  - optional exact counts from a db query already in progress
+ */
+function writeVectorStatsCache(dbPath, stats) {
+    try {
+        const fileStat = fs.statSync(dbPath);
+        const dbSizeKB = Math.floor(fileStat.size / 1024);
+        const vectorCount = stats?.vectorCount ?? 0;
+        const namespaces = stats?.namespaces ?? 0;
+        // Check HNSW index presence
+        const dbDir = path.dirname(dbPath);
+        const projectDir = path.dirname(dbDir); // .swarm -> project root
+        let hasHnsw = false;
+        for (const p of [
+            path.join(dbDir, 'hnsw.index'),
+            path.join(projectDir, '.claude-flow', 'hnsw.index'),
+        ]) {
+            try {
+                fs.statSync(p);
+                hasHnsw = true;
+                break;
+            }
+            catch { /* nope */ }
+        }
+        // Write to .claude-flow dir next to the .swarm dir
+        const cacheDir = path.join(projectDir, '.claude-flow');
+        if (!fs.existsSync(cacheDir))
+            fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(path.join(cacheDir, 'vector-stats.json'), JSON.stringify({ vectorCount, dbSizeKB, namespaces, hasHnsw, updatedAt: Date.now() }));
+    }
+    catch { /* Non-fatal */ }
+}
 // ADR-053: Lazy import of AgentDB v3 bridge
 let _bridge;
 async function getBridge() {
@@ -1747,8 +1782,13 @@ export async function storeEntry(options) {
     const bridge = await getBridge();
     if (bridge) {
         const bridgeResult = await bridge.bridgeStoreEntry(options);
-        if (bridgeResult)
+        if (bridgeResult) {
+            // Update statusline cache after successful bridge store
+            const swarmDir = path.join(process.cwd(), '.swarm');
+            const dbFile = options.dbPath || path.join(swarmDir, 'memory.db');
+            writeVectorStatsCache(dbFile);
             return bridgeResult;
+        }
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
@@ -1805,6 +1845,15 @@ export async function storeEntry(options) {
         // Save
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
+        // Query exact stats while DB is still open
+        let vecCount = 0, nsCount = 0;
+        try {
+            const vc = db.exec("SELECT COUNT(*) FROM memory_entries WHERE status='active' AND embedding IS NOT NULL");
+            vecCount = vc[0]?.values?.[0]?.[0] ?? 0;
+            const nc = db.exec("SELECT COUNT(DISTINCT namespace) FROM memory_entries WHERE status='active'");
+            nsCount = nc[0]?.values?.[0]?.[0] ?? 0;
+        }
+        catch { /* table may not have status column in older DBs */ }
         db.close();
         // Add to HNSW index for faster future searches
         if (embeddingJson) {
@@ -1816,6 +1865,8 @@ export async function storeEntry(options) {
                 content: value
             });
         }
+        // Update statusline cache with exact counts
+        writeVectorStatsCache(dbPath, { vectorCount: vecCount, namespaces: nsCount });
         return {
             success: true,
             id,

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

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+export interface DaemonLockPayload {
+    pid: number;
+    startedAt: number;
+    label: string;
+}
+/** Resolve the lock file path for a project root. */
+export declare function lockPath(projectRoot: string): string;
+/**
+ * Try to acquire the daemon lock atomically.
+ *
+ * @returns `{ acquired: true }` on success,
+ *          `{ acquired: false, holder: pid }` if another daemon owns the lock.
+ */
+export declare function acquireDaemonLock(projectRoot: string, pid?: number): {
+    acquired: true;
+} | {
+    acquired: false;
+    holder: number;
+};
+/**
+ * Release the daemon lock. Only removes if we own it (or force = true).
+ */
+export declare function releaseDaemonLock(projectRoot: string, pid?: number, force?: boolean): void;
+/**
+ * Check if the daemon lock is currently held by a live daemon.
+ * Returns the holder PID or null.
+ */
+export declare function getDaemonLockHolder(projectRoot: string): number | null;
+//# sourceMappingURL=daemon-lock.d.ts.map

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.7.7",
+  "version": "4.8.0",
   "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",
@@ -81,18 +81,14 @@
     "publish:all": "./scripts/publish.sh"
   },
   "devDependencies": {
-    "typescript": "^5.3.0",
-    "vitest": "^4.0.16"
+    "typescript": "^5.3.0"
   },
   "dependencies": {
-    "@claude-flow/mcp": "^3.0.0-alpha.8",
-    "@claude-flow/shared": "^3.0.0-alpha.1",
     "@noble/ed25519": "^2.1.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "@claude-flow/aidefence": "^3.0.2",
-    "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.12",
     "@claude-flow/guidance": "^3.0.0-alpha.1",
     "@claude-flow/memory": "^3.0.0-alpha.11",

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