claude-flow 3.47.0 → 3.48.0

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

@@ -0,0 +1,242 @@
+/**
+ * Hive-mind worker execution: the MCP config handed to a spawned Claude, and
+ * `hive-mind work`, which actually runs a queued task.
+ *
+ * Before this, `hive-mind task` only wrote a `pending` row to the task store.
+ * Workers are records, not processes, and nothing ever claimed the row: the
+ * task stayed pending and the worker stayed idle forever. `work` is the missing
+ * consumer — claim one task, assign it to an idle hive worker, run it through
+ * `claude -p`, and record the outcome.
+ */
+import { output } from '../output.js';
+import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import { spawn as childSpawn } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { resolveClaudeLaunchCommand } from '../runtime/claude-command.js';
+/** The server key the hive-mind prompt addresses (`mcp__ruflo__*`). */
+const RUFLO_SERVER = 'ruflo';
+function readServers(path, cwd) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        const isMap = (v) => !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0;
+        if (isMap(parsed.mcpServers))
+            return parsed.mcpServers;
+        // ~/.claude.json keeps project-scoped servers under projects[<cwd>].
+        const project = parsed.projects?.[cwd];
+        if (isMap(project?.mcpServers))
+            return project.mcpServers;
+    }
+    catch {
+        // Unreadable or not JSON: not a usable config.
+    }
+    return null;
+}
+/**
+ * The MCP config file to pass to a spawned Claude.
+ *
+ * A source file is never passed through as-is. `~/.claude.json` is Claude
+ * Code's whole state file; on a machine where it has no top-level
+ * `mcpServers` (a fresh desktop), Claude exits at startup with "Invalid MCP
+ * configuration: mcpServers: Invalid input", before any task can run. And a
+ * config lacking a `ruflo` server leaves the worker without the tools its
+ * prompt names. So the servers are extracted, a `ruflo` server is guaranteed,
+ * and the result is written as a config Claude is known to accept.
+ */
+export function resolveWorkerMcpConfig(opts) {
+    if (opts.explicit)
+        return opts.explicit;
+    const candidates = [join(opts.cwd, '.mcp.json')];
+    if (opts.home)
+        candidates.push(join(opts.home, '.claude.json'), join(opts.home, '.claude', 'mcp.json'));
+    let servers = {};
+    for (const c of candidates) {
+        const found = readServers(c, opts.cwd);
+        if (found) {
+            servers = found;
+            break;
+        }
+    }
+    if (!servers[RUFLO_SERVER]) {
+        servers = {
+            ...servers,
+            [RUFLO_SERVER]: {
+                command: opts.rufloServer.command,
+                args: opts.rufloServer.args,
+                // The MCP server keys its stores off this, so the worker's tool calls
+                // land in the same task/agent stores as the CLI that dispatched it.
+                env: { CLAUDE_FLOW_CWD: opts.cwd },
+            },
+        };
+    }
+    mkdirSync(opts.outDir, { recursive: true });
+    const path = join(opts.outDir, `mcp-${opts.swarmId}.json`);
+    writeFileSync(path, JSON.stringify({ mcpServers: servers }, null, 2), 'utf-8');
+    return path;
+}
+/**
+ * The ruflo MCP server as launched by THIS cli, so a worker and the CLI that
+ * dispatched it share one version and one store format. `@latest` could
+ * resolve to a different release mid-session.
+ */
+export function currentRufloServer() {
+    const entry = process.argv[1];
+    return entry
+        ? { command: process.execPath, args: [entry, 'mcp', 'start'] }
+        : { command: 'npx', args: ['-y', '@claude-flow/cli@latest', 'mcp', 'start'] };
+}
+/** Run one prompt through `claude -p` and parse its JSON result. */
+export const runWithClaude = (prompt, opts) => new Promise((resolve) => {
+    const started = Date.now();
+    const launch = resolveClaudeLaunchCommand();
+    if (!launch) {
+        resolve({ ok: false, output: 'Claude Code CLI not found in PATH', exitCode: null, durationMs: 0 });
+        return;
+    }
+    // The prompt goes on stdin, not argv: a task description has no length
+    // bound and `--mcp-config` is variadic (#1780).
+    const child = childSpawn(launch.command, [...launch.argsPrefix, '-p', '--output-format', 'json', `--mcp-config=${opts.mcpConfig}`], { cwd: opts.cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => (stdout += d));
+    child.stderr.on('data', (d) => (stderr += d));
+    const timer = setTimeout(() => child.kill('SIGTERM'), opts.timeoutMs);
+    child.on('error', (e) => {
+        clearTimeout(timer);
+        resolve({ ok: false, output: e.message, exitCode: null, durationMs: Date.now() - started });
+    });
+    child.on('close', (code, signal) => {
+        clearTimeout(timer);
+        const durationMs = Date.now() - started;
+        try {
+            const r = JSON.parse(stdout);
+            resolve({
+                ok: code === 0 && !r.is_error,
+                output: r.result ?? '',
+                exitCode: code,
+                sessionId: r.session_id,
+                costUsd: r.total_cost_usd,
+                durationMs,
+            });
+        }
+        catch {
+            const why = signal === 'SIGTERM' ? `timed out after ${opts.timeoutMs}ms` : (stderr || stdout).trim().slice(-2000);
+            resolve({ ok: false, output: why, exitCode: code, durationMs });
+        }
+    });
+    child.stdin.end(prompt);
+});
+function timeoutFromTags(tags, fallback) {
+    const tag = tags?.find((t) => /^timeout:\d+s$/.test(t));
+    return tag ? Number(tag.slice('timeout:'.length, -1)) * 1000 : fallback;
+}
+/**
+ * One dispatch cycle: the oldest pending hive task goes to an idle hive worker,
+ * runs, and its outcome is recorded on the task. Every state change goes
+ * through the MCP task tools, so the store is the same one `hive-mind status`
+ * and `task status` read.
+ */
+export async function workOnce(opts) {
+    let taskId = opts.taskId;
+    if (!taskId) {
+        const listed = await callMCPTool('task_list', { status: 'pending', type: 'hive-mind', limit: 1000 });
+        const oldest = [...(listed.tasks ?? [])].sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+        if (!oldest)
+            return { dispatched: false, reason: 'No pending hive-mind tasks' };
+        taskId = oldest.taskId;
+    }
+    const task = await callMCPTool('task_status', { taskId });
+    if (task.status !== 'pending') {
+        return { dispatched: false, reason: `Task ${taskId} is ${task.status}, not pending` };
+    }
+    let workerId = opts.workerId;
+    if (!workerId) {
+        const hive = await callMCPTool('hive-mind_status', {});
+        workerId = hive.workers?.find((w) => w.status === 'idle')?.id;
+        if (!workerId)
+            return { dispatched: false, reason: 'No idle hive worker — run "hive-mind spawn" first' };
+    }
+    await callMCPTool('task_assign', { taskId, agentIds: [workerId] });
+    const prompt = `You are hive-mind worker ${workerId}. Complete this task, then reply with ` +
+        `the result only.\n\nTask ${taskId}:\n${task.description}`;
+    const outcome = await opts.runner(prompt, {
+        mcpConfig: opts.mcpConfig,
+        timeoutMs: timeoutFromTags(task.tags, opts.defaultTimeoutMs ?? 300_000),
+        cwd: opts.cwd,
+    });
+    const result = {
+        worker: workerId,
+        output: outcome.output,
+        exitCode: outcome.exitCode,
+        durationMs: outcome.durationMs,
+        ...(outcome.sessionId ? { sessionId: outcome.sessionId } : {}),
+        ...(outcome.costUsd !== undefined ? { costUsd: outcome.costUsd } : {}),
+    };
+    if (outcome.ok) {
+        await callMCPTool('task_complete', { taskId, result });
+        return { dispatched: true, taskId, workerId, status: 'completed', outcome };
+    }
+    await callMCPTool('task_update', { taskId, status: 'failed', result });
+    return { dispatched: true, taskId, workerId, status: 'failed', outcome };
+}
+export const workCommand = {
+    name: 'work',
+    description: 'Run the next pending hive task on an idle worker via Claude Code and record the result',
+    options: [
+        { name: 'task', description: 'Run this task id instead of the oldest pending one', type: 'string' },
+        { name: 'worker', description: 'Assign to this worker id instead of the first idle one', type: 'string' },
+        { name: 'mcp-config', description: 'MCP config for the worker (default: generated, with the ruflo server)', type: 'string' },
+    ],
+    examples: [
+        { command: 'claude-flow hive-mind work', description: 'Run the oldest pending hive task' },
+        { command: 'claude-flow hive-mind work --task task-123', description: 'Run a specific task' },
+    ],
+    action: async (ctx) => {
+        const cwd = ctx.cwd || process.cwd();
+        try {
+            const mcpConfig = resolveWorkerMcpConfig({
+                explicit: ctx.flags.mcpConfig,
+                cwd,
+                home: process.env.HOME || process.env.USERPROFILE || '',
+                outDir: join(cwd, '.hive-mind', 'sessions'),
+                swarmId: 'worker',
+                rufloServer: currentRufloServer(),
+            });
+            const r = await workOnce({
+                cwd,
+                mcpConfig,
+                runner: runWithClaude,
+                taskId: ctx.flags.task,
+                workerId: ctx.flags.worker,
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(r);
+            }
+            else if (!r.dispatched) {
+                output.printInfo(r.reason);
+            }
+            else {
+                output.printBox([
+                    `Task ID: ${r.taskId}`,
+                    `Worker: ${r.workerId}`,
+                    `Status: ${r.status}`,
+                    `Duration: ${r.outcome.durationMs}ms`,
+                    '',
+                    r.outcome.output.slice(0, 2000),
+                ].join('\n'), r.status === 'completed' ? 'Task Completed' : 'Task Failed');
+                output.writeln(output.dim(`  Full record: claude-flow task status ${r.taskId}`));
+            }
+            // Nothing to do is not an error; a task that ran and failed is.
+            const failed = r.dispatched && r.status === 'failed';
+            return { success: !failed, exitCode: failed ? 1 : 0, data: r };
+        }
+        catch (error) {
+            const msg = error instanceof MCPClientError ? error.message : String(error);
+            output.printError(`Work error: ${msg}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
+//# sourceMappingURL=hive-mind-worker.js.map

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

@@ -10,7 +10,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { spawn as childSpawn } from 'child_process';
 import { mkdir, writeFile } from 'fs/promises';
-import { existsSync } from 'fs';
+import { resolveWorkerMcpConfig, currentRufloServer, workCommand } from './hive-mind-worker.js';
 import { join } from 'path';
 import { resolveClaudeLaunchCommand } from '../runtime/claude-command.js';
 import { getHiveTokenForCli } from '../mcp-tools/hive-mind-tools.js';
@@ -202,44 +202,25 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             // Build arguments - flags first, then prompt
             const claudeArgs = [];
             // #1748 Issue 2 — pass --mcp-config so the spawned worker actually has
-            // mcp__ruflo__* tools registered. Before this, the coordination prompt
-            // referenced tools the worker didn't know about and exited silently.
-            // Resolution order:
-            //   1. explicit --mcp-config <path> flag passed by the caller
-            //   2. ./.mcp.json in cwd (project-local Ruflo MCP config)
-            //   3. ~/.claude.json or ~/.claude/mcp.json (user-global)
-            // If none found, we still spawn but warn — that's the pre-fix behavior
-            // and the user's debug log will surface the missing tools.
-            const explicitMcpConfig = flags['mcp-config'];
-            let mcpConfigPath = explicitMcpConfig;
-            if (!mcpConfigPath) {
-                const candidates = [
-                    join(process.cwd(), '.mcp.json'),
-                    join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json'),
-                    join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'mcp.json'),
-                ];
-                for (const c of candidates) {
-                    try {
-                        if (c && existsSync(c)) {
-                            mcpConfigPath = c;
-                            break;
-                        }
-                    }
-                    catch { /* continue */ }
-                }
-            }
-            if (mcpConfigPath) {
-                // #1780 — Claude Code's `--mcp-config` is variadic; passing it as two
-                // argv tokens (`--mcp-config`, `<path>`) lets a later positional (the
-                // hive-mind prompt) be slurped as a second config file, producing
-                // `ENAMETOOLONG: name too long, open` once the prompt exceeds PATH_MAX.
-                // Use `=`-syntax so the flag stays attached to its single value.
-                claudeArgs.push(`--mcp-config=${mcpConfigPath}`);
-                output.printInfo(`Spawned worker MCP config: ${mcpConfigPath}`);
-            }
-            else {
-                output.printWarning('No .mcp.json or ~/.claude.json found — spawned worker will not have mcp__ruflo__* tools (#1748 Issue 2). Pass --mcp-config <path> or run "ruflo init" to generate one.');
-            }
+            // mcp__ruflo__* tools registered. The config is always a generated file
+            // that Claude accepts; see resolveWorkerMcpConfig for why a source
+            // config (notably ~/.claude.json) is never passed through as-is.
+            // The parser stores flags camelCased (#2269), so read both forms.
+            const mcpConfigPath = resolveWorkerMcpConfig({
+                explicit: (flags['mcp-config'] ?? flags.mcpConfig),
+                cwd: process.cwd(),
+                home: process.env.HOME || process.env.USERPROFILE || '',
+                outDir: sessionsDir,
+                swarmId,
+                rufloServer: currentRufloServer(),
+            });
+            // #1780 — Claude Code's `--mcp-config` is variadic; passing it as two
+            // argv tokens (`--mcp-config`, `<path>`) lets a later positional (the
+            // hive-mind prompt) be slurped as a second config file, producing
+            // `ENAMETOOLONG: name too long, open` once the prompt exceeds PATH_MAX.
+            // Use `=`-syntax so the flag stays attached to its single value.
+            claudeArgs.push(`--mcp-config=${mcpConfigPath}`);
+            output.printInfo(`Spawned worker MCP config: ${mcpConfigPath}`);
             // Check for non-interactive mode
             const isNonInteractive = flags['non-interactive'] || flags.nonInteractive;
             if (isNonInteractive) {
@@ -882,7 +863,8 @@ const taskCommand = {
             ].join('\n'), 'Task Submitted');
             output.writeln();
             output.printSuccess('Task submitted to hive');
-            output.writeln(output.dim(`  Track with: claude-flow hive-mind task-status ${result.taskId}`));
+            output.writeln(output.dim(`  Run it with: claude-flow hive-mind work --task ${result.taskId}`));
+            output.writeln(output.dim(`  Track with:  claude-flow task status ${result.taskId}`));
             return { success: true, data: result };
         }
         catch (error) {
@@ -1210,7 +1192,7 @@ export const hiveMindCommand = {
     name: 'hive-mind',
     aliases: ['hive'],
     description: 'Queen-led consensus-based multi-agent coordination',
-    subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
+    subcommands: [initCommand, spawnCommand, statusCommand, taskCommand, workCommand, joinCommand, leaveCommand, consensusCommand, broadcastCommand, memorySubCommand, optimizeMemoryCommand, shutdownCommand],
     options: [],
     examples: [
         { command: 'claude-flow hive-mind init -t hierarchical-mesh', description: 'Initialize hive' },
@@ -1230,6 +1212,7 @@ export const hiveMindCommand = {
             `${output.highlight('spawn')}           - Spawn worker agents (use --claude to launch Claude Code)`,
             `${output.highlight('status')}          - Show hive status`,
             `${output.highlight('task')}            - Submit task to hive`,
+            `${output.highlight('work')}            - Run the next pending task on an idle worker`,
             `${output.highlight('join')}            - Join an agent to the hive`,
             `${output.highlight('leave')}           - Remove an agent from the hive`,
             `${output.highlight('consensus')}       - Manage consensus proposals`,

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

@@ -1,7 +1,4 @@
-/**
- * V3 CLI Hooks Command
- * Self-learning hooks system for intelligent workflow automation
- */
+import { validateFeedbackPatterns } from '../memory/feedback-patterns.js';
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -572,6 +569,11 @@ const postCommandCommand = {
             short: 'd',
             description: 'Execution duration in milliseconds',
             type: 'number'
+        },
+        {
+            name: 'ttl',
+            description: 'Command history lifetime in seconds (default: 30 days)',
+            type: 'number'
         }
     ],
     examples: [
@@ -594,11 +596,16 @@ const postCommandCommand = {
                 success,
                 exitCode: ctx.flags.exitCode || 0,
                 duration: ctx.flags.duration,
+                ttl: ctx.flags.ttl,
                 timestamp: Date.now(),
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
-                return { success: true, data: result };
+                return { success: result.recorded, exitCode: result.recorded ? 0 : 1, data: result };
+            }
+            if (!result.recorded) {
+                output.printError('Command outcome could not be recorded');
+                return { success: false, exitCode: 1, data: result };
             }
             output.writeln();
             output.printSuccess('Command outcome recorded');
@@ -1699,6 +1706,7 @@ const postTaskCommand = {
     name: 'post-task',
     description: 'Record task completion for learning',
     options: [
+        { name: 'patterns', description: 'JSON array of learned pattern strings for feedback and skill creation', type: 'string' },
         {
             name: 'task-id',
             short: 'i',
@@ -1784,8 +1792,10 @@ const postTaskCommand = {
         const success = ctx.flags.success !== undefined ? ctx.flags.success : true;
         output.printInfo(`Recording outcome for task: ${output.highlight(taskId)}`);
         try {
+            const patterns = validateFeedbackPatterns(ctx.flags.patterns === undefined ? undefined : JSON.parse(ctx.flags.patterns));
             const result = await callMCPTool('hooks_post-task', {
                 taskId,
+                patterns,
                 success,
                 quality: ctx.flags.quality,
                 agent: ctx.flags.agent,

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

@@ -9,6 +9,8 @@ import { distillCommand } from './memory-distill.js';
 import { backupCommand } from './memory-backup.js';
 import { countSiblingStoreRows } from '../memory/sibling-store.js';
 import { resolveDbPath } from '../memory/memory-initializer.js';
+import { existsSync } from 'node:fs';
+import { siblingAgentDbPath } from '../memory/memory-bridge.js';
 /**
  * #3228: a miss in one store is not a miss in the memory.
  *
@@ -26,6 +28,24 @@ async function warnIfSiblingHasRows(pathFlag) {
             `That store is written by the MCP/AgentDB path; read it with --path ${unread.path}.`);
     }
 }
+/** Default CLI writes may be mirrored into AgentDB; remove both copies. */
+function removalDbTargets(pathFlag) {
+    const primary = resolveDbPath(pathFlag);
+    // An explicit file selection is a single-store operation, as documented by
+    // --path. Do not widen a caller's requested destructive scope.
+    if (pathFlag || process.env.CLAUDE_FLOW_DB_PATH)
+        return [{ dbPath: primary }];
+    const sibling = siblingAgentDbPath(primary);
+    // The AgentDB mirror is consumed by native SQLite and must stay plaintext.
+    // Pass this per operation, including preview migrations; never toggle the
+    // process encryption setting while asynchronous operations are in flight.
+    const targets = [
+        { dbPath: primary },
+        ...(sibling ? [{ dbPath: sibling, encryptWrites: false }] : []),
+    ].filter(target => existsSync(target.dbPath));
+    // Preserve the existing missing-database error when neither store exists.
+    return targets.length ? targets : [{ dbPath: primary }];
+}
 // Memory backends
 const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
@@ -820,7 +840,7 @@ function formatRelativeTime(isoDate) {
 const deleteCommand = {
     name: 'delete',
     aliases: ['rm'],
-    description: 'Delete memory entry',
+    description: 'Delete a memory entry from the default store and its AgentDB mirror (use --path to select one store)',
     options: [
         {
             name: 'key',
@@ -870,16 +890,24 @@ const deleteCommand = {
         }
         // Use sql.js directly for consistent data access (Issue #980)
         try {
-            const { deleteEntry, resolveDbPath: _rdbDelete } = await import('../memory/memory-initializer.js');
-            const dbPathDelete = _rdbDelete(ctx.flags.path);
-            const result = await deleteEntry({ key, namespace, dbPath: dbPathDelete });
-            if (!result.success) {
-                output.printError(result.error || 'Failed to delete');
-                return { success: false, exitCode: 1 };
+            const { deleteEntry } = await import('../memory/memory-initializer.js');
+            const paths = removalDbTargets(ctx.flags.path);
+            const stores = [];
+            for (const target of paths) {
+                const { dbPath } = target;
+                const entry = await deleteEntry({ key, namespace, ...target });
+                if (!entry.success)
+                    throw new Error(`${dbPath}: ${entry.error || 'Failed to delete'}`);
+                stores.push({ dbPath, ...entry });
             }
+            const result = {
+                success: true, key, namespace, stores,
+                deleted: stores.some(entry => entry.deleted),
+                remainingEntries: stores.reduce((total, entry) => total + entry.remainingEntries, 0),
+            };
             if (result.deleted) {
                 output.printSuccess(`Deleted "${key}" from namespace "${namespace}"`);
-                output.printInfo(`Remaining entries: ${result.remainingEntries}`);
+                output.printInfo(`Remaining entries across ${paths.length} store(s): ${result.remainingEntries}`);
             }
             else {
                 output.printWarning(`Key not found: "${key}" in namespace "${namespace}"`);
@@ -901,7 +929,7 @@ const deleteCommand = {
 // either interactive confirmation or --force.
 const purgeCommand = {
     name: 'purge',
-    description: 'Permanently delete every entry in a namespace (hard delete — not the soft delete/tombstone that `memory delete` uses)',
+    description: 'Permanently delete a namespace from the default store and its AgentDB mirror (use --path to select one store)',
     options: [
         {
             name: 'namespace',
@@ -939,17 +967,22 @@ const purgeCommand = {
             return { success: false, exitCode: 1 };
         }
         try {
-            const { listEntries, purgeNamespace, resolveDbPath: _rdbPurge } = await import('../memory/memory-initializer.js');
-            const resolvedDbPath = _rdbPurge(dbPath);
-            const preview = await listEntries({ namespace, limit: 1, dbPath: resolvedDbPath });
-            const previewCount = preview.total ?? preview.entries?.length ?? 0;
+            const { listEntries, purgeNamespace } = await import('../memory/memory-initializer.js');
+            const paths = removalDbTargets(dbPath);
+            let previewCount = 0;
+            for (const target of paths) {
+                const preview = await listEntries({ namespace, limit: 1, ...target });
+                if (!preview.success)
+                    throw new Error(`${target.dbPath}: ${preview.error || 'Failed to read purge target'}`);
+                previewCount += preview.total ?? preview.entries?.length ?? 0;
+            }
             if (dryRun) {
-                output.printInfo(`Would permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}" (dry run — nothing deleted)`);
+                output.printInfo(`Would permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}" across ${paths.length} store(s) (dry run — nothing deleted)`);
                 return { success: true, data: { namespace, wouldDelete: previewCount } };
             }
             if (!force && ctx.interactive) {
                 const confirmed = await confirm({
-                    message: `Permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"? This is a hard delete — not reversible with \`memory delete\`'s soft-undo.`,
+                    message: `Permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}" across ${paths.length} store(s)? This is a hard delete — not reversible with \`memory delete\`'s soft-undo.`,
                     default: false
                 });
                 if (!confirmed) {
@@ -961,13 +994,20 @@ const purgeCommand = {
                 output.printError(`Refusing to purge namespace "${namespace}" without --force in non-interactive mode`);
                 return { success: false, exitCode: 1 };
             }
-            const result = await purgeNamespace({ namespace, dbPath: resolvedDbPath });
-            if (!result.success) {
-                output.printError(result.error || 'Failed to purge');
-                return { success: false, exitCode: 1 };
+            const stores = [];
+            for (const target of paths) {
+                const purged = await purgeNamespace({ namespace, ...target });
+                if (!purged.success)
+                    throw new Error(`${target.dbPath}: ${purged.error || 'Failed to purge'}`);
+                stores.push({ dbPath: target.dbPath, ...purged });
             }
+            const result = {
+                success: true, stores,
+                deletedCount: stores.reduce((total, store) => total + store.deletedCount, 0),
+                remainingEntries: stores.reduce((total, store) => total + store.remainingEntries, 0),
+            };
             output.printSuccess(`Purged ${result.deletedCount} entr${result.deletedCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"`);
-            output.printInfo(`Remaining entries (all namespaces): ${result.remainingEntries}`);
+            output.printInfo(`Remaining entries (all namespaces, ${paths.length} store(s)): ${result.remainingEntries}`);
             return { success: true, data: result };
         }
         catch (error) {
@@ -984,8 +1024,16 @@ const statsCommand = {
     action: async (ctx) => {
         // Call MCP memory/stats tool for real statistics
         try {
-            const statsResult = await callMCPTool('memory_stats', {});
+            const dbPath = resolveDbPath(ctx.flags.path);
+            const statsResult = await callMCPTool('memory_stats', { dbPath });
+            if (statsResult.available === false) {
+                output.printError(`Failed to get stats: ${statsResult.error || 'Store unavailable'}`);
+                return { success: false, exitCode: 1 };
+            }
+            const unreadStore = await countSiblingStoreRows(dbPath);
             const stats = {
+                ...(unreadStore ? { unreadStore } : {}),
+                ...(statsResult.truncated ? { truncated: true } : {}),
                 backend: statsResult.backend,
                 entries: {
                     total: statsResult.totalEntries,
@@ -993,7 +1041,7 @@ const statsCommand = {
                     text: statsResult.totalEntries
                 },
                 storage: {
-                    total: statsResult.totalSize,
+                    total: statsResult.totalSize ?? 'unknown',
                     location: statsResult.location
                 },
                 version: statsResult.version,
@@ -1004,6 +1052,9 @@ const statsCommand = {
                 output.printJson(stats);
                 return { success: true, data: stats };
             }
+            if (unreadStore) {
+                output.printWarning(`${unreadStore.rows} entries are in ${unreadStore.path} and were not read here. Read them with --path ${unreadStore.path}.`);
+            }
             output.writeln();
             output.writeln(output.bold('Memory Statistics'));
             output.writeln();
@@ -1245,19 +1296,27 @@ const cleanupCommand = {
         { command: 'claude-flow memory cleanup --expired-only', description: 'Clean expired entries' }
     ],
     action: async (ctx) => {
-        const dryRun = ctx.flags.dryRun;
-        const force = ctx.flags.force;
+        const dryRun = ctx.flags.dryRun === true;
+        const force = ctx.flags.force === true;
+        if (ctx.flags.format === 'json' && !dryRun && !force) {
+            output.printJson({ success: false, error: 'Use --dry-run to preview or --force to authorize cleanup with --format json.' });
+            return { success: false, exitCode: 1 };
+        }
         if (dryRun) {
             output.writeln(output.warning('DRY RUN - No changes will be made'));
         }
         output.printInfo('Analyzing memory for cleanup...');
         try {
-            const result = await callMCPTool('memory_cleanup', {
-                dryRun,
+            const selectors = {
                 olderThan: ctx.flags.olderThan,
                 expiredOnly: ctx.flags.expiredOnly,
                 lowQualityThreshold: ctx.flags.lowQuality,
                 namespace: ctx.flags.namespace,
+            };
+            // Preview before asking: dryRun:false executes deletion inside the tool.
+            let result = await callMCPTool('memory_cleanup', {
+                ...selectors,
+                dryRun: dryRun || !force,
             });
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -1286,6 +1345,7 @@ const cleanupCommand = {
                     output.printInfo('Cleanup cancelled');
                     return { success: true, data: result };
                 }
+                result = await callMCPTool('memory_cleanup', { ...selectors, dryRun: false });
             }
             if (!dryRun) {
                 output.writeln();
@@ -1525,7 +1585,8 @@ const importCommand = {
             short: 'n',
             description: 'Import into specific namespace',
             type: 'string'
-        }
+        },
+        DB_PATH_OPTION
     ],
     examples: [
         { command: 'claude-flow memory import -i ./backup.json', description: 'Import from file' },
@@ -1543,6 +1604,7 @@ const importCommand = {
                 inputPath,
                 merge: ctx.flags.merge ?? true,
                 namespace: ctx.flags.namespace,
+                dbPath: resolveDbPath(ctx.flags.path),
             });
             output.printSuccess(`Imported from ${result.inputPath}`);
             output.printList([

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

@@ -279,6 +279,7 @@ export const metaharnessCommand = {
             'verbose', 'v',
             'quiet', 'q',
             'help', 'h',
+            'interactive', 'i', // CLI-only default; plugin scripts are non-interactive
         ]);
         // Parser normalizes kebab-case → camelCase (--per-dimension → perDimension).
         // Plugin scripts expect kebab-case at argv, so we re-kebab here.