claude-flow 3.6.5 → 3.6.7

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"ea43bca2-cc37-44fb-97ff-f1c914a31fb1","pid":12017,"procStart":"Tue Apr 28 01:25:58 2026","acquiredAt":1777350938971}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.5",
+  "version": "3.6.7",
   "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/mcp-tools/browser-tools.js

@@ -8,47 +8,97 @@ import { validateIdentifier, validateText } from './validate-input.js';
 // Session registry for multi-session support
 const browserSessions = new Map();
 /**
- * Execute agent-browser CLI command
+ * Execute agent-browser CLI command.
+ * Tries global agent-browser first, falls back to npx if ENOENT.
  */
 async function execBrowserCommand(args, session = 'default') {
     const { execFileSync } = await import('child_process');
+    const fullArgs = ['--session', session, '--json', ...args];
+    let result;
     try {
-        const fullArgs = ['--session', session, '--json', ...args];
-        const result = execFileSync('agent-browser', fullArgs, {
+        result = execFileSync('agent-browser', fullArgs, {
             encoding: 'utf-8',
             timeout: 30000,
         });
-        let data;
-        try {
-            data = JSON.parse(result);
-        }
-        catch {
-            data = result.trim();
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            try {
+                result = execFileSync('npx', ['--yes', 'agent-browser', ...fullArgs], {
+                    encoding: 'utf-8',
+                    timeout: 60000,
+                });
+            }
+            catch (npxError) {
+                const npxErr = npxError;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: npxErr.code === 'ENOENT'
+                                    ? 'Neither agent-browser nor npx found. Install with: npm i -g agent-browser'
+                                    : npxErr instanceof Error ? npxErr.message : String(npxError),
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
         }
-        // Update session activity
-        const sessionInfo = browserSessions.get(session);
-        if (sessionInfo) {
-            sessionInfo.lastActivity = new Date().toISOString();
+        else {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: err instanceof Error ? err.message : String(error),
+                        }),
+                    }],
+                isError: true,
+            };
         }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(data, null, 2),
-                }],
-        };
     }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    }),
-                }],
-            isError: true,
-        };
+    let data;
+    try {
+        data = JSON.parse(result);
     }
+    catch {
+        data = result.trim();
+    }
+    const sessionInfo = browserSessions.get(session);
+    if (sessionInfo) {
+        sessionInfo.lastActivity = new Date().toISOString();
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(data, null, 2),
+            }],
+    };
+}
+/**
+ * Read a sysctl value, returning the trimmed string or null.
+ */
+function readSysctl(name) {
+    try {
+        const { readFileSync, existsSync } = require('fs');
+        const p = `/proc/sys/kernel/${name}`;
+        if (existsSync(p))
+            return readFileSync(p, 'utf-8').trim();
+    }
+    catch { /* not Linux or can't read */ }
+    return null;
+}
+/**
+ * Detect if Linux needs --no-sandbox for Chrome.
+ * Checks both legacy userns flag and Ubuntu 24.04+ AppArmor restriction.
+ */
+function needsNoSandbox() {
+    if (process.platform !== 'linux')
+        return false;
+    return readSysctl('unprivileged_userns_clone') === '0' ||
+        readSysctl('apparmor_restrict_unprivileged_userns') === '1';
 }
 /**
  * Browser MCP Tools
@@ -72,6 +122,11 @@ export const browserTools = [
                     enum: ['load', 'domcontentloaded', 'networkidle'],
                     description: 'Wait condition',
                 },
+                args: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Additional Chrome launch args (e.g., ["--no-sandbox", "--disable-dev-shm-usage"])',
+                },
             },
             required: ['url'],
         },
@@ -85,9 +140,15 @@ export const browserTools = [
                     return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: vS.error }) }], isError: true };
             }
             const { url, session, waitUntil } = input;
+            const launchArgs = input.args || [];
+            if (needsNoSandbox() && !launchArgs.includes('--no-sandbox')) {
+                launchArgs.push('--no-sandbox');
+            }
             const args = ['open', url];
             if (waitUntil)
                 args.push('--wait-until', waitUntil);
+            if (launchArgs.length > 0)
+                args.push('--args', launchArgs.join(' '));
             // Create session if new
             const sessionId = session || 'default';
             if (!browserSessions.has(sessionId)) {
@@ -369,13 +430,13 @@ export const browserTools = [
     },
     {
         name: 'browser_hover',
-        description: 'Hover over an element',
+        description: 'Hover over an element using ref (@e1) or CSS selector',
         category: 'browser',
         tags: ['interaction'],
         inputSchema: {
             type: 'object',
             properties: {
-                target: { type: 'string', description: 'Element ref or CSS selector' },
+                target: { type: 'string', description: 'Element ref (@e1) or CSS selector' },
                 session: { type: 'string', description: 'Session ID' },
             },
             required: ['target'],

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

@@ -412,7 +412,7 @@ export const embeddingsTools = [
                     query,
                     limit: topK,
                     threshold,
-                    namespace: namespace || 'default'
+                    namespace: namespace || 'all'
                 });
                 const searchTime = (performance.now() - startTime).toFixed(2);
                 return {
@@ -428,7 +428,7 @@ export const embeddingsTools = [
                         model: config.model,
                         topK,
                         threshold,
-                        namespace: namespace || 'default',
+                        namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                         resultCount: searchResult.results.length
@@ -446,7 +446,7 @@ export const embeddingsTools = [
                         model: config.model,
                         topK,
                         threshold,
-                        namespace: namespace || 'default',
+                        namespace: namespace || 'all',
                         searchTime: `${searchTime}ms`,
                         indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
                     },

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

@@ -405,4 +405,19 @@ export declare function bridgeContextSynthesize(params: {
 export declare function bridgeSemanticRoute(params: {
     input: string;
 }): Promise<any>;
+/**
+ * Export all embeddings from the bridge's better-sqlite3 connection.
+ * Used by RaBitQ to build its index from the same data that memory_store writes.
+ * Returns null if bridge is unavailable (caller falls back to sql.js).
+ */
+export declare function bridgeGetAllEmbeddings(options?: {
+    dimensions?: number;
+    limit?: number;
+    dbPath?: string;
+}): Promise<Array<{
+    id: string;
+    key: string;
+    namespace: string;
+    embedding: number[];
+}> | null>;
 //# sourceMappingURL=memory-bridge.d.ts.map

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

@@ -1554,6 +1554,51 @@ export async function bridgeSemanticRoute(params) {
         return { route: null, error: e.message };
     }
 }
+// ===== RaBitQ data export =====
+/**
+ * Export all embeddings from the bridge's better-sqlite3 connection.
+ * Used by RaBitQ to build its index from the same data that memory_store writes.
+ * Returns null if bridge is unavailable (caller falls back to sql.js).
+ */
+export async function bridgeGetAllEmbeddings(options) {
+    const registry = await getRegistry(options?.dbPath);
+    if (!registry)
+        return null;
+    const ctx = getDb(registry);
+    if (!ctx)
+        return null;
+    try {
+        const dims = options?.dimensions ?? 384;
+        const maxRows = options?.limit ?? 50000;
+        const rows = ctx.db.prepare(`
+      SELECT id, key, namespace, embedding
+      FROM memory_entries
+      WHERE status = 'active' AND embedding IS NOT NULL
+      LIMIT ?
+    `).all(maxRows);
+        const results = [];
+        for (const row of rows) {
+            if (!row.embedding)
+                continue;
+            try {
+                const emb = JSON.parse(row.embedding);
+                if (emb.length !== dims)
+                    continue;
+                results.push({
+                    id: String(row.id),
+                    key: row.key || String(row.id),
+                    namespace: row.namespace || 'default',
+                    embedding: emb,
+                });
+            }
+            catch { /* skip invalid */ }
+        }
+        return results;
+    }
+    catch {
+        return null;
+    }
+}
 // ===== Utility =====
 function cosineSim(a, b) {
     if (!a || !b || a.length === 0 || b.length === 0)

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

@@ -55,41 +55,57 @@ export async function buildRabitqIndex(options) {
         const dimensions = options?.dimensions ?? 384;
         const swarmDir = path.resolve(process.cwd(), '.swarm');
         const dbPath = options?.dbPath ? path.resolve(options.dbPath) : path.join(swarmDir, 'memory.db');
-        if (!fs.existsSync(dbPath)) {
-            rabitqInitializing = false;
-            return { success: false, vectorCount: 0, dimensions, compressionRatio: 0, buildTimeMs: 0, error: 'Database not found' };
-        }
-        // Load embeddings from SQLite
-        const initSqlJs = (await import('sql.js')).default;
-        const SQL = await initSqlJs();
-        const fileBuffer = fs.readFileSync(dbPath);
-        const db = new SQL.Database(fileBuffer);
-        const result = db.exec(`
-      SELECT id, key, namespace, embedding
-      FROM memory_entries
-      WHERE status = 'active' AND embedding IS NOT NULL
-      LIMIT 50000
-    `);
         const entries = [];
         const vectors = [];
-        if (result[0]?.values) {
-            for (const row of result[0].values) {
-                const [id, key, ns, embeddingJson] = row;
-                if (!embeddingJson)
-                    continue;
-                try {
-                    const embedding = JSON.parse(embeddingJson);
-                    if (embedding.length !== dimensions)
-                        continue;
-                    entries.push({ id: String(id), key: key || String(id), namespace: ns || 'default' });
-                    vectors.push(...embedding);
+        // Try bridge first (reads via better-sqlite3, sees WAL data)
+        let usedBridge = false;
+        try {
+            const { bridgeGetAllEmbeddings } = await import('./memory-bridge.js');
+            const bridgeRows = await bridgeGetAllEmbeddings({ dimensions, dbPath: options?.dbPath });
+            if (bridgeRows && bridgeRows.length > 0) {
+                for (const row of bridgeRows) {
+                    entries.push({ id: row.id, key: row.key, namespace: row.namespace });
+                    vectors.push(...row.embedding);
                 }
-                catch {
-                    // skip invalid
+                usedBridge = true;
+            }
+        }
+        catch { /* bridge unavailable, fall through */ }
+        // Fallback: read .swarm/memory.db via sql.js
+        if (!usedBridge) {
+            if (!fs.existsSync(dbPath)) {
+                rabitqInitializing = false;
+                return { success: false, vectorCount: 0, dimensions, compressionRatio: 0, buildTimeMs: 0, error: 'Database not found' };
+            }
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            const fileBuffer = fs.readFileSync(dbPath);
+            const db = new SQL.Database(fileBuffer);
+            const result = db.exec(`
+        SELECT id, key, namespace, embedding
+        FROM memory_entries
+        WHERE status = 'active' AND embedding IS NOT NULL
+        LIMIT 50000
+      `);
+            if (result[0]?.values) {
+                for (const row of result[0].values) {
+                    const [id, key, ns, embeddingJson] = row;
+                    if (!embeddingJson)
+                        continue;
+                    try {
+                        const embedding = JSON.parse(embeddingJson);
+                        if (embedding.length !== dimensions)
+                            continue;
+                        entries.push({ id: String(id), key: key || String(id), namespace: ns || 'default' });
+                        vectors.push(...embedding);
+                    }
+                    catch {
+                        // skip invalid
+                    }
                 }
             }
+            db.close();
         }
-        db.close();
         if (entries.length < 2) {
             rabitqInitializing = false;
             return { success: false, vectorCount: entries.length, dimensions, compressionRatio: 0, buildTimeMs: Date.now() - startTime, error: 'Need at least 2 vectors to build RaBitQ index' };

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.5",
+  "version": "3.6.7",
   "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",

package/v3/@claude-flow/guidance/dist/analyzer.js

@@ -336,11 +336,32 @@ function isContentAwareExecutor(executor) {
     return 'setContext' in executor && typeof executor.setContext === 'function';
 }
 class DefaultHeadlessExecutor {
+    contextContent = null;
+    setContext(claudeMdContent) {
+        this.contextContent = claudeMdContent;
+    }
     async execute(prompt, workDir) {
         const { execFile } = await import('node:child_process');
         const { promisify } = await import('node:util');
+        const fs = await import('node:fs/promises');
+        const { join } = await import('node:path');
         const execFileAsync = promisify(execFile);
-        // Pass prompt as a direct argument array — no shell interpretation.
+        const claudeMdPath = join(workDir, 'CLAUDE.md');
+        const backupPath = join(workDir, '.CLAUDE.md.ab-backup');
+        let swapped = false;
+        if (this.contextContent !== null) {
+            try {
+                await fs.copyFile(claudeMdPath, backupPath);
+            }
+            catch { /* no file to back up */ }
+            if (this.contextContent.length > 0) {
+                await fs.writeFile(claudeMdPath, this.contextContent, 'utf-8');
+            }
+            else {
+                await fs.unlink(claudeMdPath).catch(() => { });
+            }
+            swapped = true;
+        }
         try {
             const { stdout, stderr } = await execFileAsync('claude', ['-p', prompt, '--output-format', 'json'], { timeout: 60000, maxBuffer: 10 * 1024 * 1024, encoding: 'utf-8', cwd: workDir });
             return { stdout, stderr, exitCode: 0 };
@@ -348,6 +369,17 @@ class DefaultHeadlessExecutor {
         catch (error) {
             return { stdout: error.stdout ?? '', stderr: error.stderr ?? '', exitCode: error.code ?? 1 };
         }
+        finally {
+            if (swapped) {
+                try {
+                    await fs.copyFile(backupPath, claudeMdPath);
+                    await fs.unlink(backupPath);
+                }
+                catch {
+                    await fs.unlink(claudeMdPath).catch(() => { });
+                }
+            }
+        }
     }
 }
 function getDefaultBenchmarkTasks() {

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/guidance",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.2",
   "description": "Guidance Control Plane - Compiles, retrieves, enforces, and evolves guidance rules for Claude Code sessions",
   "type": "module",
   "main": "./dist/index.js",