claude-flow 3.47.1 → 3.49.0

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

@@ -9,6 +9,10 @@ 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';
+import { validateIdentifier } from '../mcp-tools/validate-input.js';
+import { memoryKeyError } from '../mcp-tools/memory-tools.js';
 /**
  * #3228: a miss in one store is not a miss in the memory.
  *
@@ -19,16 +23,39 @@ import { resolveDbPath } from '../memory/memory-initializer.js';
  * `found:false`. A confident negative is worse than an error, because nothing
  * prompts anyone to look further.
  */
-async function warnIfSiblingHasRows(pathFlag) {
+async function warnIfSiblingHasRows(pathFlag, hits) {
     const unread = await countSiblingStoreRows(resolveDbPath(pathFlag));
     if (unread && unread.rows > 0) {
-        output.printWarning(`This read covered one store. ${unread.rows} entries are in ${unread.path} and were not searched. ` +
+        // #3566: disclose on hits too. A partial positive ("Found 1 results") invites
+        // no second look, so it is the more dangerous case, not the safer one.
+        const lead = hits === undefined
+            ? 'This read covered one store.'
+            : `Partial result: ${hits} ${hits === 1 ? 'match' : 'matches'} came from the store read here.`;
+        output.printWarning(`${lead} ${unread.rows} entries are in ${unread.path} and were not searched. ` +
             `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)' },
+    { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing' },
     { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
     { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
@@ -162,6 +189,18 @@ const storeCommand = {
             output.printError('Value is required. Use --value');
             return { success: false, exitCode: 1 };
         }
+        // #3570: reject a traversal namespace before persisting, as export/purge do.
+        const vNs = validateIdentifier(namespace, 'namespace');
+        if (!vNs.valid) {
+            output.printError(vNs.error);
+            return { success: false, exitCode: 1 };
+        }
+        // #3570 follow-up: the same key rule MCP memory_store enforces.
+        const keyError = memoryKeyError(key);
+        if (keyError) {
+            output.printError(keyError);
+            return { success: false, exitCode: 1 };
+        }
         // #2752 MemPoison gate — scan before persist when opted in.
         // CLI flag ctx.flags.scanContent takes precedence over RUFLO_MEMORY_SCAN_ON_WRITE env var
         // (ADR-125 §"CLI flag wins" / ADR-130 §env-var-config-precedence — fix for #2794).
@@ -308,6 +347,9 @@ const retrieveCommand = {
                 return { success: false, exitCode: 1, data: { key, found: false } };
             }
             const entry = result.entry;
+            // #3566: the same key may also live in the sibling store. Goes to stderr,
+            // so --value-only / --format json stdout stays parseable.
+            await warnIfSiblingHasRows(ctx.flags.path, 1);
             // #2073: --value-only emits just the raw value (no decoration) for
             // piping into JSON.parse / jq / other downstream parsers without
             // any cleanup.
@@ -391,7 +433,7 @@ const searchCommand = {
         },
         {
             name: 'build-hnsw',
-            description: 'Build/rebuild HNSW index before searching (enables 150x-12,500x speedup)',
+            description: 'Build/rebuild HNSW index before searching',
             type: 'boolean',
             default: false
         },
@@ -492,7 +534,6 @@ const searchCommand = {
                     const status = getHNSWStatus();
                     output.printSuccess(`HNSW index built (${status.entryCount} vectors, ${buildTime}ms)`);
                     output.writeln(output.dim(`  Dimensions: ${status.dimensions}, Metric: cosine`));
-                    output.writeln(output.dim(`  Search speedup: ${status.entryCount > 10000 ? '12,500x' : status.entryCount > 1000 ? '150x' : '10x'}`));
                 }
                 else {
                     output.printWarning('HNSW index not available (install @ruvector/core for acceleration)');
@@ -556,6 +597,7 @@ const searchCommand = {
                     // Pure-keyword mode returns directly; skip the semantic path entirely.
                     if (ctx.flags.format === 'json') {
                         output.printJson({ query, searchType, results: keywordResults, searchTime: '0ms' });
+                        await warnIfSiblingHasRows(ctx.flags.path, keywordResults.length);
                         return { success: true, data: keywordResults };
                     }
                     output.writeln();
@@ -563,6 +605,7 @@ const searchCommand = {
                     for (const r of keywordResults) {
                         output.writeln(`  ${r.key} (${r.namespace}, score=${r.score.toFixed(2)}) — ${r.preview.slice(0, 80)}${r.preview.length > 80 ? '…' : ''}`);
                     }
+                    await warnIfSiblingHasRows(ctx.flags.path, keywordResults.length);
                     return { success: true, data: keywordResults };
                 }
                 // Hybrid mode: keyword hits will be MERGED after semantic runs below.
@@ -674,6 +717,7 @@ const searchCommand = {
             }
             if (ctx.flags.format === 'json') {
                 output.printJson({ query, searchType, results, searchTime: `${searchTimeMs}ms`, ...(smartStats ? { stats: smartStats } : {}) });
+                await warnIfSiblingHasRows(ctx.flags.path, results.length);
                 return { success: true, data: results };
             }
             // Performance stats
@@ -700,6 +744,7 @@ const searchCommand = {
             });
             output.writeln();
             output.printInfo(`Found ${results.length} results`);
+            await warnIfSiblingHasRows(ctx.flags.path, results.length);
             return { success: true, data: results };
         }
         catch (error) {
@@ -820,7 +865,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 +915,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 +954,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 +992,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 +1019,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 +1049,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 +1066,7 @@ const statsCommand = {
                     text: statsResult.totalEntries
                 },
                 storage: {
-                    total: statsResult.totalSize,
+                    total: statsResult.totalSize ?? 'unknown',
                     location: statsResult.location
                 },
                 version: statsResult.version,
@@ -1004,6 +1077,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();
@@ -1109,8 +1185,6 @@ const statsCommand = {
                 output.writeln(output.bold('Embedding'));
                 output.printInfo(`Provider info unavailable: ${e instanceof Error ? e.message : String(e)}`);
             }
-            output.writeln();
-            output.printInfo('V3 Performance: 150x-12,500x faster search with HNSW indexing');
             return { success: true, data: stats };
         }
         catch (error) {
@@ -1245,19 +1319,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 +1368,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 +1608,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 +1627,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.

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

@@ -8,6 +8,7 @@
 import { output } from '../output.js';
 import { createPluginDiscoveryService, searchPlugins, getPluginSearchSuggestions, getFeaturedPlugins, getOfficialPlugins, } from '../plugins/store/index.js';
 import { getPluginManager } from '../plugins/manager.js';
+import { DEFAULT_PLUGIN_PERMISSIONS } from '../plugins/trust-policy.js';
 import { getBulkRatings } from '../services/registry-api.js';
 // List subcommand - Now uses IPFS-based registry
 const listCommand = {
@@ -185,18 +186,29 @@ const installCommand = {
         { name: 'version', short: 'v', type: 'string', description: 'Specific version to install' },
         { name: 'global', short: 'g', type: 'boolean', description: 'Install globally' },
         { name: 'dev', short: 'd', type: 'boolean', description: 'Install as dev dependency' },
-        { name: 'verify', type: 'boolean', description: 'Verify checksum (default: true)', default: true },
+        {
+            name: 'verify',
+            type: 'boolean',
+            description: 'Verify before registering (default: true). Registry installs must match the registry sha256 checksum. ' +
+                'Hooks and commands are withheld from a plugin that declares trustLevel "untrusted"/"unverified" or ' +
+                `permissions beyond the default set (${DEFAULT_PLUGIN_PERMISSIONS.join(', ')}) unless --trust is given. ` +
+                '--no-verify skips all of this.',
+            default: true,
+        },
+        { name: 'trust', type: 'boolean', description: 'Register hooks and commands even if the plugin is untrusted or declares elevated permissions', default: false },
         { name: 'registry', short: 'r', type: 'string', description: 'Registry to use' },
     ],
     examples: [
         { command: 'claude-flow plugins install -n community-analytics', description: 'Install plugin from IPFS' },
         { command: 'claude-flow plugins install -n ./my-plugin --dev', description: 'Install local plugin' },
+        { command: 'claude-flow plugins install -n ./my-plugin --trust', description: 'Install a local plugin that declares elevated permissions, registering its hooks' },
     ],
     action: async (ctx) => {
         const name = ctx.flags.name;
         const version = ctx.flags.version || 'latest';
         const registryName = ctx.flags.registry;
         const verify = ctx.flags.verify !== false;
+        const trust = ctx.flags.trust === true;
         if (!name) {
             output.printError('Plugin name is required');
             return { success: false, exitCode: 1 };
@@ -227,7 +239,7 @@ const installCommand = {
             if (isLocalPath) {
                 // Install from local path
                 spinner.setText(`Installing from ${name}...`);
-                result = await manager.installFromLocal(name);
+                result = await manager.installFromLocal(name, { verify, trust });
             }
             else {
                 // First, try to find in registry for metadata
@@ -242,7 +254,13 @@ const installCommand = {
                 }
                 // Install from npm (since IPFS is demo mode)
                 spinner.setText(`Installing ${name} from npm...`);
-                result = await manager.installFromNpm(name, version !== 'latest' ? version : undefined);
+                result = await manager.installFromNpm(name, version !== 'latest' ? version : undefined, {
+                    verify,
+                    trust,
+                    expectedChecksum: plugin?.checksum,
+                    registryTrustLevel: plugin?.trustLevel,
+                    registryPermissions: plugin?.permissions,
+                });
             }
             if (!result.success) {
                 spinner.fail(`Installation failed: ${result.error}`);
@@ -251,20 +269,39 @@ const installCommand = {
             const installed = result.plugin;
             spinner.succeed(`Installed ${installed.name}@${installed.version}`);
             output.writeln();
+            if (result.decision?.verificationSkipped) {
+                output.printWarning('Verification skipped (--no-verify): hooks and commands were registered without a trust or checksum check.');
+            }
+            for (const warning of result.warnings ?? []) {
+                output.printWarning(warning);
+            }
             const boxContent = [
                 `Plugin: ${installed.name}`,
                 `Version: ${installed.version}`,
                 `Source: ${installed.source}`,
                 `Path: ${installed.path || 'N/A'}`,
                 ``,
+                `Trust: ${installed.trustLevel ?? 'not declared'}`,
+                `Permissions: ${installed.permissions?.join(', ') || 'none declared'}`,
+                `Verification: ${installed.verification ?? 'n/a'}`,
+                `Install scripts: ${installed.source === 'local' ? 'n/a (local link)' : installed.scriptsRun ? 'ran' : 'skipped (use --trust to run)'}`,
+                ``,
                 `Hooks registered: ${installed.hooks?.length || 0}`,
                 `Commands added: ${installed.commands?.length || 0}`,
             ];
-            if (plugin) {
-                boxContent.push(`Trust: ${plugin.trustLevel}`);
-                boxContent.push(`Permissions: ${plugin.permissions.join(', ') || 'none'}`);
-            }
             output.printBox(boxContent.join('\n'), 'Installation Complete');
+            if (installed.withheld) {
+                output.writeln();
+                output.printWarning(`Withheld ${installed.withheld.hooks.length} hook(s) and ${installed.withheld.commands.length} command(s) ` +
+                    `from ${installed.name} because it ${installed.withheld.reasons.join('; ')}.`);
+                if (installed.withheld.hooks.length > 0) {
+                    output.writeln(output.dim(`  Hooks not registered: ${installed.withheld.hooks.join(', ')}`));
+                }
+                if (installed.withheld.commands.length > 0) {
+                    output.writeln(output.dim(`  Commands not added: ${installed.withheld.commands.join(', ')}`));
+                }
+                output.writeln(output.dim(`  To register them, uninstall and reinstall with --trust.`));
+            }
             return { success: true, data: installed };
         }
         catch (error) {

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

@@ -86,8 +86,11 @@ export const policyCommand = {
                 const state = loadPolicyState(root);
                 return print({ receipts: state.receipts });
             }
-            if (operation === 'verify')
-                return print(await verifyPolicyLedger(root));
+            if (operation === 'verify') {
+                const ledger = await verifyPolicyLedger(root);
+                const result = print(ledger);
+                return ledger.valid ? result : { ...result, success: false, exitCode: 1 };
+            }
             throw new Error(`unknown policy operation: ${operation}`);
         }
         catch (error) {