kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/embeddings-tools.js

@@ -4,65 +4,29 @@
  * Tool definitions for ONNX embeddings with hyperbolic support and neural substrate.
  * Implements ADR-024: Embeddings MCP Tools
  */
-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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 // Configuration paths
-var CONFIG_DIR = '.claude-flow';
-var EMBEDDINGS_CONFIG = 'embeddings.json';
-var MODELS_DIR = 'models';
+const CONFIG_DIR = '.claude-flow';
+const EMBEDDINGS_CONFIG = 'embeddings.json';
+const MODELS_DIR = 'models';
 function getConfigPath() {
     return resolve(join(CONFIG_DIR, EMBEDDINGS_CONFIG));
 }
 function ensureConfigDir() {
-    var dir = resolve(CONFIG_DIR);
+    const dir = resolve(CONFIG_DIR);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadConfig() {
     try {
-        var path = getConfigPath();
+        const path = getConfigPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return null on error
     }
     return null;
@@ -72,96 +36,73 @@ function saveConfig(config) {
     writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
 }
 // Real ONNX embedding generation via memory-initializer
-var realEmbeddingFn = null;
-function getRealEmbeddingFunction() {
-    return __awaiter(this, void 0, void 0, function () {
-        var generateEmbedding, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!!realEmbeddingFn) return [3 /*break*/, 4];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    generateEmbedding = (_b.sent()).generateEmbedding;
-                    realEmbeddingFn = generateEmbedding;
-                    return [3 /*break*/, 4];
-                case 3:
-                    _a = _b.sent();
-                    realEmbeddingFn = null;
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, realEmbeddingFn];
-            }
-        });
-    });
+let realEmbeddingFn = null;
+async function getRealEmbeddingFunction() {
+    if (!realEmbeddingFn) {
+        try {
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            realEmbeddingFn = generateEmbedding;
+        }
+        catch {
+            realEmbeddingFn = null;
+        }
+    }
+    return realEmbeddingFn;
 }
 // Generate real ONNX embedding (falls back to deterministic hash if ONNX unavailable)
-function generateRealEmbedding(text, dimension) {
-    return __awaiter(this, void 0, Promise, function () {
-        var realFn, result, _a, embedding, hash, i, i, seed, norm;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getRealEmbeddingFunction()];
-                case 1:
-                    realFn = _b.sent();
-                    if (!realFn) return [3 /*break*/, 5];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, realFn(text)];
-                case 3:
-                    result = _b.sent();
-                    return [2 /*return*/, result.embedding];
-                case 4:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 5:
-                    // Fallback: deterministic hash-based (only if ONNX truly unavailable)
-                    console.warn('[MCP] ONNX unavailable, using fallback embedding');
-                    embedding = [];
-                    hash = 0;
-                    for (i = 0; i < text.length; i++) {
-                        hash = ((hash << 5) - hash + text.charCodeAt(i)) | 0;
-                    }
-                    for (i = 0; i < dimension; i++) {
-                        seed = hash + i * 1337;
-                        embedding.push(Math.sin(seed) * Math.cos(seed * 0.5));
-                    }
-                    norm = Math.sqrt(embedding.reduce(function (sum, x) { return sum + x * x; }, 0));
-                    return [2 /*return*/, embedding.map(function (x) { return x / norm; })];
-            }
-        });
-    });
+async function generateRealEmbedding(text, dimension) {
+    const realFn = await getRealEmbeddingFunction();
+    if (realFn) {
+        try {
+            const result = await realFn(text);
+            return result.embedding;
+        }
+        catch {
+            // Fall through to fallback
+        }
+    }
+    // Fallback: deterministic hash-based (only if ONNX truly unavailable)
+    console.warn('[MCP] ONNX unavailable, using fallback embedding');
+    const embedding = [];
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        hash = ((hash << 5) - hash + text.charCodeAt(i)) | 0;
+    }
+    for (let i = 0; i < dimension; i++) {
+        const seed = hash + i * 1337;
+        embedding.push(Math.sin(seed) * Math.cos(seed * 0.5));
+    }
+    // L2 normalize
+    const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
+    return embedding.map(x => x / norm);
 }
 // Convert Euclidean embedding to Poincaré ball
 function toPoincare(euclidean, curvature) {
-    var c = Math.abs(curvature);
-    var sqrtC = Math.sqrt(c);
-    var norm = Math.sqrt(euclidean.reduce(function (sum, x) { return sum + x * x; }, 0));
+    const c = Math.abs(curvature);
+    const sqrtC = Math.sqrt(c);
+    const norm = Math.sqrt(euclidean.reduce((sum, x) => sum + x * x, 0));
     // Exponential map at origin
-    var factor = Math.tanh(sqrtC * norm / 2) / (sqrtC * norm + 1e-15);
-    return euclidean.map(function (x) { return x * factor; });
+    const factor = Math.tanh(sqrtC * norm / 2) / (sqrtC * norm + 1e-15);
+    return euclidean.map(x => x * factor);
 }
 // Poincaré distance
 function poincareDistance(a, b, curvature) {
-    var c = Math.abs(curvature);
-    var diffSq = a.reduce(function (sum, _, i) { return sum + Math.pow((a[i] - b[i]), 2); }, 0);
-    var normASq = a.reduce(function (sum, x) { return sum + x * x; }, 0);
-    var normBSq = b.reduce(function (sum, x) { return sum + x * x; }, 0);
-    var denom = (1 - normASq) * (1 - normBSq);
-    var delta = 2 * diffSq / (denom + 1e-15);
+    const c = Math.abs(curvature);
+    const diffSq = a.reduce((sum, _, i) => sum + (a[i] - b[i]) ** 2, 0);
+    const normASq = a.reduce((sum, x) => sum + x * x, 0);
+    const normBSq = b.reduce((sum, x) => sum + x * x, 0);
+    const denom = (1 - normASq) * (1 - normBSq);
+    const delta = 2 * diffSq / (denom + 1e-15);
     return (1 / Math.sqrt(c)) * Math.acosh(1 + delta);
 }
 // Cosine similarity
 function cosineSimilarity(a, b) {
-    var dot = a.reduce(function (sum, _, i) { return sum + a[i] * b[i]; }, 0);
-    var normA = Math.sqrt(a.reduce(function (sum, x) { return sum + x * x; }, 0));
-    var normB = Math.sqrt(b.reduce(function (sum, x) { return sum + x * x; }, 0));
+    const dot = a.reduce((sum, _, i) => sum + a[i] * b[i], 0);
+    const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
+    const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
     return dot / (normA * normB + 1e-15);
 }
-export var embeddingsTools = [
+export const embeddingsTools = [
     {
         name: 'embeddings_init',
         description: 'Initialize the ONNX embedding subsystem with hyperbolic support',
@@ -172,92 +113,89 @@ export var embeddingsTools = [
                 model: {
                     type: 'string',
                     description: 'ONNX model ID',
-                    "enum": ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
-                    "default": 'all-MiniLM-L6-v2'
+                    enum: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
+                    default: 'all-MiniLM-L6-v2',
                 },
                 hyperbolic: {
                     type: 'boolean',
                     description: 'Enable hyperbolic (Poincaré ball) embeddings',
-                    "default": true
+                    default: true,
                 },
                 curvature: {
                     type: 'number',
                     description: 'Poincaré ball curvature (negative)',
-                    "default": -1
+                    default: -1,
                 },
                 cacheSize: {
                     type: 'number',
                     description: 'LRU cache size',
-                    "default": 256
+                    default: 256,
                 },
                 force: {
                     type: 'boolean',
                     description: 'Overwrite existing configuration',
-                    "default": false
-                }
-            }
+                    default: false,
+                },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var model, hyperbolic, curvature, cacheSize, force, existingConfig, dimension, modelPath, config;
-            return __generator(this, function (_a) {
-                model = input.model || 'all-MiniLM-L6-v2';
-                hyperbolic = input.hyperbolic !== false;
-                curvature = input.curvature || -1;
-                cacheSize = input.cacheSize || 256;
-                force = input.force === true;
-                existingConfig = loadConfig();
-                if (existingConfig && !force) {
-                    return [2 /*return*/, {
-                            success: false,
-                            error: 'Embeddings already initialized. Use force=true to overwrite.',
-                            existingConfig: {
-                                model: existingConfig.model,
-                                initialized: existingConfig.initialized
-                            }
-                        }];
-                }
-                dimension = model.includes('mpnet') ? 768 : 384;
-                modelPath = resolve(join(CONFIG_DIR, MODELS_DIR));
-                // Create models directory
-                if (!existsSync(modelPath)) {
-                    mkdirSync(modelPath, { recursive: true });
-                }
-                config = {
-                    model: model,
-                    modelPath: modelPath,
-                    dimension: dimension,
-                    cacheSize: cacheSize,
-                    hyperbolic: {
-                        enabled: hyperbolic,
-                        curvature: curvature,
-                        epsilon: 1e-15,
-                        maxNorm: 1 - 1e-5
-                    },
-                    neural: {
-                        enabled: true,
-                        driftThreshold: 0.3,
-                        decayRate: 0.01
+        handler: async (input) => {
+            const model = input.model || 'all-MiniLM-L6-v2';
+            const hyperbolic = input.hyperbolic !== false;
+            const curvature = input.curvature || -1;
+            const cacheSize = input.cacheSize || 256;
+            const force = input.force === true;
+            const existingConfig = loadConfig();
+            if (existingConfig && !force) {
+                return {
+                    success: false,
+                    error: 'Embeddings already initialized. Use force=true to overwrite.',
+                    existingConfig: {
+                        model: existingConfig.model,
+                        initialized: existingConfig.initialized,
                     },
-                    initialized: new Date().toISOString()
                 };
-                saveConfig(config);
-                return [2 /*return*/, {
-                        success: true,
-                        config: {
-                            model: model,
-                            dimension: dimension,
-                            cacheSize: cacheSize,
-                            hyperbolic: hyperbolic ? { enabled: true, curvature: curvature } : { enabled: false },
-                            neural: { enabled: true }
-                        },
-                        paths: {
-                            config: getConfigPath(),
-                            models: modelPath
-                        },
-                        message: 'Embedding subsystem initialized successfully'
-                    }];
-            });
-        }); }
+            }
+            const dimension = model.includes('mpnet') ? 768 : 384;
+            const modelPath = resolve(join(CONFIG_DIR, MODELS_DIR));
+            // Create models directory
+            if (!existsSync(modelPath)) {
+                mkdirSync(modelPath, { recursive: true });
+            }
+            const config = {
+                model,
+                modelPath,
+                dimension,
+                cacheSize,
+                hyperbolic: {
+                    enabled: hyperbolic,
+                    curvature,
+                    epsilon: 1e-15,
+                    maxNorm: 1 - 1e-5,
+                },
+                neural: {
+                    enabled: true,
+                    driftThreshold: 0.3,
+                    decayRate: 0.01,
+                },
+                initialized: new Date().toISOString(),
+            };
+            saveConfig(config);
+            return {
+                success: true,
+                config: {
+                    model,
+                    dimension,
+                    cacheSize,
+                    hyperbolic: hyperbolic ? { enabled: true, curvature } : { enabled: false },
+                    neural: { enabled: true },
+                },
+                paths: {
+                    config: getConfigPath(),
+                    models: modelPath,
+                },
+                message: 'Embedding subsystem initialized successfully',
+            };
+        },
     },
     {
         name: 'embeddings_generate',
@@ -268,61 +206,56 @@ export var embeddingsTools = [
             properties: {
                 text: {
                     type: 'string',
-                    description: 'Text to embed'
+                    description: 'Text to embed',
                 },
                 hyperbolic: {
                     type: 'boolean',
                     description: 'Return hyperbolic (Poincaré) embedding',
-                    "default": false
+                    default: false,
                 },
                 normalize: {
                     type: 'boolean',
                     description: 'L2 normalize the embedding',
-                    "default": true
-                }
+                    default: true,
+                },
             },
-            required: ['text']
+            required: ['text'],
+        },
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            const text = input.text;
+            const useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
+            // Generate real ONNX embedding
+            const embedding = await generateRealEmbedding(text, config.dimension);
+            let result;
+            let geometry;
+            if (useHyperbolic) {
+                result = toPoincare(embedding, config.hyperbolic.curvature);
+                geometry = 'poincare';
+            }
+            else {
+                result = embedding;
+                geometry = 'euclidean';
+            }
+            return {
+                success: true,
+                embedding: result,
+                metadata: {
+                    model: config.model,
+                    dimension: config.dimension,
+                    geometry,
+                    curvature: useHyperbolic ? config.hyperbolic.curvature : null,
+                    textLength: text.length,
+                    norm: Math.sqrt(result.reduce((sum, x) => sum + x * x, 0)),
+                },
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var config, text, useHyperbolic, embedding, result, geometry;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        config = loadConfig();
-                        if (!config) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    error: 'Embeddings not initialized. Run embeddings/init first.'
-                                }];
-                        }
-                        text = input.text;
-                        useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
-                        return [4 /*yield*/, generateRealEmbedding(text, config.dimension)];
-                    case 1:
-                        embedding = _a.sent();
-                        if (useHyperbolic) {
-                            result = toPoincare(embedding, config.hyperbolic.curvature);
-                            geometry = 'poincare';
-                        }
-                        else {
-                            result = embedding;
-                            geometry = 'euclidean';
-                        }
-                        return [2 /*return*/, {
-                                success: true,
-                                embedding: result,
-                                metadata: {
-                                    model: config.model,
-                                    dimension: config.dimension,
-                                    geometry: geometry,
-                                    curvature: useHyperbolic ? config.hyperbolic.curvature : null,
-                                    textLength: text.length,
-                                    norm: Math.sqrt(result.reduce(function (sum, x) { return sum + x * x; }, 0))
-                                }
-                            }];
-                }
-            });
-        }); }
     },
     {
         name: 'embeddings_compare',
@@ -333,80 +266,75 @@ export var embeddingsTools = [
             properties: {
                 text1: {
                     type: 'string',
-                    description: 'First text'
+                    description: 'First text',
                 },
                 text2: {
                     type: 'string',
-                    description: 'Second text'
+                    description: 'Second text',
                 },
                 metric: {
                     type: 'string',
                     description: 'Similarity metric',
-                    "enum": ['cosine', 'euclidean', 'poincare'],
-                    "default": 'cosine'
-                }
+                    enum: ['cosine', 'euclidean', 'poincare'],
+                    default: 'cosine',
+                },
             },
-            required: ['text1', 'text2']
+            required: ['text1', 'text2'],
+        },
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            const text1 = input.text1;
+            const text2 = input.text2;
+            const metric = input.metric || 'cosine';
+            // Generate real ONNX embeddings for both texts
+            const [emb1, emb2] = await Promise.all([
+                generateRealEmbedding(text1, config.dimension),
+                generateRealEmbedding(text2, config.dimension)
+            ]);
+            let similarity;
+            let distance;
+            switch (metric) {
+                case 'poincare':
+                    if (!config.hyperbolic.enabled) {
+                        return {
+                            success: false,
+                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.',
+                        };
+                    }
+                    const poinc1 = toPoincare(emb1, config.hyperbolic.curvature);
+                    const poinc2 = toPoincare(emb2, config.hyperbolic.curvature);
+                    distance = poincareDistance(poinc1, poinc2, config.hyperbolic.curvature);
+                    similarity = 1 / (1 + distance);
+                    break;
+                case 'euclidean':
+                    distance = Math.sqrt(emb1.reduce((sum, _, i) => sum + (emb1[i] - emb2[i]) ** 2, 0));
+                    similarity = 1 / (1 + distance);
+                    break;
+                default: // cosine
+                    similarity = cosineSimilarity(emb1, emb2);
+                    distance = 1 - similarity;
+            }
+            return {
+                success: true,
+                similarity,
+                distance,
+                metric,
+                texts: {
+                    text1: { length: text1.length, preview: text1.slice(0, 50) },
+                    text2: { length: text2.length, preview: text2.slice(0, 50) },
+                },
+                interpretation: similarity > 0.8 ? 'very similar' :
+                    similarity > 0.6 ? 'similar' :
+                        similarity > 0.4 ? 'somewhat similar' :
+                            similarity > 0.2 ? 'different' : 'very different',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var config, text1, text2, metric, _a, emb1, emb2, similarity, distance, poinc1, poinc2;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        config = loadConfig();
-                        if (!config) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    error: 'Embeddings not initialized. Run embeddings/init first.'
-                                }];
-                        }
-                        text1 = input.text1;
-                        text2 = input.text2;
-                        metric = input.metric || 'cosine';
-                        return [4 /*yield*/, Promise.all([
-                                generateRealEmbedding(text1, config.dimension),
-                                generateRealEmbedding(text2, config.dimension)
-                            ])];
-                    case 1:
-                        _a = _b.sent(), emb1 = _a[0], emb2 = _a[1];
-                        switch (metric) {
-                            case 'poincare':
-                                if (!config.hyperbolic.enabled) {
-                                    return [2 /*return*/, {
-                                            success: false,
-                                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.'
-                                        }];
-                                }
-                                poinc1 = toPoincare(emb1, config.hyperbolic.curvature);
-                                poinc2 = toPoincare(emb2, config.hyperbolic.curvature);
-                                distance = poincareDistance(poinc1, poinc2, config.hyperbolic.curvature);
-                                similarity = 1 / (1 + distance);
-                                break;
-                            case 'euclidean':
-                                distance = Math.sqrt(emb1.reduce(function (sum, _, i) { return sum + Math.pow((emb1[i] - emb2[i]), 2); }, 0));
-                                similarity = 1 / (1 + distance);
-                                break;
-                            default: // cosine
-                                similarity = cosineSimilarity(emb1, emb2);
-                                distance = 1 - similarity;
-                        }
-                        return [2 /*return*/, {
-                                success: true,
-                                similarity: similarity,
-                                distance: distance,
-                                metric: metric,
-                                texts: {
-                                    text1: { length: text1.length, preview: text1.slice(0, 50) },
-                                    text2: { length: text2.length, preview: text2.slice(0, 50) }
-                                },
-                                interpretation: similarity > 0.8 ? 'very similar' :
-                                    similarity > 0.6 ? 'similar' :
-                                        similarity > 0.4 ? 'somewhat similar' :
-                                            similarity > 0.2 ? 'different' : 'very different'
-                            }];
-                }
-            });
-        }); }
     },
     {
         name: 'embeddings_search',
@@ -417,103 +345,89 @@ export var embeddingsTools = [
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Search query'
+                    description: 'Search query',
                 },
                 topK: {
                     type: 'number',
                     description: 'Number of results to return',
-                    "default": 5
+                    default: 5,
                 },
                 threshold: {
                     type: 'number',
                     description: 'Minimum similarity threshold (0-1)',
-                    "default": 0.5
+                    default: 0.5,
                 },
                 namespace: {
                     type: 'string',
-                    description: 'Search in specific namespace'
-                }
+                    description: 'Search in specific namespace',
+                },
             },
-            required: ['query']
+            required: ['query'],
+        },
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            const query = input.query;
+            const topK = input.topK || 5;
+            const threshold = input.threshold || 0.5;
+            const namespace = input.namespace;
+            const startTime = performance.now();
+            // Generate real ONNX embedding for query
+            const queryEmbedding = await generateRealEmbedding(query, config.dimension);
+            // Try to search using real memory search
+            try {
+                const { searchEntries } = await import('../memory/memory-initializer.js');
+                const searchResult = await searchEntries({
+                    query,
+                    limit: topK,
+                    threshold,
+                    namespace: namespace || 'default'
+                });
+                const searchTime = (performance.now() - startTime).toFixed(2);
+                return {
+                    success: true,
+                    query,
+                    results: searchResult.results.map((r) => ({
+                        key: r.key,
+                        content: r.content?.substring(0, 100),
+                        similarity: r.score,
+                        namespace: r.namespace
+                    })),
+                    metadata: {
+                        model: config.model,
+                        topK,
+                        threshold,
+                        namespace: namespace || 'default',
+                        searchTime: `${searchTime}ms`,
+                        indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
+                        resultCount: searchResult.results.length
+                    },
+                };
+            }
+            catch {
+                // Database not available - return empty but truthful
+                const searchTime = (performance.now() - startTime).toFixed(2);
+                return {
+                    success: true,
+                    query,
+                    results: [],
+                    metadata: {
+                        model: config.model,
+                        topK,
+                        threshold,
+                        namespace: namespace || 'default',
+                        searchTime: `${searchTime}ms`,
+                        indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
+                    },
+                    message: 'No embeddings indexed yet. Use memory store to add documents.',
+                };
+            }
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var config, query, topK, threshold, namespace, startTime, queryEmbedding, searchEntries, searchResult, searchTime, _a, searchTime;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        config = loadConfig();
-                        if (!config) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    error: 'Embeddings not initialized. Run embeddings/init first.'
-                                }];
-                        }
-                        query = input.query;
-                        topK = input.topK || 5;
-                        threshold = input.threshold || 0.5;
-                        namespace = input.namespace;
-                        startTime = performance.now();
-                        return [4 /*yield*/, generateRealEmbedding(query, config.dimension)];
-                    case 1:
-                        queryEmbedding = _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 5, , 6]);
-                        return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                    case 3:
-                        searchEntries = (_b.sent()).searchEntries;
-                        return [4 /*yield*/, searchEntries({
-                                query: query,
-                                limit: topK,
-                                threshold: threshold,
-                                namespace: namespace || 'default'
-                            })];
-                    case 4:
-                        searchResult = _b.sent();
-                        searchTime = (performance.now() - startTime).toFixed(2);
-                        return [2 /*return*/, {
-                                success: true,
-                                query: query,
-                                results: searchResult.results.map(function (r) {
-                                    var _a;
-                                    return ({
-                                        key: r.key,
-                                        content: (_a = r.content) === null || _a === void 0 ? void 0 : _a.substring(0, 100),
-                                        similarity: r.score,
-                                        namespace: r.namespace
-                                    });
-                                }),
-                                metadata: {
-                                    model: config.model,
-                                    topK: topK,
-                                    threshold: threshold,
-                                    namespace: namespace || 'default',
-                                    searchTime: searchTime + "ms",
-                                    indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
-                                    resultCount: searchResult.results.length
-                                }
-                            }];
-                    case 5:
-                        _a = _b.sent();
-                        searchTime = (performance.now() - startTime).toFixed(2);
-                        return [2 /*return*/, {
-                                success: true,
-                                query: query,
-                                results: [],
-                                metadata: {
-                                    model: config.model,
-                                    topK: topK,
-                                    threshold: threshold,
-                                    namespace: namespace || 'default',
-                                    searchTime: searchTime + "ms",
-                                    indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)'
-                                },
-                                message: 'No embeddings indexed yet. Use memory store to add documents.'
-                            }];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); }
     },
     {
         name: 'embeddings_neural',
@@ -525,207 +439,189 @@ export var embeddingsTools = [
                 action: {
                     type: 'string',
                     description: 'Neural action',
-                    "enum": ['status', 'init', 'drift', 'consolidate', 'adapt'],
-                    "default": 'status'
+                    enum: ['status', 'init', 'drift', 'consolidate', 'adapt'],
+                    default: 'status',
                 },
                 driftThreshold: {
                     type: 'number',
                     description: 'Semantic drift detection threshold',
-                    "default": 0.3
+                    default: 0.3,
                 },
                 decayRate: {
                     type: 'number',
                     description: 'Memory decay rate (hippocampal dynamics)',
-                    "default": 0.01
-                }
-            }
+                    default: 0.01,
+                },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var config, action, _a, getIntelligenceStats, stats, _b, getIntelligenceStats, stats, _c, _d, benchmarkAdaptation, initializeIntelligence, benchmark, _e, _f, getIntelligenceStats, benchmarkAdaptation, initializeIntelligence, stats, benchmark, _g;
-            var _h, _j, _k, _l;
-            return __generator(this, function (_m) {
-                switch (_m.label) {
-                    case 0:
-                        config = loadConfig();
-                        if (!config) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    error: 'Embeddings not initialized. Run embeddings/init first.'
-                                }];
-                        }
-                        action = input.action || 'status';
-                        _a = action;
-                        switch (_a) {
-                            case 'init': return [3 /*break*/, 1];
-                            case 'drift': return [3 /*break*/, 2];
-                            case 'consolidate': return [3 /*break*/, 5];
-                            case 'adapt': return [3 /*break*/, 8];
-                        }
-                        return [3 /*break*/, 12];
-                    case 1:
-                        config.neural = {
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            const action = input.action || 'status';
+            switch (action) {
+                case 'init':
+                    config.neural = {
+                        enabled: true,
+                        driftThreshold: input.driftThreshold || 0.3,
+                        decayRate: input.decayRate || 0.01,
+                        ruvector: {
                             enabled: true,
-                            driftThreshold: input.driftThreshold || 0.3,
-                            decayRate: input.decayRate || 0.01,
-                            ruvector: {
-                                enabled: true,
-                                sona: true,
-                                flashAttention: true,
-                                ewcPlusPlus: true
+                            sona: true,
+                            flashAttention: true,
+                            ewcPlusPlus: true,
+                        },
+                        features: {
+                            semanticDrift: true,
+                            memoryPhysics: true,
+                            stateMachine: true,
+                            swarmCoordination: true,
+                            coherenceMonitor: true,
+                        },
+                    };
+                    saveConfig(config);
+                    return {
+                        success: true,
+                        action: 'init',
+                        neural: config.neural,
+                        message: 'Neural substrate initialized with RuVector integration',
+                    };
+                case 'drift':
+                    // Get real drift metrics if available
+                    try {
+                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
+                        const stats = getIntelligenceStats();
+                        return {
+                            success: true,
+                            action: 'drift',
+                            status: {
+                                semanticDrift: {
+                                    enabled: config.neural.features?.semanticDrift ?? false,
+                                    threshold: config.neural.driftThreshold,
+                                    patternsTracked: stats.patternsLearned,
+                                    status: stats.patternsLearned > 0 ? 'tracking' : 'no patterns',
+                                },
                             },
-                            features: {
-                                semanticDrift: true,
-                                memoryPhysics: true,
-                                stateMachine: true,
-                                swarmCoordination: true,
-                                coherenceMonitor: true
-                            }
+                            message: stats.patternsLearned > 0
+                                ? `Tracking ${stats.patternsLearned} patterns for drift`
+                                : 'No patterns stored yet - drift detection inactive',
                         };
-                        saveConfig(config);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'init',
-                                neural: config.neural,
-                                message: 'Neural substrate initialized with RuVector integration'
-                            }];
-                    case 2:
-                        _m.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, import('../memory/intelligence.js')];
-                    case 3:
-                        getIntelligenceStats = (_m.sent()).getIntelligenceStats;
-                        stats = getIntelligenceStats();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'drift',
-                                status: {
-                                    semanticDrift: {
-                                        enabled: (_j = (_h = config.neural.features) === null || _h === void 0 ? void 0 : _h.semanticDrift) !== null && _j !== void 0 ? _j : false,
-                                        threshold: config.neural.driftThreshold,
-                                        patternsTracked: stats.patternsLearned,
-                                        status: stats.patternsLearned > 0 ? 'tracking' : 'no patterns'
-                                    }
-                                },
-                                message: stats.patternsLearned > 0
-                                    ? "Tracking " + stats.patternsLearned + " patterns for drift"
-                                    : 'No patterns stored yet - drift detection inactive'
-                            }];
-                    case 4:
-                        _b = _m.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'drift',
-                                status: { semanticDrift: { enabled: false, reason: 'Intelligence module unavailable' } }
-                            }];
-                    case 5:
-                        _m.trys.push([5, 7, , 8]);
-                        return [4 /*yield*/, import('../memory/intelligence.js')];
-                    case 6:
-                        getIntelligenceStats = (_m.sent()).getIntelligenceStats;
-                        stats = getIntelligenceStats();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'consolidate',
-                                status: {
-                                    memoryPhysics: {
-                                        enabled: (_l = (_k = config.neural.features) === null || _k === void 0 ? void 0 : _k.memoryPhysics) !== null && _l !== void 0 ? _l : false,
-                                        decayRate: config.neural.decayRate,
-                                        patternsStored: stats.reasoningBankSize,
-                                        trajectoriesRecorded: stats.trajectoriesRecorded
-                                    }
-                                },
-                                message: "ReasoningBank: " + stats.reasoningBankSize + " patterns, " + stats.trajectoriesRecorded + " trajectories"
-                            }];
-                    case 7:
-                        _c = _m.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'consolidate',
-                                status: { memoryPhysics: { enabled: false, reason: 'Intelligence module unavailable' } }
-                            }];
-                    case 8:
-                        _m.trys.push([8, 11, , 12]);
-                        return [4 /*yield*/, import('../memory/intelligence.js')];
-                    case 9:
-                        _d = _m.sent(), benchmarkAdaptation = _d.benchmarkAdaptation, initializeIntelligence = _d.initializeIntelligence;
-                        return [4 /*yield*/, initializeIntelligence()];
-                    case 10:
-                        _m.sent();
-                        benchmark = benchmarkAdaptation(100);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'adapt',
-                                status: {
-                                    sona: {
-                                        enabled: true,
-                                        adaptationTime: (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs",
-                                        targetMet: benchmark.targetMet,
-                                        minTime: (benchmark.minMs * 1000).toFixed(2) + "\u03BCs",
-                                        maxTime: (benchmark.maxMs * 1000).toFixed(2) + "\u03BCs"
-                                    }
+                    }
+                    catch {
+                        return {
+                            success: true,
+                            action: 'drift',
+                            status: { semanticDrift: { enabled: false, reason: 'Intelligence module unavailable' } },
+                        };
+                    }
+                case 'consolidate':
+                    // Get real consolidation metrics
+                    try {
+                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
+                        const stats = getIntelligenceStats();
+                        return {
+                            success: true,
+                            action: 'consolidate',
+                            status: {
+                                memoryPhysics: {
+                                    enabled: config.neural.features?.memoryPhysics ?? false,
+                                    decayRate: config.neural.decayRate,
+                                    patternsStored: stats.reasoningBankSize,
+                                    trajectoriesRecorded: stats.trajectoriesRecorded,
                                 },
-                                message: benchmark.targetMet
-                                    ? "SONA adaptation: " + (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs (target <50\u03BCs met)"
-                                    : "SONA adaptation: " + (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs (target not met)"
-                            }];
-                    case 11:
-                        _e = _m.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'adapt',
-                                status: { sona: { enabled: false, reason: 'Intelligence module unavailable' } }
-                            }];
-                    case 12:
-                        _m.trys.push([12, 15, , 16]);
-                        return [4 /*yield*/, import('../memory/intelligence.js')];
-                    case 13:
-                        _f = _m.sent(), getIntelligenceStats = _f.getIntelligenceStats, benchmarkAdaptation = _f.benchmarkAdaptation, initializeIntelligence = _f.initializeIntelligence;
-                        return [4 /*yield*/, initializeIntelligence()];
-                    case 14:
-                        _m.sent();
-                        stats = getIntelligenceStats();
-                        benchmark = benchmarkAdaptation(50);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'status',
-                                neural: {
-                                    enabled: config.neural.enabled,
-                                    sonaEnabled: stats.sonaEnabled,
-                                    ruvector: config.neural.ruvector || { enabled: false },
-                                    features: config.neural.features || {},
-                                    realMetrics: {
-                                        patternsLearned: stats.patternsLearned,
-                                        trajectoriesRecorded: stats.trajectoriesRecorded,
-                                        reasoningBankSize: stats.reasoningBankSize,
-                                        adaptationTime: (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs",
-                                        targetMet: benchmark.targetMet,
-                                        lastAdaptation: stats.lastAdaptation
-                                            ? new Date(stats.lastAdaptation).toISOString()
-                                            : null
-                                    }
+                            },
+                            message: `ReasoningBank: ${stats.reasoningBankSize} patterns, ${stats.trajectoriesRecorded} trajectories`,
+                        };
+                    }
+                    catch {
+                        return {
+                            success: true,
+                            action: 'consolidate',
+                            status: { memoryPhysics: { enabled: false, reason: 'Intelligence module unavailable' } },
+                        };
+                    }
+                case 'adapt':
+                    // Get real SONA adaptation metrics
+                    try {
+                        const { benchmarkAdaptation, initializeIntelligence } = await import('../memory/intelligence.js');
+                        await initializeIntelligence();
+                        const benchmark = benchmarkAdaptation(100);
+                        return {
+                            success: true,
+                            action: 'adapt',
+                            status: {
+                                sona: {
+                                    enabled: true,
+                                    adaptationTime: `${(benchmark.avgMs * 1000).toFixed(2)}μs`,
+                                    targetMet: benchmark.targetMet,
+                                    minTime: `${(benchmark.minMs * 1000).toFixed(2)}μs`,
+                                    maxTime: `${(benchmark.maxMs * 1000).toFixed(2)}μs`,
                                 },
-                                capabilities: [
-                                    stats.sonaEnabled ? '✅ SONA Active' : '❌ SONA Inactive',
-                                    benchmark.targetMet ? '✅ <0.05ms Target Met' : '⚠️ Target Not Met',
-                                    stats.patternsLearned + " patterns learned",
-                                    stats.trajectoriesRecorded + " trajectories recorded",
-                                ]
-                            }];
-                    case 15:
-                        _g = _m.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'status',
-                                neural: {
-                                    enabled: config.neural.enabled,
-                                    ruvector: config.neural.ruvector || { enabled: false },
-                                    features: config.neural.features || {}
+                            },
+                            message: benchmark.targetMet
+                                ? `SONA adaptation: ${(benchmark.avgMs * 1000).toFixed(2)}μs (target <50μs met)`
+                                : `SONA adaptation: ${(benchmark.avgMs * 1000).toFixed(2)}μs (target not met)`,
+                        };
+                    }
+                    catch {
+                        return {
+                            success: true,
+                            action: 'adapt',
+                            status: { sona: { enabled: false, reason: 'Intelligence module unavailable' } },
+                        };
+                    }
+                default: // status
+                    // Get real neural system status
+                    try {
+                        const { getIntelligenceStats, benchmarkAdaptation, initializeIntelligence } = await import('../memory/intelligence.js');
+                        await initializeIntelligence();
+                        const stats = getIntelligenceStats();
+                        const benchmark = benchmarkAdaptation(50);
+                        return {
+                            success: true,
+                            action: 'status',
+                            neural: {
+                                enabled: config.neural.enabled,
+                                sonaEnabled: stats.sonaEnabled,
+                                ruvector: config.neural.ruvector || { enabled: false },
+                                features: config.neural.features || {},
+                                realMetrics: {
+                                    patternsLearned: stats.patternsLearned,
+                                    trajectoriesRecorded: stats.trajectoriesRecorded,
+                                    reasoningBankSize: stats.reasoningBankSize,
+                                    adaptationTime: `${(benchmark.avgMs * 1000).toFixed(2)}μs`,
+                                    targetMet: benchmark.targetMet,
+                                    lastAdaptation: stats.lastAdaptation
+                                        ? new Date(stats.lastAdaptation).toISOString()
+                                        : null,
                                 },
-                                message: 'Intelligence module not available - showing config only'
-                            }];
-                    case 16: return [2 /*return*/];
-                }
-            });
-        }); }
+                            },
+                            capabilities: [
+                                stats.sonaEnabled ? '✅ SONA Active' : '❌ SONA Inactive',
+                                benchmark.targetMet ? '✅ <0.05ms Target Met' : '⚠️ Target Not Met',
+                                `${stats.patternsLearned} patterns learned`,
+                                `${stats.trajectoriesRecorded} trajectories recorded`,
+                            ],
+                        };
+                    }
+                    catch {
+                        return {
+                            success: true,
+                            action: 'status',
+                            neural: {
+                                enabled: config.neural.enabled,
+                                ruvector: config.neural.ruvector || { enabled: false },
+                                features: config.neural.features || {},
+                            },
+                            message: 'Intelligence module not available - showing config only',
+                        };
+                    }
+            }
+        },
     },
     {
         name: 'embeddings_hyperbolic',
@@ -737,109 +633,106 @@ export var embeddingsTools = [
                 action: {
                     type: 'string',
                     description: 'Hyperbolic action',
-                    "enum": ['status', 'convert', 'distance', 'midpoint'],
-                    "default": 'status'
+                    enum: ['status', 'convert', 'distance', 'midpoint'],
+                    default: 'status',
                 },
                 embedding: {
                     type: 'array',
                     description: 'Euclidean embedding to convert',
-                    items: { type: 'number' }
+                    items: { type: 'number' },
                 },
                 embedding1: {
                     type: 'array',
                     description: 'First embedding for distance/midpoint',
-                    items: { type: 'number' }
+                    items: { type: 'number' },
                 },
                 embedding2: {
                     type: 'array',
                     description: 'Second embedding for distance/midpoint',
-                    items: { type: 'number' }
-                }
+                    items: { type: 'number' },
+                },
+            },
+        },
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    error: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            if (!config.hyperbolic.enabled) {
+                return {
+                    success: false,
+                    error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.',
+                };
+            }
+            const action = input.action || 'status';
+            const curvature = config.hyperbolic.curvature;
+            switch (action) {
+                case 'convert':
+                    const embedding = input.embedding;
+                    if (!embedding || !Array.isArray(embedding)) {
+                        return { success: false, error: 'Embedding array required for convert action' };
+                    }
+                    const poincare = toPoincare(embedding, curvature);
+                    return {
+                        success: true,
+                        action: 'convert',
+                        euclidean: embedding,
+                        poincare,
+                        curvature,
+                        poincareNorm: Math.sqrt(poincare.reduce((sum, x) => sum + x * x, 0)),
+                    };
+                case 'distance':
+                    const emb1 = input.embedding1;
+                    const emb2 = input.embedding2;
+                    if (!emb1 || !emb2) {
+                        return { success: false, error: 'embedding1 and embedding2 required for distance action' };
+                    }
+                    const dist = poincareDistance(emb1, emb2, curvature);
+                    return {
+                        success: true,
+                        action: 'distance',
+                        distance: dist,
+                        curvature,
+                        interpretation: dist < 1 ? 'close' : dist < 2 ? 'moderate' : 'far',
+                    };
+                case 'midpoint':
+                    const e1 = input.embedding1;
+                    const e2 = input.embedding2;
+                    if (!e1 || !e2) {
+                        return { success: false, error: 'embedding1 and embedding2 required for midpoint action' };
+                    }
+                    // Simplified midpoint (proper Möbius midpoint is more complex)
+                    const mid = e1.map((_, i) => (e1[i] + e2[i]) / 2);
+                    const norm = Math.sqrt(mid.reduce((sum, x) => sum + x * x, 0));
+                    const scaledMid = mid.map(x => x * (config.hyperbolic.maxNorm / Math.max(norm, config.hyperbolic.maxNorm)));
+                    return {
+                        success: true,
+                        action: 'midpoint',
+                        midpoint: scaledMid,
+                        curvature,
+                    };
+                default: // status
+                    return {
+                        success: true,
+                        action: 'status',
+                        hyperbolic: {
+                            enabled: true,
+                            curvature,
+                            epsilon: config.hyperbolic.epsilon,
+                            maxNorm: config.hyperbolic.maxNorm,
+                        },
+                        benefits: [
+                            'Better hierarchical data representation',
+                            'Exponential capacity in low dimensions',
+                            'Preserves tree-like structures',
+                            'Natural for taxonomy embeddings',
+                        ],
+                    };
             }
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var config, action, curvature, embedding, poincare, emb1, emb2, dist, e1_1, e2_1, mid, norm_1, scaledMid;
-            return __generator(this, function (_a) {
-                config = loadConfig();
-                if (!config) {
-                    return [2 /*return*/, {
-                            success: false,
-                            error: 'Embeddings not initialized. Run embeddings/init first.'
-                        }];
-                }
-                if (!config.hyperbolic.enabled) {
-                    return [2 /*return*/, {
-                            success: false,
-                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.'
-                        }];
-                }
-                action = input.action || 'status';
-                curvature = config.hyperbolic.curvature;
-                switch (action) {
-                    case 'convert':
-                        embedding = input.embedding;
-                        if (!embedding || !Array.isArray(embedding)) {
-                            return [2 /*return*/, { success: false, error: 'Embedding array required for convert action' }];
-                        }
-                        poincare = toPoincare(embedding, curvature);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'convert',
-                                euclidean: embedding,
-                                poincare: poincare,
-                                curvature: curvature,
-                                poincareNorm: Math.sqrt(poincare.reduce(function (sum, x) { return sum + x * x; }, 0))
-                            }];
-                    case 'distance':
-                        emb1 = input.embedding1;
-                        emb2 = input.embedding2;
-                        if (!emb1 || !emb2) {
-                            return [2 /*return*/, { success: false, error: 'embedding1 and embedding2 required for distance action' }];
-                        }
-                        dist = poincareDistance(emb1, emb2, curvature);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'distance',
-                                distance: dist,
-                                curvature: curvature,
-                                interpretation: dist < 1 ? 'close' : dist < 2 ? 'moderate' : 'far'
-                            }];
-                    case 'midpoint':
-                        e1_1 = input.embedding1;
-                        e2_1 = input.embedding2;
-                        if (!e1_1 || !e2_1) {
-                            return [2 /*return*/, { success: false, error: 'embedding1 and embedding2 required for midpoint action' }];
-                        }
-                        mid = e1_1.map(function (_, i) { return (e1_1[i] + e2_1[i]) / 2; });
-                        norm_1 = Math.sqrt(mid.reduce(function (sum, x) { return sum + x * x; }, 0));
-                        scaledMid = mid.map(function (x) { return x * (config.hyperbolic.maxNorm / Math.max(norm_1, config.hyperbolic.maxNorm)); });
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'midpoint',
-                                midpoint: scaledMid,
-                                curvature: curvature
-                            }];
-                    default: // status
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'status',
-                                hyperbolic: {
-                                    enabled: true,
-                                    curvature: curvature,
-                                    epsilon: config.hyperbolic.epsilon,
-                                    maxNorm: config.hyperbolic.maxNorm
-                                },
-                                benefits: [
-                                    'Better hierarchical data representation',
-                                    'Exponential capacity in low dimensions',
-                                    'Preserves tree-like structures',
-                                    'Natural for taxonomy embeddings',
-                                ]
-                            }];
-                }
-                return [2 /*return*/];
-            });
-        }); }
     },
     {
         name: 'embeddings_status',
@@ -847,47 +740,43 @@ export var embeddingsTools = [
         category: 'embeddings',
         inputSchema: {
             type: 'object',
-            properties: {}
+            properties: {},
+        },
+        handler: async () => {
+            const config = loadConfig();
+            if (!config) {
+                return {
+                    success: false,
+                    initialized: false,
+                    message: 'Embeddings not initialized. Run embeddings/init first.',
+                };
+            }
+            return {
+                success: true,
+                initialized: true,
+                config: {
+                    model: config.model,
+                    dimension: config.dimension,
+                    cacheSize: config.cacheSize,
+                    hyperbolic: config.hyperbolic,
+                    neural: {
+                        enabled: config.neural.enabled,
+                        ruvector: config.neural.ruvector?.enabled ?? false,
+                    },
+                },
+                paths: {
+                    config: getConfigPath(),
+                    models: config.modelPath,
+                },
+                initializedAt: config.initialized,
+                capabilities: {
+                    onnxModels: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
+                    geometries: ['euclidean', 'poincare'],
+                    normalizations: ['L2', 'L1', 'minmax', 'zscore'],
+                    features: ['semantic search', 'hyperbolic projection', 'neural substrate'],
+                },
+            };
         },
-        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
-            var config;
-            var _a, _b;
-            return __generator(this, function (_c) {
-                config = loadConfig();
-                if (!config) {
-                    return [2 /*return*/, {
-                            success: false,
-                            initialized: false,
-                            message: 'Embeddings not initialized. Run embeddings/init first.'
-                        }];
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        initialized: true,
-                        config: {
-                            model: config.model,
-                            dimension: config.dimension,
-                            cacheSize: config.cacheSize,
-                            hyperbolic: config.hyperbolic,
-                            neural: {
-                                enabled: config.neural.enabled,
-                                ruvector: (_b = (_a = config.neural.ruvector) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false
-                            }
-                        },
-                        paths: {
-                            config: getConfigPath(),
-                            models: config.modelPath
-                        },
-                        initializedAt: config.initialized,
-                        capabilities: {
-                            onnxModels: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
-                            geometries: ['euclidean', 'poincare'],
-                            normalizations: ['L2', 'L1', 'minmax', 'zscore'],
-                            features: ['semantic search', 'hyperbolic projection', 'neural substrate']
-                        }
-                    }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=embeddings-tools.js.map