claude-flow 3.5.81 → 3.5.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.81",
+  "version": "3.5.82",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/hooks.js

@@ -3365,14 +3365,14 @@ const statuslineCommand = {
             const isWindows = process.platform === 'win32';
             try {
                 const psCmd = isWindows
-                    ? 'tasklist /FI "IMAGENAME eq node.exe" 2>NUL | findstr /I /C:"node" >NUL && echo 1 || echo 0'
+                    ? 'tasklist /FI "IMAGENAME eq node.exe" /NH 2>NUL | find /c /v "" 2>NUL || echo 0'
                     : 'ps aux 2>/dev/null | grep -c agentic-flow || echo "0"';
-                const ps = execSync(psCmd, { encoding: 'utf-8' });
+                const ps = execSync(psCmd, { encoding: 'utf-8', timeout: 3000 });
                 activeAgents = Math.max(0, parseInt(ps.trim()) - 1);
                 coordinationActive = activeAgents > 0;
             }
             catch {
-                // Ignore
+                // ps/tasklist unavailable or timed out — report zero
             }
             return { activeAgents, maxAgents, coordinationActive };
         }

package/v3/@claude-flow/cli/dist/src/commands/init.js

@@ -344,13 +344,13 @@ const initAction = async (ctx) => {
             }
         }
         if (!startDaemon && !startAll) {
-            // Next steps (only if not auto-starting)
+            const bin = (process.argv[1] || '').includes('ruflo') ? 'ruflo' : 'claude-flow';
             output.writeln(output.bold('Next steps:'));
             output.printList([
-                `Run ${output.highlight('claude-flow daemon start')} to start background workers`,
-                `Run ${output.highlight('claude-flow memory init')} to initialize memory database`,
-                `Run ${output.highlight('claude-flow swarm init')} to initialize a swarm`,
-                `Or use ${output.highlight('claude-flow init --start-all')} to do all of the above`,
+                `Run ${output.highlight(`${bin} daemon start`)} to start background workers`,
+                `Run ${output.highlight(`${bin} memory init`)} to initialize memory database`,
+                `Run ${output.highlight(`${bin} swarm init`)} to initialize a swarm`,
+                `Or use ${output.highlight(`${bin} init --start-all`)} to do all of the above`,
                 options.components.settings ? `Review ${output.highlight('.claude/settings.json')} for hook configurations` : '',
             ].filter(Boolean));
         }

package/v3/@claude-flow/cli/dist/src/mcp-tools/guidance-tools.js

@@ -65,7 +65,7 @@ const CAPABILITY_CATALOG = {
     'memory-knowledge': {
         name: 'Memory & Knowledge',
         description: 'Persistent memory with HNSW vector search, AgentDB storage, and embeddings.',
-        tools: ['memory_store', 'memory_retrieve', 'memory_search', 'memory_list', 'memory_delete', 'memory_init', 'memory_export', 'memory_import', 'memory_stats', 'memory_compact', 'memory_namespace'],
+        tools: ['memory_store', 'memory_retrieve', 'memory_search', 'memory_list', 'memory_delete', 'memory_init', 'memory_export', 'memory_import_claude', 'memory_stats', 'memory_compact', 'memory_namespace'],
         commands: ['memory store', 'memory retrieve', 'memory search', 'memory list', 'memory delete', 'memory init'],
         agents: ['swarm-memory-manager', 'v3-memory-specialist'],
         skills: ['v3-memory-unification', 'agentdb-advanced', 'agentdb-vector-search', 'agentdb-memory-patterns', 'agentdb-learning'],

package/v3/@claude-flow/cli/dist/src/mcp-tools/hooks-tools.js

@@ -2196,6 +2196,21 @@ export const hooksTrajectoryStart = {
             startedAt,
         };
         activeTrajectories.set(trajectoryId, trajectory);
+        // Persist pending trajectory to disk so it survives MCP restarts
+        const storeFn = await getRealStoreFunction();
+        if (storeFn) {
+            try {
+                await storeFn({
+                    key: `trajectory-pending-${trajectoryId}`,
+                    value: JSON.stringify(trajectory),
+                    namespace: 'trajectories',
+                    tags: [agent, 'pending', 'sona-trajectory'],
+                });
+            }
+            catch {
+                // Best-effort persistence — trajectory still lives in-memory
+            }
+        }
         return {
             trajectoryId,
             task,
@@ -2607,8 +2622,19 @@ export const hooksIntelligenceStats = {
         const moe = await getMoERouter();
         const flash = await getFlashAttention();
         const lora = await getLoRAAdapter();
-        // Fallback to memory store for legacy data
-        const memoryStats = getIntelligenceStatsFromMemory();
+        // Fallback to memory store for legacy data (may not exist yet)
+        let memoryStats;
+        try {
+            memoryStats = getIntelligenceStatsFromMemory();
+        }
+        catch {
+            memoryStats = {
+                trajectories: { total: 0, successful: 0 },
+                patterns: { learned: 0, categories: {} },
+                memory: { indexSize: 0, totalAccessCount: 0, memorySizeBytes: 0 },
+                routing: { decisions: 0, avgConfidence: 0 },
+            };
+        }
         // SONA stats from real implementation
         let sonaStats = {
             trajectoriesTotal: memoryStats.trajectories.total,
@@ -3304,26 +3330,7 @@ export const hooksWorkerDispatch = {
             startedAt: new Date(),
         };
         activeWorkers.set(workerId, worker);
-        // Update worker progress in background
-        if (background) {
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 50;
-                    w.phase = 'processing';
-                }
-            }, 500);
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 100;
-                    w.phase = 'completed';
-                    w.status = 'completed';
-                    w.completedAt = new Date();
-                }
-            }, 1500);
-        }
-        else {
+        if (!background) {
             worker.progress = 100;
             worker.phase = 'completed';
             worker.status = 'completed';
@@ -3340,8 +3347,9 @@ export const hooksWorkerDispatch = {
                 estimatedDuration: config.estimatedDuration,
                 capabilities: config.capabilities,
             },
-            status: background ? 'dispatched' : 'completed',
+            status: background ? 'scheduled' : 'completed',
             background,
+            note: background ? 'Worker scheduled. Use hooks_worker-status to check progress. Start the daemon (daemon start) for real background execution.' : undefined,
             timestamp: new Date().toISOString(),
         };
     },

package/v3/@claude-flow/cli/dist/src/mcp-tools/neural-tools.js

@@ -251,6 +251,9 @@ export const neuralTools = [
                 totalPatterns: Object.keys(store.patterns).length,
                 epochs,
                 trainedAt: model.trainedAt,
+                ...(embeddingServiceName === 'hash-fallback' || embeddingServiceName === 'none' ? {
+                    platformNote: 'ONNX embeddings not available — using hash-based fallback. Install @claude-flow/embeddings and run "embeddings init --download" for semantic search.',
+                } : {}),
             };
         },
     },

package/v3/@claude-flow/cli/dist/src/mcp-tools/system-tools.js

@@ -284,11 +284,13 @@ export const systemTools = [
             const metrics = loadMetrics();
             const checks = [];
             const projectCwd = getProjectCwd();
-            // Memory DB check — verify the store file exists
+            // Memory DB check — verify any supported store file exists
             {
                 const t0 = performance.now();
-                const memoryDbPath = join(projectCwd, '.claude-flow', 'memory', 'store.json');
-                const memoryExists = existsSync(memoryDbPath);
+                const legacyPath = join(projectCwd, '.claude-flow', 'memory', 'store.json');
+                const agentDbPath = join(projectCwd, '.claude-flow', 'memory', 'agentdb.sqlite');
+                const rvfPath = join(projectCwd, '.claude-flow', 'memory', 'store.rvf');
+                const memoryExists = existsSync(legacyPath) || existsSync(agentDbPath) || existsSync(rvfPath);
                 const elapsed = performance.now() - t0;
                 checks.push({
                     name: 'memory',

package/v3/@claude-flow/cli/dist/src/mcp-tools/types.js

@@ -9,6 +9,10 @@
  * where process.cwd() may resolve to '/') over the real process.cwd().
  */
 export function getProjectCwd() {
-    return process.env.CLAUDE_FLOW_CWD || process.cwd();
+    const envCwd = process.env.CLAUDE_FLOW_CWD;
+    if (envCwd && envCwd !== '/' && envCwd !== process.env.HOME) {
+        return envCwd;
+    }
+    return process.cwd();
 }
 //# sourceMappingURL=types.js.map

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

@@ -78,13 +78,15 @@ async function getRegistry(dbPath) {
                         dbPath: dbPath || getDbPath(),
                         embeddingModel: 'Xenova/all-MiniLM-L6-v2',
                         dimension: 384,
+                        vectorBackend: 'auto',
                         controllers: {
                             reasoningBank: true,
                             learningBridge: false,
                             tieredCache: true,
                             hierarchicalMemory: true,
                             memoryConsolidation: true,
-                            memoryGraph: true, // issue #1214: enable MemoryGraph for graph-aware ranking
+                            memoryGraph: true,
+                            vectorBackend: true,
                         },
                     });
                 }

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

@@ -10,7 +10,7 @@
  * - testgaps: Test coverage analysis (20 min interval)
  */
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, unlinkSync, renameSync } from 'fs';
 import { cpus } from 'os';
 import { join } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
@@ -903,7 +903,9 @@ export class WorkerDaemon extends EventEmitter {
             savedAt: new Date().toISOString(),
         };
         try {
-            writeFileSync(this.config.stateFile, JSON.stringify(state, null, 2));
+            const tmpFile = this.config.stateFile + '.tmp';
+            writeFileSync(tmpFile, JSON.stringify(state, null, 2));
+            renameSync(tmpFile, this.config.stateFile);
         }
         catch (error) {
             this.log('error', `Failed to save state: ${error}`);

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.81",
+  "version": "3.5.82",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",