kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/memory.js

@@ -2,65 +2,18 @@
  * V3 CLI Memory Command
  * Memory operations for AgentDB integration
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 // Memory backends
-var BACKENDS = [
+const BACKENDS = [
     { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
     { 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' }
 ];
 // Store command
-var storeCommand = {
+const storeCommand = {
     name: 'store',
     description: 'Store data in memory',
     options: [
@@ -82,7 +35,7 @@ var storeCommand = {
             short: 'n',
             description: 'Memory namespace',
             type: 'string',
-            "default": 'default'
+            default: 'default'
         },
         {
             name: 'ttl',
@@ -98,14 +51,14 @@ var storeCommand = {
             name: 'vector',
             description: 'Store as vector embedding',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'upsert',
             short: 'u',
             description: 'Update if key exists (insert or replace)',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -113,100 +66,86 @@ var storeCommand = {
         { command: 'claude-flow memory store -k "pattern/singleton" --vector', description: 'Store vector' },
         { command: 'claude-flow memory store -k "pattern" -v "updated" --upsert', description: 'Update existing' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var key, value, namespace, ttl, tags, asVector, upsert, storeData, storeEntry, result, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = ctx.flags.key;
-                    value = ctx.flags.value || ctx.args[0];
-                    namespace = ctx.flags.namespace;
-                    ttl = ctx.flags.ttl;
-                    tags = ctx.flags.tags ? ctx.flags.tags.split(',') : [];
-                    asVector = ctx.flags.vector;
-                    upsert = ctx.flags.upsert;
-                    if (!key) {
-                        output.printError('Key is required. Use --key or -k');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!(!value && ctx.interactive)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, input({
-                            message: 'Enter value to store:',
-                            validate: function (v) { return v.length > 0 || 'Value is required'; }
-                        })];
-                case 1:
-                    value = _a.sent();
-                    _a.label = 2;
-                case 2:
-                    if (!value) {
-                        output.printError('Value is required. Use --value');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    storeData = {
-                        key: key,
-                        namespace: namespace,
-                        value: value,
-                        ttl: ttl,
-                        tags: tags,
-                        asVector: asVector,
-                        storedAt: new Date().toISOString(),
-                        size: Buffer.byteLength(value, 'utf8')
-                    };
-                    output.printInfo("Storing in " + namespace + "/" + key + "...");
-                    _a.label = 3;
-                case 3:
-                    _a.trys.push([3, 6, , 7]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 4:
-                    storeEntry = (_a.sent()).storeEntry;
-                    if (asVector) {
-                        output.writeln(output.dim('  Generating embedding vector...'));
-                    }
-                    return [4 /*yield*/, storeEntry({
-                            key: key,
-                            value: value,
-                            namespace: namespace,
-                            generateEmbeddingFlag: true,
-                            tags: tags,
-                            ttl: ttl,
-                            upsert: upsert
-                        })];
-                case 5:
-                    result = _a.sent();
-                    if (!result.success) {
-                        output.printError(result.error || 'Failed to store');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'property', header: 'Property', width: 15 },
-                            { key: 'val', header: 'Value', width: 40 }
-                        ],
-                        data: [
-                            { property: 'Key', val: key },
-                            { property: 'Namespace', val: namespace },
-                            { property: 'Size', val: storeData.size + " bytes" },
-                            { property: 'TTL', val: ttl ? ttl + "s" : 'None' },
-                            { property: 'Tags', val: tags.length > 0 ? tags.join(', ') : 'None' },
-                            { property: 'Vector', val: result.embedding ? "Yes (" + result.embedding.dimensions + "-dim)" : 'No' },
-                            { property: 'ID', val: result.id.substring(0, 20) }
-                        ]
-                    });
-                    output.writeln();
-                    output.printSuccess('Data stored successfully');
-                    return [2 /*return*/, { success: true, data: __assign(__assign({}, storeData), { id: result.id, embedding: result.embedding }) }];
-                case 6:
-                    error_1 = _a.sent();
-                    output.printError("Failed to store: " + (error_1 instanceof Error ? error_1.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 7: return [2 /*return*/];
+    action: async (ctx) => {
+        const key = ctx.flags.key;
+        let value = ctx.flags.value || ctx.args[0];
+        const namespace = ctx.flags.namespace;
+        const ttl = ctx.flags.ttl;
+        const tags = ctx.flags.tags ? ctx.flags.tags.split(',') : [];
+        const asVector = ctx.flags.vector;
+        const upsert = ctx.flags.upsert;
+        if (!key) {
+            output.printError('Key is required. Use --key or -k');
+            return { success: false, exitCode: 1 };
+        }
+        if (!value && ctx.interactive) {
+            value = await input({
+                message: 'Enter value to store:',
+                validate: (v) => v.length > 0 || 'Value is required'
+            });
+        }
+        if (!value) {
+            output.printError('Value is required. Use --value');
+            return { success: false, exitCode: 1 };
+        }
+        const storeData = {
+            key,
+            namespace,
+            value,
+            ttl,
+            tags,
+            asVector,
+            storedAt: new Date().toISOString(),
+            size: Buffer.byteLength(value, 'utf8')
+        };
+        output.printInfo(`Storing in ${namespace}/${key}...`);
+        // Use direct sql.js storage with automatic embedding generation
+        try {
+            const { storeEntry } = await import('../memory/memory-initializer.js');
+            if (asVector) {
+                output.writeln(output.dim('  Generating embedding vector...'));
             }
-        });
-    }); }
+            const result = await storeEntry({
+                key,
+                value,
+                namespace,
+                generateEmbeddingFlag: true, // Always generate embeddings for semantic search
+                tags,
+                ttl,
+                upsert
+            });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to store');
+                return { success: false, exitCode: 1 };
+            }
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'property', header: 'Property', width: 15 },
+                    { key: 'val', header: 'Value', width: 40 }
+                ],
+                data: [
+                    { property: 'Key', val: key },
+                    { property: 'Namespace', val: namespace },
+                    { property: 'Size', val: `${storeData.size} bytes` },
+                    { property: 'TTL', val: ttl ? `${ttl}s` : 'None' },
+                    { property: 'Tags', val: tags.length > 0 ? tags.join(', ') : 'None' },
+                    { property: 'Vector', val: result.embedding ? `Yes (${result.embedding.dimensions}-dim)` : 'No' },
+                    { property: 'ID', val: result.id.substring(0, 20) }
+                ]
+            });
+            output.writeln();
+            output.printSuccess('Data stored successfully');
+            return { success: true, data: { ...storeData, id: result.id, embedding: result.embedding } };
+        }
+        catch (error) {
+            output.printError(`Failed to store: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Retrieve command
-var retrieveCommand = {
+const retrieveCommand = {
     name: 'retrieve',
     aliases: ['get'],
     description: 'Retrieve data from memory',
@@ -222,66 +161,55 @@ var retrieveCommand = {
             short: 'n',
             description: 'Memory namespace',
             type: 'string',
-            "default": 'default'
+            default: 'default'
         }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var key, namespace, getEntry, result, entry, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = ctx.flags.key || ctx.args[0];
-                    namespace = ctx.flags.namespace;
-                    if (!key) {
-                        output.printError('Key is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    getEntry = (_a.sent()).getEntry;
-                    return [4 /*yield*/, getEntry({ key: key, namespace: namespace })];
-                case 3:
-                    result = _a.sent();
-                    if (!result.success) {
-                        output.printError("Failed to retrieve: " + result.error);
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!result.found || !result.entry) {
-                        output.printWarning("Key not found: " + key);
-                        return [2 /*return*/, { success: false, exitCode: 1, data: { key: key, found: false } }];
-                    }
-                    entry = result.entry;
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(entry);
-                        return [2 /*return*/, { success: true, data: entry }];
-                    }
-                    output.writeln();
-                    output.printBox([
-                        "Namespace: " + entry.namespace,
-                        "Key: " + entry.key,
-                        "Size: " + entry.content.length + " bytes",
-                        "Access Count: " + entry.accessCount,
-                        "Tags: " + (entry.tags.length > 0 ? entry.tags.join(', ') : 'None'),
-                        "Vector: " + (entry.hasEmbedding ? 'Yes' : 'No'),
-                        '',
-                        output.bold('Value:'),
-                        entry.content
-                    ].join('\n'), 'Memory Entry');
-                    return [2 /*return*/, { success: true, data: entry }];
-                case 4:
-                    error_2 = _a.sent();
-                    output.printError("Failed to retrieve: " + (error_2 instanceof Error ? error_2.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [2 /*return*/];
+    action: async (ctx) => {
+        const key = ctx.flags.key || ctx.args[0];
+        const namespace = ctx.flags.namespace;
+        if (!key) {
+            output.printError('Key is required');
+            return { success: false, exitCode: 1 };
+        }
+        // Use sql.js directly for consistent data access
+        try {
+            const { getEntry } = await import('../memory/memory-initializer.js');
+            const result = await getEntry({ key, namespace });
+            if (!result.success) {
+                output.printError(`Failed to retrieve: ${result.error}`);
+                return { success: false, exitCode: 1 };
             }
-        });
-    }); }
+            if (!result.found || !result.entry) {
+                output.printWarning(`Key not found: ${key}`);
+                return { success: false, exitCode: 1, data: { key, found: false } };
+            }
+            const entry = result.entry;
+            if (ctx.flags.format === 'json') {
+                output.printJson(entry);
+                return { success: true, data: entry };
+            }
+            output.writeln();
+            output.printBox([
+                `Namespace: ${entry.namespace}`,
+                `Key: ${entry.key}`,
+                `Size: ${entry.content.length} bytes`,
+                `Access Count: ${entry.accessCount}`,
+                `Tags: ${entry.tags.length > 0 ? entry.tags.join(', ') : 'None'}`,
+                `Vector: ${entry.hasEmbedding ? 'Yes' : 'No'}`,
+                '',
+                output.bold('Value:'),
+                entry.content
+            ].join('\n'), 'Memory Entry');
+            return { success: true, data: entry };
+        }
+        catch (error) {
+            output.printError(`Failed to retrieve: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Search command
-var searchCommand = {
+const searchCommand = {
     name: 'search',
     description: 'Search memory with semantic/vector search',
     options: [
@@ -303,27 +231,27 @@ var searchCommand = {
             short: 'l',
             description: 'Maximum results',
             type: 'number',
-            "default": 10
+            default: 10
         },
         {
             name: 'threshold',
             description: 'Similarity threshold (0-1)',
             type: 'number',
-            "default": 0.7
+            default: 0.7
         },
         {
             name: 'type',
             short: 't',
             description: 'Search type (semantic, keyword, hybrid)',
             type: 'string',
-            "default": 'semantic',
+            default: 'semantic',
             choices: ['semantic', 'keyword', 'hybrid']
         },
         {
             name: 'build-hnsw',
             description: 'Build/rebuild HNSW index before searching (enables 150x-12,500x speedup)',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -331,113 +259,96 @@ var searchCommand = {
         { command: 'claude-flow memory search -q "JWT" -t keyword', description: 'Keyword search' },
         { command: 'claude-flow memory search -q "test" --build-hnsw', description: 'Build HNSW index and search' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var query, namespace, limit, threshold, searchType, buildHnsw, _a, getHNSWIndex, getHNSWStatus, startTime, index, buildTime, status, error_3, searchEntries, searchResult, results, error_4;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    query = ctx.flags.query || ctx.args[0];
-                    namespace = ctx.flags.namespace || 'all';
-                    limit = ctx.flags.limit || 10;
-                    threshold = ctx.flags.threshold || 0.3;
-                    searchType = ctx.flags.type || 'semantic';
-                    buildHnsw = (ctx.flags['build-hnsw'] || ctx.flags.buildHnsw);
-                    if (!query) {
-                        output.printError('Query is required. Use --query or -q');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!buildHnsw) return [3 /*break*/, 5];
-                    output.printInfo('Building HNSW index...');
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _b.sent(), getHNSWIndex = _a.getHNSWIndex, getHNSWStatus = _a.getHNSWStatus;
-                    startTime = Date.now();
-                    return [4 /*yield*/, getHNSWIndex({ forceRebuild: true })];
-                case 3:
-                    index = _b.sent();
-                    buildTime = Date.now() - startTime;
-                    if (index) {
-                        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)');
-                    }
-                    output.writeln();
-                    return [3 /*break*/, 5];
-                case 4:
-                    error_3 = _b.sent();
-                    output.printWarning("HNSW build failed: " + (error_3 instanceof Error ? error_3.message : 'Unknown error'));
-                    output.writeln(output.dim('  Falling back to brute-force search'));
-                    output.writeln();
-                    return [3 /*break*/, 5];
-                case 5:
-                    output.printInfo("Searching: \"" + query + "\" (" + searchType + ")");
-                    output.writeln();
-                    _b.label = 6;
-                case 6:
-                    _b.trys.push([6, 9, , 10]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 7:
-                    searchEntries = (_b.sent()).searchEntries;
-                    return [4 /*yield*/, searchEntries({
-                            query: query,
-                            namespace: namespace,
-                            limit: limit,
-                            threshold: threshold
-                        })];
-                case 8:
-                    searchResult = _b.sent();
-                    if (!searchResult.success) {
-                        output.printError(searchResult.error || 'Search failed');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    results = searchResult.results.map(function (r) { return ({
-                        key: r.key,
-                        score: r.score,
-                        namespace: r.namespace,
-                        preview: r.content
-                    }); });
-                    if (ctx.flags.format === 'json') {
-                        output.printJson({ query: query, searchType: searchType, results: results, searchTime: searchResult.searchTime + "ms" });
-                        return [2 /*return*/, { success: true, data: results }];
-                    }
-                    // Performance stats
-                    output.writeln(output.dim("  Search time: " + searchResult.searchTime + "ms"));
-                    output.writeln();
-                    if (results.length === 0) {
-                        output.printWarning('No results found');
-                        output.writeln(output.dim('Try: claude-flow memory store -k "key" --value "data"'));
-                        return [2 /*return*/, { success: true, data: [] }];
-                    }
-                    output.printTable({
-                        columns: [
-                            { key: 'key', header: 'Key', width: 20 },
-                            { key: 'score', header: 'Score', width: 8, align: 'right', format: function (v) { return Number(v).toFixed(2); } },
-                            { key: 'namespace', header: 'Namespace', width: 12 },
-                            { key: 'preview', header: 'Preview', width: 35 }
-                        ],
-                        data: results
-                    });
-                    output.writeln();
-                    output.printInfo("Found " + results.length + " results");
-                    return [2 /*return*/, { success: true, data: results }];
-                case 9:
-                    error_4 = _b.sent();
-                    output.printError("Search failed: " + (error_4 instanceof Error ? error_4.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 10: return [2 /*return*/];
+    action: async (ctx) => {
+        const query = ctx.flags.query || ctx.args[0];
+        const namespace = ctx.flags.namespace || 'all';
+        const limit = ctx.flags.limit || 10;
+        const threshold = ctx.flags.threshold || 0.3;
+        const searchType = ctx.flags.type || 'semantic';
+        const buildHnsw = (ctx.flags['build-hnsw'] || ctx.flags.buildHnsw);
+        if (!query) {
+            output.printError('Query is required. Use --query or -q');
+            return { success: false, exitCode: 1 };
+        }
+        // Build/rebuild HNSW index if requested
+        if (buildHnsw) {
+            output.printInfo('Building HNSW index...');
+            try {
+                const { getHNSWIndex, getHNSWStatus } = await import('../memory/memory-initializer.js');
+                const startTime = Date.now();
+                const index = await getHNSWIndex({ forceRebuild: true });
+                const buildTime = Date.now() - startTime;
+                if (index) {
+                    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)');
+                }
+                output.writeln();
             }
-        });
-    }); }
+            catch (error) {
+                output.printWarning(`HNSW build failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                output.writeln(output.dim('  Falling back to brute-force search'));
+                output.writeln();
+            }
+        }
+        output.printInfo(`Searching: "${query}" (${searchType})`);
+        output.writeln();
+        // Use direct sql.js search with vector similarity
+        try {
+            const { searchEntries } = await import('../memory/memory-initializer.js');
+            const searchResult = await searchEntries({
+                query,
+                namespace,
+                limit,
+                threshold
+            });
+            if (!searchResult.success) {
+                output.printError(searchResult.error || 'Search failed');
+                return { success: false, exitCode: 1 };
+            }
+            const results = searchResult.results.map(r => ({
+                key: r.key,
+                score: r.score,
+                namespace: r.namespace,
+                preview: r.content
+            }));
+            if (ctx.flags.format === 'json') {
+                output.printJson({ query, searchType, results, searchTime: `${searchResult.searchTime}ms` });
+                return { success: true, data: results };
+            }
+            // Performance stats
+            output.writeln(output.dim(`  Search time: ${searchResult.searchTime}ms`));
+            output.writeln();
+            if (results.length === 0) {
+                output.printWarning('No results found');
+                output.writeln(output.dim('Try: claude-flow memory store -k "key" --value "data"'));
+                return { success: true, data: [] };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'key', header: 'Key', width: 20 },
+                    { key: 'score', header: 'Score', width: 8, align: 'right', format: (v) => Number(v).toFixed(2) },
+                    { key: 'namespace', header: 'Namespace', width: 12 },
+                    { key: 'preview', header: 'Preview', width: 35 }
+                ],
+                data: results
+            });
+            output.writeln();
+            output.printInfo(`Found ${results.length} results`);
+            return { success: true, data: results };
+        }
+        catch (error) {
+            output.printError(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // List command
-var listCommand = {
+const listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List memory entries',
@@ -459,91 +370,81 @@ var listCommand = {
             short: 'l',
             description: 'Maximum entries',
             type: 'number',
-            "default": 20
+            default: 20
         }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var namespace, limit, listEntries, listResult, entries, error_5;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    namespace = ctx.flags.namespace;
-                    limit = ctx.flags.limit;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    listEntries = (_a.sent()).listEntries;
-                    return [4 /*yield*/, listEntries({ namespace: namespace, limit: limit, offset: 0 })];
-                case 3:
-                    listResult = _a.sent();
-                    if (!listResult.success) {
-                        output.printError("Failed to list: " + listResult.error);
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    entries = listResult.entries.map(function (e) { return ({
-                        key: e.key,
-                        namespace: e.namespace,
-                        size: e.size + ' B',
-                        vector: e.hasEmbedding ? '✓' : '-',
-                        accessCount: e.accessCount,
-                        updated: formatRelativeTime(e.updatedAt)
-                    }); });
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(listResult.entries);
-                        return [2 /*return*/, { success: true, data: listResult.entries }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Memory Entries'));
-                    output.writeln();
-                    if (entries.length === 0) {
-                        output.printWarning('No entries found');
-                        output.printInfo('Store data: claude-flow memory store -k "key" --value "data"');
-                        return [2 /*return*/, { success: true, data: [] }];
-                    }
-                    output.printTable({
-                        columns: [
-                            { key: 'key', header: 'Key', width: 25 },
-                            { key: 'namespace', header: 'Namespace', width: 12 },
-                            { key: 'size', header: 'Size', width: 10, align: 'right' },
-                            { key: 'vector', header: 'Vector', width: 8, align: 'center' },
-                            { key: 'accessCount', header: 'Accessed', width: 10, align: 'right' },
-                            { key: 'updated', header: 'Updated', width: 12 }
-                        ],
-                        data: entries
-                    });
-                    output.writeln();
-                    output.printInfo("Showing " + entries.length + " of " + listResult.total + " entries");
-                    return [2 /*return*/, { success: true, data: listResult.entries }];
-                case 4:
-                    error_5 = _a.sent();
-                    output.printError("Failed to list: " + (error_5 instanceof Error ? error_5.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [2 /*return*/];
+    action: async (ctx) => {
+        const namespace = ctx.flags.namespace;
+        const limit = ctx.flags.limit;
+        // Use sql.js directly for consistent data access
+        try {
+            const { listEntries } = await import('../memory/memory-initializer.js');
+            const listResult = await listEntries({ namespace, limit, offset: 0 });
+            if (!listResult.success) {
+                output.printError(`Failed to list: ${listResult.error}`);
+                return { success: false, exitCode: 1 };
             }
-        });
-    }); }
+            // Format entries for display
+            const entries = listResult.entries.map(e => ({
+                key: e.key,
+                namespace: e.namespace,
+                size: e.size + ' B',
+                vector: e.hasEmbedding ? '✓' : '-',
+                accessCount: e.accessCount,
+                updated: formatRelativeTime(e.updatedAt)
+            }));
+            if (ctx.flags.format === 'json') {
+                output.printJson(listResult.entries);
+                return { success: true, data: listResult.entries };
+            }
+            output.writeln();
+            output.writeln(output.bold('Memory Entries'));
+            output.writeln();
+            if (entries.length === 0) {
+                output.printWarning('No entries found');
+                output.printInfo('Store data: claude-flow memory store -k "key" --value "data"');
+                return { success: true, data: [] };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'key', header: 'Key', width: 25 },
+                    { key: 'namespace', header: 'Namespace', width: 12 },
+                    { key: 'size', header: 'Size', width: 10, align: 'right' },
+                    { key: 'vector', header: 'Vector', width: 8, align: 'center' },
+                    { key: 'accessCount', header: 'Accessed', width: 10, align: 'right' },
+                    { key: 'updated', header: 'Updated', width: 12 }
+                ],
+                data: entries
+            });
+            output.writeln();
+            output.printInfo(`Showing ${entries.length} of ${listResult.total} entries`);
+            return { success: true, data: listResult.entries };
+        }
+        catch (error) {
+            output.printError(`Failed to list: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Helper function to format relative time
 function formatRelativeTime(isoDate) {
-    var now = Date.now();
-    var date = new Date(isoDate).getTime();
-    var diff = now - date;
-    var seconds = Math.floor(diff / 1000);
-    var minutes = Math.floor(seconds / 60);
-    var hours = Math.floor(minutes / 60);
-    var days = Math.floor(hours / 24);
+    const now = Date.now();
+    const date = new Date(isoDate).getTime();
+    const diff = now - date;
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
     if (days > 0)
-        return days + "d ago";
+        return `${days}d ago`;
     if (hours > 0)
-        return hours + "h ago";
+        return `${hours}h ago`;
     if (minutes > 0)
-        return minutes + "m ago";
+        return `${minutes}m ago`;
     return 'just now';
 }
 // Delete command
-var deleteCommand = {
+const deleteCommand = {
     name: 'delete',
     aliases: ['rm'],
     description: 'Delete memory entry',
@@ -559,14 +460,14 @@ var deleteCommand = {
             short: 'n',
             description: 'Memory namespace',
             type: 'string',
-            "default": 'default'
+            default: 'default'
         },
         {
             name: 'force',
             short: 'f',
             description: 'Skip confirmation',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -574,134 +475,116 @@ var deleteCommand = {
         { command: 'claude-flow memory delete -k "lesson" -n "lessons"', description: 'Delete entry from specific namespace' },
         { command: 'claude-flow memory delete mykey -f', description: 'Delete without confirmation' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var key, namespace, force, confirmed, deleteEntry, result, error_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = ctx.flags.key || ctx.args[0];
-                    namespace = ctx.flags.namespace || 'default';
-                    force = ctx.flags.force;
-                    if (!key) {
-                        output.printError('Key is required. Use: memory delete -k "key" [-n "namespace"]');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, confirm({
-                            message: "Delete memory entry \"" + key + "\" from namespace \"" + namespace + "\"?",
-                            "default": false
-                        })];
-                case 1:
-                    confirmed = _a.sent();
-                    if (!confirmed) {
-                        output.printInfo('Operation cancelled');
-                        return [2 /*return*/, { success: true }];
-                    }
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 3:
-                    deleteEntry = (_a.sent()).deleteEntry;
-                    return [4 /*yield*/, deleteEntry({ key: key, namespace: namespace })];
-                case 4:
-                    result = _a.sent();
-                    if (!result.success) {
-                        output.printError(result.error || 'Failed to delete');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (result.deleted) {
-                        output.printSuccess("Deleted \"" + key + "\" from namespace \"" + namespace + "\"");
-                        output.printInfo("Remaining entries: " + result.remainingEntries);
-                    }
-                    else {
-                        output.printWarning("Key not found: \"" + key + "\" in namespace \"" + namespace + "\"");
-                    }
-                    return [2 /*return*/, { success: result.deleted, data: result }];
-                case 5:
-                    error_6 = _a.sent();
-                    output.printError("Failed to delete: " + (error_6 instanceof Error ? error_6.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
+    action: async (ctx) => {
+        // Support both --key flag and positional argument
+        const key = ctx.flags.key || ctx.args[0];
+        const namespace = ctx.flags.namespace || 'default';
+        const force = ctx.flags.force;
+        if (!key) {
+            output.printError('Key is required. Use: memory delete -k "key" [-n "namespace"]');
+            return { success: false, exitCode: 1 };
+        }
+        if (!force && ctx.interactive) {
+            const confirmed = await confirm({
+                message: `Delete memory entry "${key}" from namespace "${namespace}"?`,
+                default: false
+            });
+            if (!confirmed) {
+                output.printInfo('Operation cancelled');
+                return { success: true };
             }
-        });
-    }); }
+        }
+        // Use sql.js directly for consistent data access (Issue #980)
+        try {
+            const { deleteEntry } = await import('../memory/memory-initializer.js');
+            const result = await deleteEntry({ key, namespace });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to delete');
+                return { success: false, exitCode: 1 };
+            }
+            if (result.deleted) {
+                output.printSuccess(`Deleted "${key}" from namespace "${namespace}"`);
+                output.printInfo(`Remaining entries: ${result.remainingEntries}`);
+            }
+            else {
+                output.printWarning(`Key not found: "${key}" in namespace "${namespace}"`);
+            }
+            return { success: result.deleted, data: result };
+        }
+        catch (error) {
+            output.printError(`Failed to delete: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Stats command
-var statsCommand = {
+const statsCommand = {
     name: 'stats',
     description: 'Show memory statistics',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var statsResult, stats, error_7;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, callMCPTool('memory_stats', {})];
-                case 1:
-                    statsResult = _a.sent();
-                    stats = {
-                        backend: statsResult.backend,
-                        entries: {
-                            total: statsResult.totalEntries,
-                            vectors: 0,
-                            text: statsResult.totalEntries
-                        },
-                        storage: {
-                            total: statsResult.totalSize,
-                            location: statsResult.location
-                        },
-                        version: statsResult.version,
-                        oldestEntry: statsResult.oldestEntry,
-                        newestEntry: statsResult.newestEntry
-                    };
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(stats);
-                        return [2 /*return*/, { success: true, data: stats }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Memory Statistics'));
-                    output.writeln();
-                    output.writeln(output.bold('Overview'));
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 20 },
-                            { key: 'value', header: 'Value', width: 30, align: 'right' }
-                        ],
-                        data: [
-                            { metric: 'Backend', value: stats.backend },
-                            { metric: 'Version', value: stats.version },
-                            { metric: 'Total Entries', value: stats.entries.total.toLocaleString() },
-                            { metric: 'Total Storage', value: stats.storage.total },
-                            { metric: 'Location', value: stats.storage.location }
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.bold('Timeline'));
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 20 },
-                            { key: 'value', header: 'Value', width: 30, align: 'right' }
-                        ],
-                        data: [
-                            { metric: 'Oldest Entry', value: stats.oldestEntry || 'N/A' },
-                            { metric: 'Newest Entry', value: stats.newestEntry || 'N/A' }
-                        ]
-                    });
-                    output.writeln();
-                    output.printInfo('V3 Performance: 150x-12,500x faster search with HNSW indexing');
-                    return [2 /*return*/, { success: true, data: stats }];
-                case 2:
-                    error_7 = _a.sent();
-                    output.printError("Failed to get stats: " + (error_7 instanceof Error ? error_7.message : 'Unknown error'));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 3: return [2 /*return*/];
+    action: async (ctx) => {
+        // Call MCP memory/stats tool for real statistics
+        try {
+            const statsResult = await callMCPTool('memory_stats', {});
+            const stats = {
+                backend: statsResult.backend,
+                entries: {
+                    total: statsResult.totalEntries,
+                    vectors: 0, // Would need vector backend support
+                    text: statsResult.totalEntries
+                },
+                storage: {
+                    total: statsResult.totalSize,
+                    location: statsResult.location
+                },
+                version: statsResult.version,
+                oldestEntry: statsResult.oldestEntry,
+                newestEntry: statsResult.newestEntry
+            };
+            if (ctx.flags.format === 'json') {
+                output.printJson(stats);
+                return { success: true, data: stats };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Memory Statistics'));
+            output.writeln();
+            output.writeln(output.bold('Overview'));
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 20 },
+                    { key: 'value', header: 'Value', width: 30, align: 'right' }
+                ],
+                data: [
+                    { metric: 'Backend', value: stats.backend },
+                    { metric: 'Version', value: stats.version },
+                    { metric: 'Total Entries', value: stats.entries.total.toLocaleString() },
+                    { metric: 'Total Storage', value: stats.storage.total },
+                    { metric: 'Location', value: stats.storage.location }
+                ]
+            });
+            output.writeln();
+            output.writeln(output.bold('Timeline'));
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 20 },
+                    { key: 'value', header: 'Value', width: 30, align: 'right' }
+                ],
+                data: [
+                    { metric: 'Oldest Entry', value: stats.oldestEntry || 'N/A' },
+                    { metric: 'Newest Entry', value: stats.newestEntry || 'N/A' }
+                ]
+            });
+            output.writeln();
+            output.printInfo('V3 Performance: 150x-12,500x faster search with HNSW indexing');
+            return { success: true, data: stats };
+        }
+        catch (error) {
+            output.printError(`Failed to get stats: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Configure command
-var configureCommand = {
+const configureCommand = {
     name: 'configure',
     aliases: ['config'],
     description: 'Configure memory backend',
@@ -711,7 +594,7 @@ var configureCommand = {
             short: 'b',
             description: 'Memory backend',
             type: 'string',
-            choices: BACKENDS.map(function (b) { return b.value; })
+            choices: BACKENDS.map(b => b.value)
         },
         {
             name: 'path',
@@ -727,65 +610,56 @@ var configureCommand = {
             name: 'hnsw-m',
             description: 'HNSW M parameter',
             type: 'number',
-            "default": 16
+            default: 16
         },
         {
             name: 'hnsw-ef',
             description: 'HNSW ef parameter',
             type: 'number',
-            "default": 200
+            default: 200
         }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var backend, config;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    backend = ctx.flags.backend;
-                    if (!(!backend && ctx.interactive)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, select({
-                            message: 'Select memory backend:',
-                            options: BACKENDS,
-                            "default": 'hybrid'
-                        })];
-                case 1:
-                    backend = _a.sent();
-                    _a.label = 2;
-                case 2:
-                    config = {
-                        backend: backend || 'hybrid',
-                        path: ctx.flags.path || './data/memory',
-                        cacheSize: ctx.flags.cacheSize || 256,
-                        hnsw: {
-                            m: ctx.flags.hnswM || 16,
-                            ef: ctx.flags.hnswEf || 200
-                        }
-                    };
-                    output.writeln();
-                    output.printInfo('Memory Configuration');
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'setting', header: 'Setting', width: 20 },
-                            { key: 'value', header: 'Value', width: 25 }
-                        ],
-                        data: [
-                            { setting: 'Backend', value: config.backend },
-                            { setting: 'Storage Path', value: config.path },
-                            { setting: 'Cache Size', value: config.cacheSize + " MB" },
-                            { setting: 'HNSW M', value: config.hnsw.m },
-                            { setting: 'HNSW ef', value: config.hnsw.ef }
-                        ]
-                    });
-                    output.writeln();
-                    output.printSuccess('Memory configuration updated');
-                    return [2 /*return*/, { success: true, data: config }];
+    action: async (ctx) => {
+        let backend = ctx.flags.backend;
+        if (!backend && ctx.interactive) {
+            backend = await select({
+                message: 'Select memory backend:',
+                options: BACKENDS,
+                default: 'hybrid'
+            });
+        }
+        const config = {
+            backend: backend || 'hybrid',
+            path: ctx.flags.path || './data/memory',
+            cacheSize: ctx.flags.cacheSize || 256,
+            hnsw: {
+                m: ctx.flags.hnswM || 16,
+                ef: ctx.flags.hnswEf || 200
             }
+        };
+        output.writeln();
+        output.printInfo('Memory Configuration');
+        output.writeln();
+        output.printTable({
+            columns: [
+                { key: 'setting', header: 'Setting', width: 20 },
+                { key: 'value', header: 'Value', width: 25 }
+            ],
+            data: [
+                { setting: 'Backend', value: config.backend },
+                { setting: 'Storage Path', value: config.path },
+                { setting: 'Cache Size', value: `${config.cacheSize} MB` },
+                { setting: 'HNSW M', value: config.hnsw.m },
+                { setting: 'HNSW ef', value: config.hnsw.ef }
+            ]
         });
-    }); }
+        output.writeln();
+        output.printSuccess('Memory configuration updated');
+        return { success: true, data: config };
+    }
 };
 // Cleanup command
-var cleanupCommand = {
+const cleanupCommand = {
     name: 'cleanup',
     description: 'Clean up stale and expired memory entries',
     options: [
@@ -794,7 +668,7 @@ var cleanupCommand = {
             short: 'd',
             description: 'Show what would be deleted',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'older-than',
@@ -807,7 +681,7 @@ var cleanupCommand = {
             short: 'e',
             description: 'Only delete expired TTL entries',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'low-quality',
@@ -826,7 +700,7 @@ var cleanupCommand = {
             short: 'f',
             description: 'Skip confirmation',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -834,87 +708,74 @@ var cleanupCommand = {
         { command: 'claude-flow memory cleanup --older-than 30d', description: 'Delete entries older than 30 days' },
         { command: 'claude-flow memory cleanup --expired-only', description: 'Clean expired entries' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var dryRun, force, result, confirmed, error_8;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    dryRun = ctx.flags.dryRun;
-                    force = ctx.flags.force;
-                    if (dryRun) {
-                        output.writeln(output.warning('DRY RUN - No changes will be made'));
-                    }
-                    output.printInfo('Analyzing memory for cleanup...');
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 5, , 6]);
-                    return [4 /*yield*/, callMCPTool('memory_cleanup', {
-                            dryRun: dryRun,
-                            olderThan: ctx.flags.olderThan,
-                            expiredOnly: ctx.flags.expiredOnly,
-                            lowQualityThreshold: ctx.flags.lowQuality,
-                            namespace: ctx.flags.namespace
-                        })];
-                case 2:
-                    result = _a.sent();
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(result);
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Cleanup Analysis'));
-                    output.printTable({
-                        columns: [
-                            { key: 'category', header: 'Category', width: 20 },
-                            { key: 'count', header: 'Count', width: 15, align: 'right' }
-                        ],
-                        data: [
-                            { category: 'Expired (TTL)', count: result.candidates.expired },
-                            { category: 'Stale (unused)', count: result.candidates.stale },
-                            { category: 'Low Quality', count: result.candidates.lowQuality },
-                            { category: output.bold('Total'), count: output.bold(String(result.candidates.total)) }
-                        ]
-                    });
-                    if (!(!dryRun && result.candidates.total > 0 && !force)) return [3 /*break*/, 4];
-                    return [4 /*yield*/, confirm({
-                            message: "Delete " + result.candidates.total + " entries (" + result.freed.formatted + ")?",
-                            "default": false
-                        })];
-                case 3:
-                    confirmed = _a.sent();
-                    if (!confirmed) {
-                        output.printInfo('Cleanup cancelled');
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    _a.label = 4;
-                case 4:
-                    if (!dryRun) {
-                        output.writeln();
-                        output.printSuccess("Cleaned " + result.deleted.entries + " entries");
-                        output.printList([
-                            "Vectors removed: " + result.deleted.vectors,
-                            "Patterns removed: " + result.deleted.patterns,
-                            "Space freed: " + result.freed.formatted,
-                            "Duration: " + result.duration + "ms"
-                        ]);
-                    }
-                    return [2 /*return*/, { success: true, data: result }];
-                case 5:
-                    error_8 = _a.sent();
-                    if (error_8 instanceof MCPClientError) {
-                        output.printError("Cleanup error: " + error_8.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_8));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
+    action: async (ctx) => {
+        const dryRun = ctx.flags.dryRun;
+        const force = ctx.flags.force;
+        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,
+                olderThan: ctx.flags.olderThan,
+                expiredOnly: ctx.flags.expiredOnly,
+                lowQualityThreshold: ctx.flags.lowQuality,
+                namespace: ctx.flags.namespace,
+            });
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Cleanup Analysis'));
+            output.printTable({
+                columns: [
+                    { key: 'category', header: 'Category', width: 20 },
+                    { key: 'count', header: 'Count', width: 15, align: 'right' }
+                ],
+                data: [
+                    { category: 'Expired (TTL)', count: result.candidates.expired },
+                    { category: 'Stale (unused)', count: result.candidates.stale },
+                    { category: 'Low Quality', count: result.candidates.lowQuality },
+                    { category: output.bold('Total'), count: output.bold(String(result.candidates.total)) }
+                ]
+            });
+            if (!dryRun && result.candidates.total > 0 && !force) {
+                const confirmed = await confirm({
+                    message: `Delete ${result.candidates.total} entries (${result.freed.formatted})?`,
+                    default: false
+                });
+                if (!confirmed) {
+                    output.printInfo('Cleanup cancelled');
+                    return { success: true, data: result };
+                }
+            }
+            if (!dryRun) {
+                output.writeln();
+                output.printSuccess(`Cleaned ${result.deleted.entries} entries`);
+                output.printList([
+                    `Vectors removed: ${result.deleted.vectors}`,
+                    `Patterns removed: ${result.deleted.patterns}`,
+                    `Space freed: ${result.freed.formatted}`,
+                    `Duration: ${result.duration}ms`
+                ]);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Cleanup error: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Compress command
-var compressCommand = {
+const compressCommand = {
     name: 'compress',
     description: 'Compress and optimize memory storage',
     options: [
@@ -924,7 +785,7 @@ var compressCommand = {
             description: 'Compression level (fast, balanced, max)',
             type: 'string',
             choices: ['fast', 'balanced', 'max'],
-            "default": 'balanced'
+            default: 'balanced'
         },
         {
             name: 'target',
@@ -932,27 +793,27 @@ var compressCommand = {
             description: 'Target (vectors, text, patterns, all)',
             type: 'string',
             choices: ['vectors', 'text', 'patterns', 'all'],
-            "default": 'all'
+            default: 'all'
         },
         {
             name: 'quantize',
             short: 'z',
             description: 'Enable vector quantization (reduces memory 4-32x)',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'bits',
             description: 'Quantization bits (4, 8, 16)',
             type: 'number',
-            "default": 8
+            default: 8
         },
         {
             name: 'rebuild-index',
             short: 'r',
             description: 'Rebuild HNSW index after compression',
             type: 'boolean',
-            "default": true
+            default: true
         }
     ],
     examples: [
@@ -960,91 +821,80 @@ var compressCommand = {
         { command: 'claude-flow memory compress --quantize --bits 4', description: '4-bit quantization (32x reduction)' },
         { command: 'claude-flow memory compress -l max -t vectors', description: 'Max compression on vectors' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var level, target, quantize, bits, rebuildIndex, spinner, result, error_9;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    level = ctx.flags.level || 'balanced';
-                    target = ctx.flags.target || 'all';
-                    quantize = ctx.flags.quantize;
-                    bits = ctx.flags.bits || 8;
-                    rebuildIndex = (_a = ctx.flags.rebuildIndex) !== null && _a !== void 0 ? _a : true;
-                    output.writeln();
-                    output.writeln(output.bold('Memory Compression'));
-                    output.writeln(output.dim("Level: " + level + ", Target: " + target + ", Quantize: " + (quantize ? bits + "-bit" : 'no')));
-                    output.writeln();
-                    spinner = output.createSpinner({ text: 'Analyzing current storage...', spinner: 'dots' });
-                    spinner.start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, callMCPTool('memory_compress', {
-                            level: level,
-                            target: target,
-                            quantize: quantize,
-                            bits: bits,
-                            rebuildIndex: rebuildIndex
-                        })];
-                case 2:
-                    result = _b.sent();
-                    spinner.succeed('Compression complete');
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(result);
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Storage Comparison'));
-                    output.printTable({
-                        columns: [
-                            { key: 'category', header: 'Category', width: 15 },
-                            { key: 'before', header: 'Before', width: 12, align: 'right' },
-                            { key: 'after', header: 'After', width: 12, align: 'right' },
-                            { key: 'saved', header: 'Saved', width: 12, align: 'right' }
-                        ],
-                        data: [
-                            { category: 'Vectors', before: result.before.vectorsSize, after: result.after.vectorsSize, saved: '-' },
-                            { category: 'Text', before: result.before.textSize, after: result.after.textSize, saved: '-' },
-                            { category: 'Patterns', before: result.before.patternsSize, after: result.after.patternsSize, saved: '-' },
-                            { category: 'Index', before: result.before.indexSize, after: result.after.indexSize, saved: '-' },
-                            { category: output.bold('Total'), before: result.before.totalSize, after: result.after.totalSize, saved: output.success(result.compression.formattedSaved) }
-                        ]
-                    });
-                    output.writeln();
-                    output.printBox([
-                        "Compression Ratio: " + result.compression.ratio.toFixed(2) + "x",
-                        "Space Saved: " + result.compression.formattedSaved,
-                        "Quantization: " + (result.compression.quantizationApplied ? "Yes (" + bits + "-bit)" : 'No'),
-                        "Index Rebuilt: " + (result.compression.indexRebuilt ? 'Yes' : 'No'),
-                        "Duration: " + (result.duration / 1000).toFixed(1) + "s"
-                    ].join('\n'), 'Results');
-                    if (result.performance) {
-                        output.writeln();
-                        output.writeln(output.bold('Performance Impact'));
-                        output.printList([
-                            "Search latency: " + result.performance.searchLatencyBefore.toFixed(2) + "ms \u2192 " + result.performance.searchLatencyAfter.toFixed(2) + "ms",
-                            "Speedup: " + output.success(result.performance.searchSpeedup)
-                        ]);
-                    }
-                    return [2 /*return*/, { success: true, data: result }];
-                case 3:
-                    error_9 = _b.sent();
-                    spinner.fail('Compression failed');
-                    if (error_9 instanceof MCPClientError) {
-                        output.printError("Compression error: " + error_9.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_9));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+    action: async (ctx) => {
+        const level = ctx.flags.level || 'balanced';
+        const target = ctx.flags.target || 'all';
+        const quantize = ctx.flags.quantize;
+        const bits = ctx.flags.bits || 8;
+        const rebuildIndex = ctx.flags.rebuildIndex ?? true;
+        output.writeln();
+        output.writeln(output.bold('Memory Compression'));
+        output.writeln(output.dim(`Level: ${level}, Target: ${target}, Quantize: ${quantize ? `${bits}-bit` : 'no'}`));
+        output.writeln();
+        const spinner = output.createSpinner({ text: 'Analyzing current storage...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const result = await callMCPTool('memory_compress', {
+                level,
+                target,
+                quantize,
+                bits,
+                rebuildIndex,
+            });
+            spinner.succeed('Compression complete');
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return { success: true, data: result };
             }
-        });
-    }); }
+            output.writeln();
+            output.writeln(output.bold('Storage Comparison'));
+            output.printTable({
+                columns: [
+                    { key: 'category', header: 'Category', width: 15 },
+                    { key: 'before', header: 'Before', width: 12, align: 'right' },
+                    { key: 'after', header: 'After', width: 12, align: 'right' },
+                    { key: 'saved', header: 'Saved', width: 12, align: 'right' }
+                ],
+                data: [
+                    { category: 'Vectors', before: result.before.vectorsSize, after: result.after.vectorsSize, saved: '-' },
+                    { category: 'Text', before: result.before.textSize, after: result.after.textSize, saved: '-' },
+                    { category: 'Patterns', before: result.before.patternsSize, after: result.after.patternsSize, saved: '-' },
+                    { category: 'Index', before: result.before.indexSize, after: result.after.indexSize, saved: '-' },
+                    { category: output.bold('Total'), before: result.before.totalSize, after: result.after.totalSize, saved: output.success(result.compression.formattedSaved) }
+                ]
+            });
+            output.writeln();
+            output.printBox([
+                `Compression Ratio: ${result.compression.ratio.toFixed(2)}x`,
+                `Space Saved: ${result.compression.formattedSaved}`,
+                `Quantization: ${result.compression.quantizationApplied ? `Yes (${bits}-bit)` : 'No'}`,
+                `Index Rebuilt: ${result.compression.indexRebuilt ? 'Yes' : 'No'}`,
+                `Duration: ${(result.duration / 1000).toFixed(1)}s`
+            ].join('\n'), 'Results');
+            if (result.performance) {
+                output.writeln();
+                output.writeln(output.bold('Performance Impact'));
+                output.printList([
+                    `Search latency: ${result.performance.searchLatencyBefore.toFixed(2)}ms → ${result.performance.searchLatencyAfter.toFixed(2)}ms`,
+                    `Speedup: ${output.success(result.performance.searchSpeedup)}`
+                ]);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            spinner.fail('Compression failed');
+            if (error instanceof MCPClientError) {
+                output.printError(`Compression error: ${error.message}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Export command
-var exportCommand = {
+const exportCommand = {
     name: 'export',
     description: 'Export memory to file',
     options: [
@@ -1061,7 +911,7 @@ var exportCommand = {
             description: 'Export format (json, csv, binary)',
             type: 'string',
             choices: ['json', 'csv', 'binary'],
-            "default": 'json'
+            default: 'json'
         },
         {
             name: 'namespace',
@@ -1073,61 +923,50 @@ var exportCommand = {
             name: 'include-vectors',
             description: 'Include vector embeddings',
             type: 'boolean',
-            "default": true
+            default: true
         }
     ],
     examples: [
         { command: 'claude-flow memory export -o ./backup.json', description: 'Export all to JSON' },
         { command: 'claude-flow memory export -o ./data.csv -f csv', description: 'Export to CSV' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var outputPath, format, result, error_10;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    outputPath = ctx.flags.output;
-                    format = ctx.flags.format || 'json';
-                    if (!outputPath) {
-                        output.printError('Output path is required. Use --output or -o');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.printInfo("Exporting memory to " + outputPath + "...");
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, callMCPTool('memory_export', {
-                            outputPath: outputPath,
-                            format: format,
-                            namespace: ctx.flags.namespace,
-                            includeVectors: (_a = ctx.flags.includeVectors) !== null && _a !== void 0 ? _a : true
-                        })];
-                case 2:
-                    result = _b.sent();
-                    output.printSuccess("Exported to " + result.outputPath);
-                    output.printList([
-                        "Entries: " + result.exported.entries,
-                        "Vectors: " + result.exported.vectors,
-                        "Patterns: " + result.exported.patterns,
-                        "File size: " + result.fileSize
-                    ]);
-                    return [2 /*return*/, { success: true, data: result }];
-                case 3:
-                    error_10 = _b.sent();
-                    if (error_10 instanceof MCPClientError) {
-                        output.printError("Export error: " + error_10.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_10));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+    action: async (ctx) => {
+        const outputPath = ctx.flags.output;
+        const format = ctx.flags.format || 'json';
+        if (!outputPath) {
+            output.printError('Output path is required. Use --output or -o');
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Exporting memory to ${outputPath}...`);
+        try {
+            const result = await callMCPTool('memory_export', {
+                outputPath,
+                format,
+                namespace: ctx.flags.namespace,
+                includeVectors: ctx.flags.includeVectors ?? true,
+            });
+            output.printSuccess(`Exported to ${result.outputPath}`);
+            output.printList([
+                `Entries: ${result.exported.entries}`,
+                `Vectors: ${result.exported.vectors}`,
+                `Patterns: ${result.exported.patterns}`,
+                `File size: ${result.fileSize}`
+            ]);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Export error: ${error.message}`);
             }
-        });
-    }); }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Import command
-var importCommand = {
+const importCommand = {
     name: 'import',
     description: 'Import memory from file',
     options: [
@@ -1143,7 +982,7 @@ var importCommand = {
             short: 'm',
             description: 'Merge with existing (skip duplicates)',
             type: 'boolean',
-            "default": true
+            default: true
         },
         {
             name: 'namespace',
@@ -1156,53 +995,42 @@ var importCommand = {
         { command: 'claude-flow memory import -i ./backup.json', description: 'Import from file' },
         { command: 'claude-flow memory import -i ./data.json -n archive', description: 'Import to namespace' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var inputPath, result, error_11;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    inputPath = ctx.flags.input || ctx.args[0];
-                    if (!inputPath) {
-                        output.printError('Input path is required. Use --input or -i');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.printInfo("Importing memory from " + inputPath + "...");
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, callMCPTool('memory_import', {
-                            inputPath: inputPath,
-                            merge: (_a = ctx.flags.merge) !== null && _a !== void 0 ? _a : true,
-                            namespace: ctx.flags.namespace
-                        })];
-                case 2:
-                    result = _b.sent();
-                    output.printSuccess("Imported from " + result.inputPath);
-                    output.printList([
-                        "Entries: " + result.imported.entries,
-                        "Vectors: " + result.imported.vectors,
-                        "Patterns: " + result.imported.patterns,
-                        "Skipped (duplicates): " + result.skipped,
-                        "Duration: " + result.duration + "ms"
-                    ]);
-                    return [2 /*return*/, { success: true, data: result }];
-                case 3:
-                    error_11 = _b.sent();
-                    if (error_11 instanceof MCPClientError) {
-                        output.printError("Import error: " + error_11.message);
-                    }
-                    else {
-                        output.printError("Unexpected error: " + String(error_11));
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+    action: async (ctx) => {
+        const inputPath = ctx.flags.input || ctx.args[0];
+        if (!inputPath) {
+            output.printError('Input path is required. Use --input or -i');
+            return { success: false, exitCode: 1 };
+        }
+        output.printInfo(`Importing memory from ${inputPath}...`);
+        try {
+            const result = await callMCPTool('memory_import', {
+                inputPath,
+                merge: ctx.flags.merge ?? true,
+                namespace: ctx.flags.namespace,
+            });
+            output.printSuccess(`Imported from ${result.inputPath}`);
+            output.printList([
+                `Entries: ${result.imported.entries}`,
+                `Vectors: ${result.imported.vectors}`,
+                `Patterns: ${result.imported.patterns}`,
+                `Skipped (duplicates): ${result.skipped}`,
+                `Duration: ${result.duration}ms`
+            ]);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof MCPClientError) {
+                output.printError(`Import error: ${error.message}`);
             }
-        });
-    }); }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Init subcommand - initialize memory database using sql.js
-var initMemoryCommand = {
+const initMemoryCommand = {
     name: 'init',
     description: 'Initialize memory database with sql.js (WASM SQLite) - includes vector embeddings, pattern learning, temporal decay',
     options: [
@@ -1211,7 +1039,7 @@ var initMemoryCommand = {
             short: 'b',
             description: 'Backend type: hybrid (default), sqlite, or agentdb',
             type: 'string',
-            "default": 'hybrid'
+            default: 'hybrid'
         },
         {
             name: 'path',
@@ -1224,25 +1052,25 @@ var initMemoryCommand = {
             short: 'f',
             description: 'Overwrite existing database',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'verbose',
             description: 'Show detailed initialization output',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'verify',
             description: 'Run verification tests after initialization',
             type: 'boolean',
-            "default": true
+            default: true
         },
         {
             name: 'load-embeddings',
             description: 'Pre-load ONNX embedding model (lazy by default)',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
     examples: [
@@ -1251,201 +1079,182 @@ var initMemoryCommand = {
         { command: 'claude-flow memory init -p ./data/memory.db --force', description: 'Reinitialize at custom path' },
         { command: 'claude-flow memory init --verbose --verify', description: 'Initialize with full verification' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var backend, customPath, force, verbose, verify, loadEmbeddings, spinner, _a, initializeMemoryDatabase, loadEmbeddingModel, verifyMemoryInit, result, embeddingSpinner, embeddingResult, featureLines, _b, activated, failed, initTimeMs, controllerLines, _i, activated_1, name, _c, failed_1, name, verifySpinner, verification, fs, path, claudeDir, claudeDbPath, error_12;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    backend = ctx.flags.backend || 'hybrid';
-                    customPath = ctx.flags.path;
-                    force = ctx.flags.force;
-                    verbose = ctx.flags.verbose;
-                    verify = ctx.flags.verify !== false;
-                    loadEmbeddings = ctx.flags.loadEmbeddings;
-                    output.writeln();
-                    output.writeln(output.bold('Initializing Memory Database'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Initializing schema...', spinner: 'dots' });
-                    spinner.start();
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 10, , 11]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _d.sent(), initializeMemoryDatabase = _a.initializeMemoryDatabase, loadEmbeddingModel = _a.loadEmbeddingModel, verifyMemoryInit = _a.verifyMemoryInit;
-                    return [4 /*yield*/, initializeMemoryDatabase({
-                            backend: backend,
-                            dbPath: customPath,
-                            force: force,
-                            verbose: verbose
-                        })];
-                case 3:
-                    result = _d.sent();
-                    if (!result.success) {
-                        spinner.fail('Initialization failed');
-                        output.printError(result.error || 'Unknown error');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    spinner.succeed('Schema initialized');
-                    if (!loadEmbeddings) return [3 /*break*/, 5];
-                    embeddingSpinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
-                    embeddingSpinner.start();
-                    return [4 /*yield*/, loadEmbeddingModel({ verbose: verbose })];
-                case 4:
-                    embeddingResult = _d.sent();
-                    if (embeddingResult.success) {
-                        embeddingSpinner.succeed("Embedding model loaded: " + embeddingResult.modelName + " (" + embeddingResult.dimensions + "-dim, " + embeddingResult.loadTime + "ms)");
-                    }
-                    else {
-                        embeddingSpinner.stop(output.warning("Embedding model: " + (embeddingResult.error || 'Using fallback')));
-                    }
-                    _d.label = 5;
-                case 5:
-                    output.writeln();
-                    featureLines = [
-                        "Backend:           " + result.backend,
-                        "Schema Version:    " + result.schemaVersion,
-                        "Database Path:     " + result.dbPath,
-                        '',
-                        output.bold('Features:'),
-                        "  Vector Embeddings: " + (result.features.vectorEmbeddings ? output.success('✓ Enabled') : output.dim('✗ Disabled')),
-                        "  Pattern Learning:  " + (result.features.patternLearning ? output.success('✓ Enabled') : output.dim('✗ Disabled')),
-                        "  Temporal Decay:    " + (result.features.temporalDecay ? output.success('✓ Enabled') : output.dim('✗ Disabled')),
-                        "  HNSW Indexing:     " + (result.features.hnswIndexing ? output.success('✓ Enabled') : output.dim('✗ Disabled')),
-                        "  Migration Tracking: " + (result.features.migrationTracking ? output.success('✓ Enabled') : output.dim('✗ Disabled'))
+    action: async (ctx) => {
+        const backend = ctx.flags.backend || 'hybrid';
+        const customPath = ctx.flags.path;
+        const force = ctx.flags.force;
+        const verbose = ctx.flags.verbose;
+        const verify = ctx.flags.verify !== false; // Default true
+        const loadEmbeddings = ctx.flags.loadEmbeddings;
+        output.writeln();
+        output.writeln(output.bold('Initializing Memory Database'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Initializing schema...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Import the memory initializer
+            const { initializeMemoryDatabase, loadEmbeddingModel, verifyMemoryInit } = await import('../memory/memory-initializer.js');
+            const result = await initializeMemoryDatabase({
+                backend,
+                dbPath: customPath,
+                force,
+                verbose
+            });
+            if (!result.success) {
+                spinner.fail('Initialization failed');
+                output.printError(result.error || 'Unknown error');
+                return { success: false, exitCode: 1 };
+            }
+            spinner.succeed('Schema initialized');
+            // Lazy load or pre-load embedding model
+            if (loadEmbeddings) {
+                const embeddingSpinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
+                embeddingSpinner.start();
+                const embeddingResult = await loadEmbeddingModel({ verbose });
+                if (embeddingResult.success) {
+                    embeddingSpinner.succeed(`Embedding model loaded: ${embeddingResult.modelName} (${embeddingResult.dimensions}-dim, ${embeddingResult.loadTime}ms)`);
+                }
+                else {
+                    embeddingSpinner.stop(output.warning(`Embedding model: ${embeddingResult.error || 'Using fallback'}`));
+                }
+            }
+            output.writeln();
+            // Show features enabled with detailed capabilities
+            const featureLines = [
+                `Backend:           ${result.backend}`,
+                `Schema Version:    ${result.schemaVersion}`,
+                `Database Path:     ${result.dbPath}`,
+                '',
+                output.bold('Features:'),
+                `  Vector Embeddings: ${result.features.vectorEmbeddings ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Pattern Learning:  ${result.features.patternLearning ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Temporal Decay:    ${result.features.temporalDecay ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  HNSW Indexing:     ${result.features.hnswIndexing ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Migration Tracking: ${result.features.migrationTracking ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`
+            ];
+            if (verbose) {
+                featureLines.push('', output.bold('HNSW Configuration:'), `  M (connections):     16`, `  ef (construction):   200`, `  ef (search):         100`, `  Metric:              cosine`, '', output.bold('Pattern Learning:'), `  Confidence scoring:  0.0 - 1.0`, `  Temporal decay:      Half-life 30 days`, `  Pattern versioning:  Enabled`, `  Types: task-routing, error-recovery, optimization, coordination, prediction`);
+            }
+            output.printBox(featureLines.join('\n'), 'Configuration');
+            output.writeln();
+            // ADR-053: Show ControllerRegistry activation results
+            if (result.controllers) {
+                const { activated, failed, initTimeMs } = result.controllers;
+                if (activated.length > 0 || failed.length > 0) {
+                    const controllerLines = [
+                        output.bold('AgentDB Controllers:'),
+                        `  Activated: ${activated.length}  Failed: ${failed.length}  Init: ${Math.round(initTimeMs)}ms`,
                     ];
-                    if (verbose) {
-                        featureLines.push('', output.bold('HNSW Configuration:'), "  M (connections):     16", "  ef (construction):   200", "  ef (search):         100", "  Metric:              cosine", '', output.bold('Pattern Learning:'), "  Confidence scoring:  0.0 - 1.0", "  Temporal decay:      Half-life 30 days", "  Pattern versioning:  Enabled", "  Types: task-routing, error-recovery, optimization, coordination, prediction");
-                    }
-                    output.printBox(featureLines.join('\n'), 'Configuration');
-                    output.writeln();
-                    // ADR-053: Show ControllerRegistry activation results
-                    if (result.controllers) {
-                        _b = result.controllers, activated = _b.activated, failed = _b.failed, initTimeMs = _b.initTimeMs;
-                        if (activated.length > 0 || failed.length > 0) {
-                            controllerLines = [
-                                output.bold('AgentDB Controllers:'),
-                                "  Activated: " + activated.length + "  Failed: " + failed.length + "  Init: " + Math.round(initTimeMs) + "ms",
-                            ];
-                            if (verbose && activated.length > 0) {
-                                controllerLines.push('');
-                                for (_i = 0, activated_1 = activated; _i < activated_1.length; _i++) {
-                                    name = activated_1[_i];
-                                    controllerLines.push("  " + output.success('✓') + " " + name);
-                                }
-                            }
-                            if (failed.length > 0 && verbose) {
-                                controllerLines.push('');
-                                for (_c = 0, failed_1 = failed; _c < failed_1.length; _c++) {
-                                    name = failed_1[_c];
-                                    controllerLines.push("  " + output.dim('✗') + " " + name);
-                                }
-                            }
-                            output.printBox(controllerLines.join('\n'), 'Controller Registry (ADR-053)');
-                            output.writeln();
+                    if (verbose && activated.length > 0) {
+                        controllerLines.push('');
+                        for (const name of activated) {
+                            controllerLines.push(`  ${output.success('✓')} ${name}`);
                         }
                     }
-                    // Show tables created
-                    if (verbose && result.tablesCreated.length > 0) {
-                        output.writeln(output.bold('Tables Created:'));
-                        output.printTable({
-                            columns: [
-                                { key: 'table', header: 'Table', width: 22 },
-                                { key: 'purpose', header: 'Purpose', width: 38 }
-                            ],
-                            data: [
-                                { table: 'memory_entries', purpose: 'Core memory storage with embeddings' },
-                                { table: 'patterns', purpose: 'Learned patterns with confidence scores' },
-                                { table: 'pattern_history', purpose: 'Pattern versioning and evolution' },
-                                { table: 'trajectories', purpose: 'SONA learning trajectories' },
-                                { table: 'trajectory_steps', purpose: 'Individual trajectory steps' },
-                                { table: 'migration_state', purpose: 'Migration progress tracking' },
-                                { table: 'sessions', purpose: 'Context persistence' },
-                                { table: 'vector_indexes', purpose: 'HNSW index configuration' },
-                                { table: 'metadata', purpose: 'System metadata' }
-                            ]
-                        });
-                        output.writeln();
-                        output.writeln(output.bold('Indexes Created:'));
-                        output.printList(result.indexesCreated.slice(0, 8).map(function (idx) { return output.dim(idx); }));
-                        if (result.indexesCreated.length > 8) {
-                            output.writeln(output.dim("  ... and " + (result.indexesCreated.length - 8) + " more"));
+                    if (failed.length > 0 && verbose) {
+                        controllerLines.push('');
+                        for (const name of failed) {
+                            controllerLines.push(`  ${output.dim('✗')} ${name}`);
                         }
-                        output.writeln();
-                    }
-                    if (!verify) return [3 /*break*/, 7];
-                    verifySpinner = output.createSpinner({ text: 'Verifying initialization...', spinner: 'dots' });
-                    verifySpinner.start();
-                    return [4 /*yield*/, verifyMemoryInit(result.dbPath, { verbose: verbose })];
-                case 6:
-                    verification = _d.sent();
-                    if (verification.success) {
-                        verifySpinner.succeed("Verification passed (" + verification.summary.passed + "/" + verification.summary.total + " tests)");
-                    }
-                    else {
-                        verifySpinner.fail("Verification failed (" + verification.summary.failed + "/" + verification.summary.total + " tests failed)");
-                    }
-                    if (verbose || !verification.success) {
-                        output.writeln();
-                        output.writeln(output.bold('Verification Results:'));
-                        output.printTable({
-                            columns: [
-                                { key: 'status', header: '', width: 3 },
-                                { key: 'name', header: 'Test', width: 22 },
-                                { key: 'details', header: 'Details', width: 30 },
-                                { key: 'duration', header: 'Time', width: 8, align: 'right' }
-                            ],
-                            data: verification.tests.map(function (t) { return ({
-                                status: t.passed ? output.success('✓') : output.error('✗'),
-                                name: t.name,
-                                details: t.details || '',
-                                duration: t.duration ? t.duration + "ms" : '-'
-                            }); })
-                        });
                     }
+                    output.printBox(controllerLines.join('\n'), 'Controller Registry (ADR-053)');
                     output.writeln();
-                    _d.label = 7;
-                case 7:
-                    // Show next steps
-                    output.writeln(output.bold('Next Steps:'));
-                    output.printList([
-                        "Store data: " + output.highlight('claude-flow memory store -k "key" --value "data"'),
-                        "Search: " + output.highlight('claude-flow memory search -q "query"'),
-                        "Train patterns: " + output.highlight('claude-flow neural train -p coordination'),
-                        "View stats: " + output.highlight('claude-flow memory stats')
-                    ]);
-                    return [4 /*yield*/, import('fs')];
-                case 8:
-                    fs = _d.sent();
-                    return [4 /*yield*/, import('path')];
-                case 9:
-                    path = _d.sent();
-                    claudeDir = path.join(process.cwd(), '.claude');
-                    claudeDbPath = path.join(claudeDir, 'memory.db');
-                    if (!fs.existsSync(claudeDir)) {
-                        fs.mkdirSync(claudeDir, { recursive: true });
-                    }
-                    if (fs.existsSync(result.dbPath) && (!fs.existsSync(claudeDbPath) || force)) {
-                        fs.copyFileSync(result.dbPath, claudeDbPath);
-                        output.writeln();
-                        output.writeln(output.dim("Synced to: " + claudeDbPath));
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            data: result
-                        }];
-                case 10:
-                    error_12 = _d.sent();
-                    spinner.fail('Initialization failed');
-                    output.printError("Failed to initialize memory: " + (error_12 instanceof Error ? error_12.message : String(error_12)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 11: return [2 /*return*/];
+                }
             }
-        });
-    }); }
+            // Show tables created
+            if (verbose && result.tablesCreated.length > 0) {
+                output.writeln(output.bold('Tables Created:'));
+                output.printTable({
+                    columns: [
+                        { key: 'table', header: 'Table', width: 22 },
+                        { key: 'purpose', header: 'Purpose', width: 38 }
+                    ],
+                    data: [
+                        { table: 'memory_entries', purpose: 'Core memory storage with embeddings' },
+                        { table: 'patterns', purpose: 'Learned patterns with confidence scores' },
+                        { table: 'pattern_history', purpose: 'Pattern versioning and evolution' },
+                        { table: 'trajectories', purpose: 'SONA learning trajectories' },
+                        { table: 'trajectory_steps', purpose: 'Individual trajectory steps' },
+                        { table: 'migration_state', purpose: 'Migration progress tracking' },
+                        { table: 'sessions', purpose: 'Context persistence' },
+                        { table: 'vector_indexes', purpose: 'HNSW index configuration' },
+                        { table: 'metadata', purpose: 'System metadata' }
+                    ]
+                });
+                output.writeln();
+                output.writeln(output.bold('Indexes Created:'));
+                output.printList(result.indexesCreated.slice(0, 8).map(idx => output.dim(idx)));
+                if (result.indexesCreated.length > 8) {
+                    output.writeln(output.dim(`  ... and ${result.indexesCreated.length - 8} more`));
+                }
+                output.writeln();
+            }
+            // Run verification if enabled
+            if (verify) {
+                const verifySpinner = output.createSpinner({ text: 'Verifying initialization...', spinner: 'dots' });
+                verifySpinner.start();
+                const verification = await verifyMemoryInit(result.dbPath, { verbose });
+                if (verification.success) {
+                    verifySpinner.succeed(`Verification passed (${verification.summary.passed}/${verification.summary.total} tests)`);
+                }
+                else {
+                    verifySpinner.fail(`Verification failed (${verification.summary.failed}/${verification.summary.total} tests failed)`);
+                }
+                if (verbose || !verification.success) {
+                    output.writeln();
+                    output.writeln(output.bold('Verification Results:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'status', header: '', width: 3 },
+                            { key: 'name', header: 'Test', width: 22 },
+                            { key: 'details', header: 'Details', width: 30 },
+                            { key: 'duration', header: 'Time', width: 8, align: 'right' }
+                        ],
+                        data: verification.tests.map(t => ({
+                            status: t.passed ? output.success('✓') : output.error('✗'),
+                            name: t.name,
+                            details: t.details || '',
+                            duration: t.duration ? `${t.duration}ms` : '-'
+                        }))
+                    });
+                }
+                output.writeln();
+            }
+            // Show next steps
+            output.writeln(output.bold('Next Steps:'));
+            output.printList([
+                `Store data: ${output.highlight('claude-flow memory store -k "key" --value "data"')}`,
+                `Search: ${output.highlight('claude-flow memory search -q "query"')}`,
+                `Train patterns: ${output.highlight('claude-flow neural train -p coordination')}`,
+                `View stats: ${output.highlight('claude-flow memory stats')}`
+            ]);
+            // Also sync to .claude directory
+            const fs = await import('fs');
+            const path = await import('path');
+            const claudeDir = path.join(process.cwd(), '.claude');
+            const claudeDbPath = path.join(claudeDir, 'memory.db');
+            if (!fs.existsSync(claudeDir)) {
+                fs.mkdirSync(claudeDir, { recursive: true });
+            }
+            if (fs.existsSync(result.dbPath) && (!fs.existsSync(claudeDbPath) || force)) {
+                fs.copyFileSync(result.dbPath, claudeDbPath);
+                output.writeln();
+                output.writeln(output.dim(`Synced to: ${claudeDbPath}`));
+            }
+            return {
+                success: true,
+                data: result
+            };
+        }
+        catch (error) {
+            spinner.fail('Initialization failed');
+            output.printError(`Failed to initialize memory: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Main memory command
-export var memoryCommand = {
+export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
     subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand],
@@ -1455,31 +1264,29 @@ export var memoryCommand = {
         { command: 'claude-flow memory search -q "auth patterns"', description: 'Search memory' },
         { command: 'claude-flow memory stats', description: 'Show statistics' }
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Memory Management Commands'));
-            output.writeln();
-            output.writeln('Usage: claude-flow memory <subcommand> [options]');
-            output.writeln();
-            output.writeln('Subcommands:');
-            output.printList([
-                output.highlight('init') + "       - Initialize memory database (sql.js)",
-                output.highlight('store') + "      - Store data in memory",
-                output.highlight('retrieve') + "   - Retrieve data from memory",
-                output.highlight('search') + "     - Semantic/vector search",
-                output.highlight('list') + "       - List memory entries",
-                output.highlight('delete') + "     - Delete memory entry",
-                output.highlight('stats') + "      - Show statistics",
-                output.highlight('configure') + "  - Configure backend",
-                output.highlight('cleanup') + "    - Clean expired entries",
-                output.highlight('compress') + "   - Compress database",
-                output.highlight('export') + "     - Export memory to file",
-                output.highlight('import') + "     - Import from file"
-            ]);
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async (ctx) => {
+        output.writeln();
+        output.writeln(output.bold('Memory Management Commands'));
+        output.writeln();
+        output.writeln('Usage: claude-flow memory <subcommand> [options]');
+        output.writeln();
+        output.writeln('Subcommands:');
+        output.printList([
+            `${output.highlight('init')}       - Initialize memory database (sql.js)`,
+            `${output.highlight('store')}      - Store data in memory`,
+            `${output.highlight('retrieve')}   - Retrieve data from memory`,
+            `${output.highlight('search')}     - Semantic/vector search`,
+            `${output.highlight('list')}       - List memory entries`,
+            `${output.highlight('delete')}     - Delete memory entry`,
+            `${output.highlight('stats')}      - Show statistics`,
+            `${output.highlight('configure')}  - Configure backend`,
+            `${output.highlight('cleanup')}    - Clean expired entries`,
+            `${output.highlight('compress')}   - Compress database`,
+            `${output.highlight('export')}     - Export memory to file`,
+            `${output.highlight('import')}     - Import from file`
+        ]);
+        return { success: true };
+    }
 };
 export default memoryCommand;
 //# sourceMappingURL=memory.js.map