claude-flow 3.5.74 → 3.5.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.74",
+  "version": "3.5.76",
   "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/embeddings.js

@@ -145,62 +145,87 @@ const searchCommand = {
             const queryResult = await generateEmbedding(query);
             const queryEmbedding = queryResult.embedding;
             // Get all entries with embeddings from database
-            const entries = db.exec(`
-        SELECT id, key, namespace, content, embedding, embedding_dimensions
-        FROM memory_entries
-        WHERE status = 'active'
-          AND embedding IS NOT NULL
-          ${namespace !== 'all' ? `AND namespace = '${namespace}'` : ''}
-        LIMIT 1000
-      `);
+            // Parameterized query to prevent SQL injection (CRIT-01)
+            const embeddingSql = namespace !== 'all'
+                ? `SELECT id, key, namespace, content, embedding, embedding_dimensions
+           FROM memory_entries
+           WHERE status = 'active' AND embedding IS NOT NULL AND namespace = ?
+           LIMIT 1000`
+                : `SELECT id, key, namespace, content, embedding, embedding_dimensions
+           FROM memory_entries
+           WHERE status = 'active' AND embedding IS NOT NULL
+           LIMIT 1000`;
+            const embeddingStmt = db.prepare(embeddingSql);
+            if (namespace !== 'all') {
+                embeddingStmt.bind([namespace]);
+            }
+            const entryRows = [];
+            while (embeddingStmt.step()) {
+                entryRows.push(embeddingStmt.get());
+            }
+            embeddingStmt.free();
             const results = [];
-            if (entries[0]?.values) {
-                for (const row of entries[0].values) {
-                    const [id, key, ns, content, embeddingJson] = row;
-                    if (!embeddingJson)
-                        continue;
-                    try {
-                        const embedding = JSON.parse(embeddingJson);
-                        // Calculate cosine similarity
-                        const similarity = cosineSimilarity(queryEmbedding, embedding);
-                        if (similarity >= threshold) {
-                            results.push({
-                                score: similarity,
-                                id: id.substring(0, 10),
-                                key: key || id.substring(0, 15),
-                                content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-                                namespace: ns || 'default'
-                            });
-                        }
-                    }
-                    catch {
-                        // Skip entries with invalid embeddings
+            for (const row of entryRows) {
+                const [id, key, ns, content, embeddingJson] = row;
+                if (!embeddingJson)
+                    continue;
+                try {
+                    const embedding = JSON.parse(embeddingJson);
+                    // Calculate cosine similarity
+                    const similarity = cosineSimilarity(queryEmbedding, embedding);
+                    if (similarity >= threshold) {
+                        results.push({
+                            score: similarity,
+                            id: id.substring(0, 10),
+                            key: key || id.substring(0, 15),
+                            content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
+                            namespace: ns || 'default'
+                        });
                     }
                 }
+                catch {
+                    // Skip entries with invalid embeddings
+                }
             }
-            // Also search entries without embeddings using keyword match
+            // Keyword search fallback with parameterized query (CRIT-01)
             if (results.length < limit) {
-                const keywordEntries = db.exec(`
-          SELECT id, key, namespace, content
-          FROM memory_entries
-          WHERE status = 'active'
-            AND (content LIKE '%${query.replace(/'/g, "''")}%' OR key LIKE '%${query.replace(/'/g, "''")}%')
-            ${namespace !== 'all' ? `AND namespace = '${namespace}'` : ''}
-          LIMIT ${limit - results.length}
-        `);
-                if (keywordEntries[0]?.values) {
-                    for (const row of keywordEntries[0].values) {
-                        const [id, key, ns, content] = row;
-                        // Avoid duplicates
-                        if (!results.some(r => r.id === id.substring(0, 10))) {
-                            results.push({
-                                score: 0.5, // Keyword match base score
-                                id: id.substring(0, 10),
-                                key: key || id.substring(0, 15),
-                                content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-                                namespace: ns || 'default'
-                            });
-                        }
+                const likePattern = `%${query}%`;
+                const remainingLimit = Math.max(0, limit - results.length);
+                const keywordSql = namespace !== 'all'
+                    ? `SELECT id, key, namespace, content
+             FROM memory_entries
+             WHERE status = 'active'
+               AND (content LIKE ? OR key LIKE ?)
+               AND namespace = ?
+             LIMIT ?`
+                    : `SELECT id, key, namespace, content
+             FROM memory_entries
+             WHERE status = 'active'
+               AND (content LIKE ? OR key LIKE ?)
+             LIMIT ?`;
+                const keywordStmt = db.prepare(keywordSql);
+                if (namespace !== 'all') {
+                    keywordStmt.bind([likePattern, likePattern, namespace, remainingLimit]);
+                }
+                else {
+                    keywordStmt.bind([likePattern, likePattern, remainingLimit]);
+                }
+                const keywordRows = [];
+                while (keywordStmt.step()) {
+                    keywordRows.push(keywordStmt.get());
+                }
+                keywordStmt.free();
+                for (const row of keywordRows) {
+                    const [id, key, ns, content] = row;
+                    // Avoid duplicates
+                    if (!results.some(r => r.id === id.substring(0, 10))) {
+                        results.push({
+                            score: 0.5, // Keyword match base score
+                            id: id.substring(0, 10),
+                            key: key || id.substring(0, 15),
+                            content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
+                            namespace: ns || 'default'
+                        });
                     }
                 }
             }

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

@@ -208,8 +208,10 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
                 claudeArgs.push('--verbose');
                 output.printInfo('Running in non-interactive mode');
             }
-            // Add auto-permission flag unless explicitly disabled
-            const skipPermissions = flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions'];
+            // HIGH-02: Strict boolean check (=== true) instead of loose truthiness (!== false)
+            // to prevent undefined/null from being treated as "skip permissions".
+            // Behavior change: only explicit --dangerously-skip-permissions flag triggers skip.
+            const skipPermissions = flags['dangerously-skip-permissions'] === true && !flags['no-auto-permissions'];
             if (skipPermissions) {
                 claudeArgs.push('--dangerously-skip-permissions');
                 if (!isNonInteractive) {

package/v3/@claude-flow/cli/dist/src/commands/index.d.ts

@@ -19,18 +19,6 @@ export { swarmCommand } from './swarm.js';
 export { memoryCommand } from './memory.js';
 export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
-export { daemonCommand } from './daemon.js';
-export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
-export { neuralCommand } from './neural.js';
-export { performanceCommand } from './performance.js';
-export { securityCommand } from './security.js';
-export { ruvectorCommand } from './ruvector/index.js';
-export { hiveMindCommand } from './hive-mind.js';
-export { guidanceCommand } from './guidance.js';
-export { applianceCommand } from './appliance.js';
-export { cleanupCommand } from './cleanup.js';
-export { autopilotCommand } from './autopilot.js';
 export declare function getConfigCommand(): Promise<Command | undefined>;
 export declare function getMigrateCommand(): Promise<Command | undefined>;
 export declare function getWorkflowCommand(): Promise<Command | undefined>;
@@ -62,7 +50,8 @@ export declare function getAutopilotCommand(): Promise<Command | undefined>;
  */
 export declare const commands: Command[];
 /**
- * Commands organized by category for help display
+ * Commands organized by category for help display (synchronous core only).
+ * @deprecated Use getCommandsByCategory() for full categorized listing.
  */
 export declare const commandsByCategory: {
     primary: Command[];
@@ -71,6 +60,11 @@ export declare const commandsByCategory: {
     analysis: Command[];
     management: Command[];
 };
+/**
+ * Async version that loads all commands by category (PERF-03).
+ * Use this for help display and full command listings.
+ */
+export declare function getCommandsByCategory(): Promise<Record<string, Command[]>>;
 /**
  * Command registry map for quick lookup
  * Supports both sync (core commands) and async (lazy-loaded) commands

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

@@ -99,6 +99,8 @@ async function loadCommand(name) {
 // Synchronous Imports for Core Commands (needed immediately at startup)
 // These are the most commonly used commands that need instant access
 // =============================================================================
+// PERF-03: Only import core commands synchronously (~10 most-used).
+// All other commands are lazy-loaded via commandLoaders on demand.
 import { initCommand } from './init.js';
 import { startCommand } from './start.js';
 import { statusCommand } from './status.js';
@@ -109,34 +111,7 @@ import { swarmCommand } from './swarm.js';
 import { memoryCommand } from './memory.js';
 import { mcpCommand } from './mcp.js';
 import { hooksCommand } from './hooks.js';
-import { daemonCommand } from './daemon.js';
-import { doctorCommand } from './doctor.js';
-import { embeddingsCommand } from './embeddings.js';
-import { neuralCommand } from './neural.js';
-import { performanceCommand } from './performance.js';
-import { securityCommand } from './security.js';
-import { ruvectorCommand } from './ruvector/index.js';
-import { hiveMindCommand } from './hive-mind.js';
-// Additional commands for categorized help display
-import { configCommand } from './config.js';
-import { completionsCommand } from './completions.js';
-import { migrateCommand } from './migrate.js';
-import { workflowCommand } from './workflow.js';
-import { analyzeCommand } from './analyze.js';
-import { routeCommand } from './route.js';
-import { progressCommand } from './progress.js';
-import { providersCommand } from './providers.js';
-import { pluginsCommand } from './plugins.js';
-import { deploymentCommand } from './deployment.js';
-import { claimsCommand } from './claims.js';
-import { issuesCommand } from './issues.js';
-import updateCommand from './update.js';
-import { processCommand } from './process.js';
-import { guidanceCommand } from './guidance.js';
-import { applianceCommand } from './appliance.js';
-import { cleanupCommand } from './cleanup.js';
-import { autopilotCommand } from './autopilot.js';
-// Pre-populate cache with core commands
+// Pre-populate cache with core commands only
 loadedCommands.set('init', initCommand);
 loadedCommands.set('start', startCommand);
 loadedCommands.set('status', statusCommand);
@@ -147,21 +122,10 @@ loadedCommands.set('swarm', swarmCommand);
 loadedCommands.set('memory', memoryCommand);
 loadedCommands.set('mcp', mcpCommand);
 loadedCommands.set('hooks', hooksCommand);
-loadedCommands.set('daemon', daemonCommand);
-loadedCommands.set('doctor', doctorCommand);
-loadedCommands.set('embeddings', embeddingsCommand);
-loadedCommands.set('neural', neuralCommand);
-loadedCommands.set('performance', performanceCommand);
-loadedCommands.set('security', securityCommand);
-loadedCommands.set('ruvector', ruvectorCommand);
-loadedCommands.set('hive-mind', hiveMindCommand);
-loadedCommands.set('guidance', guidanceCommand);
-loadedCommands.set('cleanup', cleanupCommand);
-loadedCommands.set('autopilot', autopilotCommand);
 // =============================================================================
 // Exports (maintain backwards compatibility)
 // =============================================================================
-// Export synchronously loaded commands
+// Export core commands (synchronous)
 export { initCommand } from './init.js';
 export { startCommand } from './start.js';
 export { statusCommand } from './status.js';
@@ -172,18 +136,6 @@ export { swarmCommand } from './swarm.js';
 export { memoryCommand } from './memory.js';
 export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
-export { daemonCommand } from './daemon.js';
-export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
-export { neuralCommand } from './neural.js';
-export { performanceCommand } from './performance.js';
-export { securityCommand } from './security.js';
-export { ruvectorCommand } from './ruvector/index.js';
-export { hiveMindCommand } from './hive-mind.js';
-export { guidanceCommand } from './guidance.js';
-export { applianceCommand } from './appliance.js';
-export { cleanupCommand } from './cleanup.js';
-export { autopilotCommand } from './autopilot.js';
 // Lazy-loaded command re-exports (for backwards compatibility, but async-only)
 export async function getConfigCommand() { return loadCommand('config'); }
 export async function getMigrateCommand() { return loadCommand('migrate'); }
@@ -215,7 +167,7 @@ export async function getAutopilotCommand() { return loadCommand('autopilot'); }
  * Advanced commands loaded on-demand for faster startup
  */
 export const commands = [
-    // Core commands (synchronously loaded)
+    // Core commands (synchronously loaded) — PERF-03
     initCommand,
     startCommand,
     statusCommand,
@@ -226,20 +178,10 @@ export const commands = [
     memoryCommand,
     mcpCommand,
     hooksCommand,
-    daemonCommand,
-    doctorCommand,
-    embeddingsCommand,
-    neuralCommand,
-    performanceCommand,
-    securityCommand,
-    ruvectorCommand,
-    hiveMindCommand,
-    guidanceCommand,
-    cleanupCommand,
-    autopilotCommand,
 ];
 /**
- * Commands organized by category for help display
+ * Commands organized by category for help display (synchronous core only).
+ * @deprecated Use getCommandsByCategory() for full categorized listing.
  */
 export const commandsByCategory = {
     primary: [
@@ -254,41 +196,48 @@ export const commandsByCategory = {
         mcpCommand,
         hooksCommand,
     ],
-    advanced: [
-        neuralCommand,
-        securityCommand,
-        performanceCommand,
-        embeddingsCommand,
-        hiveMindCommand,
-        ruvectorCommand,
-        guidanceCommand,
-        autopilotCommand,
-    ],
-    utility: [
-        configCommand,
-        doctorCommand,
-        daemonCommand,
-        completionsCommand,
-        migrateCommand,
-        workflowCommand,
-    ],
-    analysis: [
-        analyzeCommand,
-        routeCommand,
-        progressCommand,
-    ],
-    management: [
-        providersCommand,
-        pluginsCommand,
-        deploymentCommand,
-        claimsCommand,
-        issuesCommand,
-        updateCommand,
-        processCommand,
-        applianceCommand,
-        cleanupCommand,
-    ],
+    advanced: [],
+    utility: [],
+    analysis: [],
+    management: [],
 };
+/**
+ * Async version that loads all commands by category (PERF-03).
+ * Use this for help display and full command listings.
+ */
+export async function getCommandsByCategory() {
+    const [daemonCmd, doctorCmd, embeddingsCmd, neuralCmd, performanceCmd, securityCmd, ruvectorCmd, hiveMindCmd, configCmd, completionsCmd, migrateCmd, workflowCmd, analyzeCmd, routeCmd, progressCmd, providersCmd, pluginsCmd, deploymentCmd, claimsCmd, issuesCmd, updateCmd, processCmd, guidanceCmd, applianceCmd, cleanupCmd, autopilotCmd,] = await Promise.all([
+        loadCommand('daemon'), loadCommand('doctor'), loadCommand('embeddings'), loadCommand('neural'),
+        loadCommand('performance'), loadCommand('security'), loadCommand('ruvector'), loadCommand('hive-mind'),
+        loadCommand('config'), loadCommand('completions'), loadCommand('migrate'), loadCommand('workflow'),
+        loadCommand('analyze'), loadCommand('route'), loadCommand('progress'), loadCommand('providers'),
+        loadCommand('plugins'), loadCommand('deployment'), loadCommand('claims'), loadCommand('issues'),
+        loadCommand('update'), loadCommand('process'), loadCommand('guidance'), loadCommand('appliance'),
+        loadCommand('cleanup'), loadCommand('autopilot'),
+    ]);
+    return {
+        primary: [
+            initCommand, startCommand, statusCommand, agentCommand,
+            swarmCommand, memoryCommand, taskCommand, sessionCommand,
+            mcpCommand, hooksCommand,
+        ],
+        advanced: [
+            neuralCmd, securityCmd, performanceCmd, embeddingsCmd,
+            hiveMindCmd, ruvectorCmd, guidanceCmd, autopilotCmd,
+        ].filter(Boolean),
+        utility: [
+            configCmd, doctorCmd, daemonCmd, completionsCmd,
+            migrateCmd, workflowCmd,
+        ].filter(Boolean),
+        analysis: [
+            analyzeCmd, routeCmd, progressCmd,
+        ].filter(Boolean),
+        management: [
+            providersCmd, pluginsCmd, deploymentCmd, claimsCmd,
+            issuesCmd, updateCmd, processCmd, applianceCmd, cleanupCmd,
+        ].filter(Boolean),
+    };
+}
 /**
  * Command registry map for quick lookup
  * Supports both sync (core commands) and async (lazy-loaded) commands

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

@@ -319,14 +319,22 @@ const initAction = async (ctx) => {
         if (withEmbeddings) {
             output.writeln();
             output.printInfo('Initializing ONNX embedding subsystem...');
-            const { execSync } = await import('child_process');
+            const { execFileSync: execFileInit } = await import('child_process');
+            // Validate embeddingModel: must match pattern org/model-name (CRIT-02)
+            if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+$/.test(embeddingModel)) {
+                throw new Error(`Invalid embedding model name: ${embeddingModel}`);
+            }
             try {
                 output.writeln(output.dim(`  Model: ${embeddingModel}`));
                 output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
-                execSync(`npx @claude-flow/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
+                execFileInit('npx', [
+                    '@claude-flow/cli@latest', 'embeddings', 'init',
+                    '--model', embeddingModel,
+                    '--no-download', '--force',
+                ], {
                     stdio: 'pipe',
                     cwd: ctx.cwd,
-                    timeout: 30000
+                    timeout: 30000,
                 });
                 output.writeln(output.success('  ✓ Embeddings initialized'));
                 output.writeln(output.dim('    Run "embeddings init --download" to download model'));
@@ -546,12 +554,20 @@ const wizardCommand = {
             if (enableEmbeddings) {
                 output.writeln();
                 output.printInfo('Initializing ONNX embedding subsystem...');
-                const { execSync } = await import('child_process');
+                const { execFileSync } = await import('child_process');
+                // Validate embeddingModel: must match pattern org/model-name (CRIT-02)
+                if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+$/.test(embeddingModel)) {
+                    throw new Error(`Invalid embedding model name: ${embeddingModel}`);
+                }
                 try {
-                    execSync(`npx @claude-flow/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
+                    execFileSync('npx', [
+                        '@claude-flow/cli@latest', 'embeddings', 'init',
+                        '--model', embeddingModel,
+                        '--no-download', '--force',
+                    ], {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
-                        timeout: 30000
+                        timeout: 30000,
                     });
                     output.writeln(output.success('  ✓ Embeddings configured'));
                     embeddingsInitialized = true;

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

@@ -4,6 +4,7 @@
  */
 import { output } from '../../output.js';
 import { confirm, input } from '../../prompt.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Get PostgreSQL connection config from context
  */
@@ -15,7 +16,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

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

@@ -4,6 +4,7 @@
  */
 import { output } from '../../output.js';
 import { confirm } from '../../prompt.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Get PostgreSQL connection config from context
  */
@@ -15,7 +16,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

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

@@ -12,10 +12,18 @@
 import { output } from '../../output.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { validateTimestamp } from './pg-utils.js';
 /**
  * Format a ruvector embedding array for PostgreSQL
+ * Validates each element is a finite number to prevent SQL injection via crafted arrays.
  */
 function formatEmbedding(embedding, dimensions = 384) {
+    // Validate every element is a finite number (prevents SQL injection via crafted JSON)
+    for (let i = 0; i < embedding.length; i++) {
+        if (typeof embedding[i] !== 'number' || !Number.isFinite(embedding[i])) {
+            throw new Error(`Invalid embedding value at index ${i}: expected finite number, got ${typeof embedding[i]}`);
+        }
+    }
     // Ensure correct dimensions by padding or truncating
     const padded = [...embedding];
     while (padded.length < dimensions) {
@@ -40,12 +48,19 @@ function generateInsertSQL(entry) {
     const value = typeof entry.value === 'string'
         ? escapeString(entry.value)
         : escapeString(JSON.stringify(entry.value));
-    const namespace = entry.namespace || 'default';
+    const namespace = escapeString(entry.namespace || 'default');
     const metadata = entry.metadata ? escapeString(JSON.stringify(entry.metadata)) : '{}';
     let embeddingClause = 'NULL';
     if (entry.embedding && Array.isArray(entry.embedding) && entry.embedding.length > 0) {
         embeddingClause = formatEmbedding(entry.embedding);
     }
+    // DA-HIGH-3: Validate timestamps to prevent SQL injection via crafted JSON
+    const createdAt = entry.created_at
+        ? `'${escapeString(validateTimestamp(String(entry.created_at)))}'::timestamptz`
+        : 'NOW()';
+    const updatedAt = entry.updated_at
+        ? `'${escapeString(validateTimestamp(String(entry.updated_at)))}'::timestamptz`
+        : 'NOW()';
     return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
 VALUES (
   '${key}',
@@ -53,8 +68,8 @@ VALUES (
   ${embeddingClause},
   '${namespace}',
   '${metadata}'::jsonb,
-  ${entry.created_at ? `'${entry.created_at}'::timestamptz` : 'NOW()'},
-  ${entry.updated_at ? `'${entry.updated_at}'::timestamptz` : 'NOW()'}
+  ${createdAt},
+  ${updatedAt}
 )
 ON CONFLICT (key, namespace) DO UPDATE SET
   value = EXCLUDED.value,
@@ -288,12 +303,21 @@ export const importCommand = {
                 output.writeln(output.dim('Command:'));
                 output.writeln(output.dim(`  docker exec -i ${containerName} psql -U claude -d claude_flow < ${tempFile}`));
                 output.writeln();
-                // Execute via child_process
-                const { execSync } = await import('child_process');
+                // Execute via child_process (CRIT-02: use execFileSync to prevent command injection)
+                const { execFileSync } = await import('child_process');
+                // Validate containerName: alphanumeric, hyphens, underscores, dots only
+                if (!/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(containerName)) {
+                    throw new Error(`Invalid container name: ${containerName}`);
+                }
                 try {
-                    const result = execSync(`docker exec -i ${containerName} psql -U claude -d claude_flow < ${tempFile}`, {
+                    const sqlContent = fs.readFileSync(tempFile, 'utf-8');
+                    const result = execFileSync('docker', [
+                        'exec', '-i', containerName,
+                        'psql', '-U', 'claude', '-d', 'claude_flow',
+                    ], {
                         encoding: 'utf-8',
                         timeout: 60000,
+                        input: sqlContent,
                     });
                     if (verbose) {
                         output.writeln(output.dim(result));

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

@@ -4,6 +4,7 @@
  */
 import { output } from '../../output.js';
 import { confirm, input } from '../../prompt.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Get PostgreSQL connection config from context flags and environment
  */
@@ -15,7 +16,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

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

@@ -4,6 +4,7 @@
  */
 import { output } from '../../output.js';
 import { confirm } from '../../prompt.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Available migrations
  */
@@ -141,7 +142,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

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

@@ -4,6 +4,7 @@
  */
 import { output } from '../../output.js';
 import { confirm } from '../../prompt.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Get PostgreSQL connection config from context
  */
@@ -15,7 +16,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

package/v3/@claude-flow/cli/dist/src/commands/ruvector/pg-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PostgreSQL security utilities for RuVector commands.
+ * Prevents SQL injection via identifier interpolation.
+ *
+ * @module v3/cli/commands/ruvector/pg-utils
+ */
+/**
+ * Validate a PostgreSQL schema name.
+ * Throws if the name contains characters that could enable SQL injection.
+ * Safe names are returned as-is (no quoting needed since they match the identifier pattern).
+ */
+export declare function validateSchemaName(schema: string): string;
+export declare function validateTimestamp(value: string): string;
+//# sourceMappingURL=pg-utils.d.ts.map

package/v3/@claude-flow/cli/dist/src/commands/ruvector/pg-utils.js

@@ -0,0 +1,41 @@
+/**
+ * PostgreSQL security utilities for RuVector commands.
+ * Prevents SQL injection via identifier interpolation.
+ *
+ * @module v3/cli/commands/ruvector/pg-utils
+ */
+/**
+ * Valid PostgreSQL identifier pattern.
+ * Allows only ASCII letters, digits, and underscores.
+ * Must start with a letter or underscore.
+ */
+const VALID_PG_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+ * Validate a PostgreSQL schema name.
+ * Throws if the name contains characters that could enable SQL injection.
+ * Safe names are returned as-is (no quoting needed since they match the identifier pattern).
+ */
+export function validateSchemaName(schema) {
+    if (!schema || schema.length === 0) {
+        throw new Error('Schema name must not be empty');
+    }
+    if (schema.length > 63) {
+        throw new Error(`Schema name too long (${schema.length} chars, max 63): "${schema}"`);
+    }
+    if (!VALID_PG_IDENTIFIER.test(schema)) {
+        throw new Error(`Invalid schema name: "${schema}". Must contain only letters, digits, and underscores, and start with a letter or underscore.`);
+    }
+    return schema;
+}
+/**
+ * Validate a PostgreSQL timestamp string.
+ * Only allows ISO 8601 format to prevent SQL injection via timestamp fields.
+ */
+const VALID_TIMESTAMP = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})?$/;
+export function validateTimestamp(value) {
+    if (!VALID_TIMESTAMP.test(value)) {
+        throw new Error(`Invalid timestamp format: "${value}". Expected ISO 8601.`);
+    }
+    return value;
+}
+//# sourceMappingURL=pg-utils.js.map

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

@@ -3,6 +3,7 @@
  * Check connection and schema status
  */
 import { output } from '../../output.js';
+import { validateSchemaName } from './pg-utils.js';
 /**
  * Get PostgreSQL connection config from context
  */
@@ -14,7 +15,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: validateSchemaName(ctx.flags.schema || 'claude_flow'),
     };
 }
 /**

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

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { commandParser } from './parser.js';
 import { output } from './output.js';
-import { commands, commandsByCategory, getCommand, getCommandAsync, getCommandNames, hasCommand } from './commands/index.js';
+import { commands, getCommandsByCategory, getCommand, getCommandAsync, getCommandNames, hasCommand } from './commands/index.js';
 import { suggestCommand } from './suggest.js';
 import { runStartupUpdateCheck } from './update/index.js';
 // Read version from package.json at runtime
@@ -109,7 +109,7 @@ export class CLI {
                     process.exit(1);
                 }
                 else {
-                    this.showHelp();
+                    await this.showHelp();
                 }
                 return;
             }
@@ -219,7 +219,7 @@ export class CLI {
     /**
      * Show main help
      */
-    showHelp() {
+    async showHelp() {
         this.output.writeln();
         this.output.writeln(this.output.bold(`${this.name} v${this.version}`));
         this.output.writeln(this.output.dim(this.description));
@@ -227,9 +227,11 @@ export class CLI {
         this.output.writeln(this.output.bold('USAGE:'));
         this.output.writeln(`  ${this.name} <command> [subcommand] [options]`);
         this.output.writeln();
+        // PERF-03: Load all commands by category (lazy-loaded on demand)
+        const categories = await getCommandsByCategory();
         // Primary Commands
         this.output.writeln(this.output.bold('PRIMARY COMMANDS:'));
-        for (const cmd of commandsByCategory.primary) {
+        for (const cmd of categories.primary) {
             if (cmd.hidden)
                 continue;
             const name = cmd.name.padEnd(12);
@@ -237,41 +239,49 @@ export class CLI {
         }
         this.output.writeln();
         // Advanced Commands
-        this.output.writeln(this.output.bold('ADVANCED COMMANDS:'));
-        for (const cmd of commandsByCategory.advanced) {
-            if (cmd.hidden)
-                continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+        if (categories.advanced.length > 0) {
+            this.output.writeln(this.output.bold('ADVANCED COMMANDS:'));
+            for (const cmd of categories.advanced) {
+                if (cmd.hidden)
+                    continue;
+                const name = cmd.name.padEnd(12);
+                this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            }
+            this.output.writeln();
         }
-        this.output.writeln();
         // Utility Commands
-        this.output.writeln(this.output.bold('UTILITY COMMANDS:'));
-        for (const cmd of commandsByCategory.utility) {
-            if (cmd.hidden)
-                continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+        if (categories.utility.length > 0) {
+            this.output.writeln(this.output.bold('UTILITY COMMANDS:'));
+            for (const cmd of categories.utility) {
+                if (cmd.hidden)
+                    continue;
+                const name = cmd.name.padEnd(12);
+                this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            }
+            this.output.writeln();
         }
-        this.output.writeln();
         // Analysis Commands
-        this.output.writeln(this.output.bold('ANALYSIS COMMANDS:'));
-        for (const cmd of commandsByCategory.analysis) {
-            if (cmd.hidden)
-                continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+        if (categories.analysis.length > 0) {
+            this.output.writeln(this.output.bold('ANALYSIS COMMANDS:'));
+            for (const cmd of categories.analysis) {
+                if (cmd.hidden)
+                    continue;
+                const name = cmd.name.padEnd(12);
+                this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            }
+            this.output.writeln();
         }
-        this.output.writeln();
         // Management Commands
-        this.output.writeln(this.output.bold('MANAGEMENT COMMANDS:'));
-        for (const cmd of commandsByCategory.management) {
-            if (cmd.hidden)
-                continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+        if (categories.management.length > 0) {
+            this.output.writeln(this.output.bold('MANAGEMENT COMMANDS:'));
+            for (const cmd of categories.management) {
+                if (cmd.hidden)
+                    continue;
+                const name = cmd.name.padEnd(12);
+                this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            }
+            this.output.writeln();
         }
-        this.output.writeln();
         this.output.writeln(this.output.bold('GLOBAL OPTIONS:'));
         for (const opt of this.parser.getGlobalOptions()) {
             const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;

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

@@ -570,12 +570,30 @@ export class MCPServerManager extends EventEmitter {
             return false;
         }
         // Verify it's actually a node process (guards against PID reuse)
+        // DA-CRIT-3: Use execFileSync to prevent command injection via PID values
         try {
-            const { execSync } = require('child_process');
-            const cmdline = execSync(`cat /proc/${pid}/cmdline 2>/dev/null || ps -p ${pid} -o comm= 2>/dev/null`, {
-                encoding: 'utf8',
-                timeout: 1000,
-            }).trim();
+            const { execFileSync } = require('child_process');
+            const safePid = String(Math.floor(Math.abs(pid)));
+            let cmdline = '';
+            try {
+                // Try /proc on Linux
+                const { readFileSync } = require('fs');
+                cmdline = readFileSync(`/proc/${safePid}/cmdline`, 'utf8');
+            }
+            catch {
+                // Fall back to ps on macOS/other
+                try {
+                    cmdline = execFileSync('ps', ['-p', safePid, '-o', 'comm='], {
+                        encoding: 'utf8',
+                        timeout: 1000,
+                    }).trim();
+                }
+                catch {
+                    // ps failed — fall through
+                }
+            }
+            if (!cmdline)
+                return true; // Can't inspect, fall back to kill check
             // Must be a node process to be our MCP server
             return cmdline.includes('node') || cmdline.includes('claude-flow') || cmdline.includes('npx');
         }

package/v3/@claude-flow/cli/dist/src/plugins/manager.js

@@ -238,6 +238,8 @@ export class PluginManager {
         if (!plugin) {
             return { success: false, error: `Plugin ${packageName} is not installed` };
         }
+        // HIGH-04: Warn about unsandboxed plugin execution
+        console.warn(`[SECURITY] Plugin loaded without sandboxing: ${packageName}. Plugins run with full process access.`);
         plugin.enabled = true;
         await this.saveManifest();
         return { success: true };

package/v3/@claude-flow/cli/dist/src/ruvector/lora-adapter.js

@@ -394,7 +394,10 @@ export class LoRAAdapter {
         if (pipeline) {
             try {
                 pipeline.saveCheckpoint(path);
-                return true;
+                // Verify ruvllm actually wrote the file (some versions are no-op)
+                const fs = await import('fs');
+                if (fs.existsSync(path))
+                    return true;
             }
             catch { /* fall through to JS fallback */ }
         }

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

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