@claude-flow/cli 3.47.1 → 3.48.0

package/.claude/helpers/auto-memory-hook.mjs

@@ -12,12 +12,16 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
+// Home-level helpers can serve a different project. Keep the memory writer on
+// the same project root as intelligence.cjs, which reads CLAUDE_PROJECT_DIR.
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const DATA_DIR = join(PROJECT_ROOT, '.claude-flow', 'data');
 const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
 

package/.claude/helpers/helpers.manifest.json

@@ -1,14 +1,14 @@
 {
   "manifest": {
-    "version": "3.47.1",
+    "version": "3.48.0",
     "files": {
-      "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
+      "auto-memory-hook.mjs": "c8d218526a3c34034c2a69de23f507f0eb0f70d59c16426a8edc849e6ac22529",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
       "intelligence.cjs": "30e42ed7ec4ca5a94ac54fdb1330d2d47ac5f3fdeeef207753574723a9e77b5c",
       "statusline.cjs": "4a48353b4f1566fa4379b00fd0321b6676a22b6cc91fbbd8380ac5183d619468",
       "router.js": "b6998397e7883191b62229ccdc66fb87f1ccca1d5b2039ecb8c1e686d1ad81f8"
     }
   },
-  "signature": "HRKTz2ZUQJg/tmC/+MkrltmjtQT7hPeFmn3ejc719DC3vfKwYlpFb42h8/JrOTqass4rrUQFy96hB40gQNQwBA==",
+  "signature": "Y5fY+vJvnledNFp6edS2V1gxJ9P7llOQuq860/gCMvxr9DAzrlDuuKMuGgVP/Tb/25FStYm9+WyBVuOTDos0BQ==",
   "algorithm": "ed25519"
 }

package/.claude/helpers/learning-service.mjs

@@ -19,14 +19,16 @@
 
 import { createRequire } from 'module';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync, spawn } from 'child_process';
 import Database from 'better-sqlite3';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '../..');
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const DATA_DIR = join(PROJECT_ROOT, '.claude-flow/learning');
 const DB_PATH = join(DATA_DIR, 'patterns.db');
 const METRICS_PATH = join(DATA_DIR, 'learning-metrics.json');

package/.claude/helpers/metrics-db.mjs

@@ -7,12 +7,14 @@
 
 import initSqlJs from 'sql.js';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, openSync, writeSync, fsyncSync, closeSync, renameSync, rmSync } from 'fs';
-import { dirname, join, basename } from 'path';
+import { dirname, join, basename, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const PROJECT_ROOT = join(__dirname, '../..');
+const PROJECT_ROOT = process.env.CLAUDE_PROJECT_DIR
+  ? resolve(process.env.CLAUDE_PROJECT_DIR)
+  : join(__dirname, '../..');
 const V3_DIR = join(PROJECT_ROOT, 'v3');
 const DB_PATH = join(PROJECT_ROOT, '.claude-flow', 'metrics.db');
 

package/bin/cli.js

@@ -302,10 +302,13 @@ if (isMCPMode) {
 
         try {
           const result = await callMCPTool(toolName, toolParams, { sessionId });
+          // Failed task outcomes are data; an explicit handler error is a tool failure.
+          const isError = result !== null && typeof result === 'object'
+            && typeof result.error === 'string' && result.error.trim().length > 0;
           return {
             jsonrpc: '2.0',
             id: message.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
+            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }], isError },
           };
         } catch (error) {
           return {

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-28T15:44:58.000Z",
-  "gitSha": "bbbd7241",
+  "generatedAt": "2026-09-28T23:12:33.113Z",
+  "gitSha": "bd42d873",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/commands/analyze.js

@@ -1480,7 +1480,7 @@ const boundariesCommand = {
                 output.writeln();
                 for (const cycle of result.circularDependencies.slice(0, 5)) {
                     const severityColor = cycle.severity === 'high' ? output.error : cycle.severity === 'medium' ? output.warning : output.dim;
-                    output.writeln(`${severityColor(`[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
+                    output.writeln(`${severityColor.call(output, `[${cycle.severity.toUpperCase()}]`)} ${cycle.cycle.join(' -> ')}`);
                     output.writeln(output.dim(`  ${cycle.suggestion}`));
                     output.writeln();
                 }
@@ -1905,7 +1905,7 @@ const circularCommand = {
                 if (items.length === 0)
                     continue;
                 const color = severity === 'high' ? output.error : severity === 'medium' ? output.warning : output.dim;
-                output.writeln(color(output.bold(`${severity.toUpperCase()} SEVERITY (${items.length})`)));
+                output.writeln(color.call(output, output.bold(`${severity.toUpperCase()} SEVERITY (${items.length})`)));
                 output.writeln();
                 for (const cycle of items.slice(0, 5)) {
                     output.writeln(`  ${cycle.cycle.join(' -> ')}`);

package/dist/src/commands/config.js

@@ -124,15 +124,13 @@ const setCommand = {
             name: 'key',
             short: 'k',
             description: 'Configuration key',
-            type: 'string',
-            required: true
+            type: 'string'
         },
         {
             name: 'value',
             short: 'v',
             description: 'Configuration value',
-            type: 'string',
-            required: true
+            type: 'string'
         }
     ],
     examples: [
@@ -140,14 +138,14 @@ const setCommand = {
         { command: 'claude-flow config set -k memory.backend -v agentdb', description: 'Set memory backend' }
     ],
     action: async (ctx) => {
-        const key = ctx.flags.key || ctx.args[0];
-        const value = ctx.flags.value || ctx.args[1];
+        const key = (ctx.flags.key ?? ctx.args[0]);
+        const value = ctx.flags.value ?? ctx.args[1];
         if (!key || value === undefined) {
             output.printError('Both key and value are required');
             return { success: false, exitCode: 1 };
         }
         try {
-            const parsedValue = parseConfigValue(value);
+            const parsedValue = parseConfigValue(String(value));
             configManager.set(ctx.cwd, key, parsedValue);
             output.writeln(`Set ${key} = ${value}`);
             return { success: true };

package/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/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/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.