monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -10,9 +10,11 @@
  *
  * @module v1/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { cosineSimilarity as sharedCosineSimilarity } from '../utils/cosine-similarity.js';
+import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
 // ============================================================================
 // Persistence Configuration
 // ============================================================================
@@ -59,8 +61,7 @@ function getStatsPath() {
 const DEFAULT_SONA_CONFIG = {
     instantLoopEnabled: true,
     backgroundLoopEnabled: false,
-    loraLearningRate: 0.001,
-    loraRank: 8,
+    confidenceLearningRate: 0.001,
     ewcLambda: 0.4,
     maxTrajectorySize: 100,
     patternThreshold: 0.7,
@@ -148,7 +149,7 @@ class LocalSonaCoordinator {
         }
     }
     /**
-     * End the current trajectory with a verdict and apply RL updates.
+     * End the current trajectory with a verdict and apply confidence updates.
      * Reward mapping: success=1.0, partial=0.5, failure=-0.5
      *
      * For successful/partial trajectories, boosts confidence of similar patterns
@@ -198,10 +199,10 @@ class LocalSonaCoordinator {
     }
     /**
      * Distill learning from recent successful trajectories.
-     * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
+     * Applies incremental confidence updates and integrates EWC consolidation.
      *
      * For each successful trajectory step with high confidence,
-     * increases the pattern's stored confidence by loraLearningRate * reward.
+     * increases the pattern's stored confidence by confidenceLearningRate * reward.
      * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
      */
     async distillLearning(bank) {
@@ -249,13 +250,13 @@ class LocalSonaCoordinator {
                     // Check EWC penalty before applying update
                     if (ewcConsolidator) {
                         const oldWeights = [oldConfidence];
-                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward);
+                        const proposedConfidence = Math.min(1.0, oldConfidence + this.config.confidenceLearningRate * reward);
                         const newWeights = [proposedConfidence];
                         const penalty = ewcConsolidator.getPenalty(oldWeights, newWeights);
                         totalEwcPenalty += penalty;
                         // If penalty is too high, reduce the update magnitude
                         if (penalty > this.config.ewcLambda) {
-                            const dampedDelta = (this.config.loraLearningRate * reward) / (1 + penalty);
+                            const dampedDelta = (this.config.confidenceLearningRate * reward) / (1 + penalty);
                             pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
                         }
                         else {
@@ -263,8 +264,8 @@ class LocalSonaCoordinator {
                         }
                     }
                     else {
-                        // No EWC: apply full LoRA update
-                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.loraLearningRate * reward));
+                        // No consolidation guard available: apply the full confidence update
+                        pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + this.config.confidenceLearningRate * reward));
                     }
                     pattern.lastUsedAt = Date.now();
                     patternsDistilled++;
@@ -331,34 +332,58 @@ class LocalReasoningBank {
      */
     loadFromDisk() {
         try {
-            const path = getPatternsPath();
-            if (existsSync(path) && statSync(path).size <= 50 * 1024 * 1024) {
-                const data = JSON.parse(readFileSync(path, 'utf-8'));
-                if (Array.isArray(data)) {
-                    // Validate each persisted pattern. The patterns file is part of the
-                    // IPFS-distributed pattern transfer flow — without bounds checks, a
-                    // malicious bundle can inject `confidence: 1e9` (deterministically wins
-                    // every routing decision) or `keywords: [10000 strings]` (DoS on every
-                    // findBestPatternMatch call).
-                    for (const pattern of data) {
-                        if (!pattern || typeof pattern !== 'object')
-                            continue;
-                        const id = pattern.id;
-                        if (typeof id !== 'string' || id.length === 0 || id.length > 256)
-                            continue;
-                        const conf = pattern.confidence;
-                        if (conf !== undefined && (typeof conf !== 'number' || !Number.isFinite(conf) || conf < 0 || conf > 1)) {
-                            continue;
-                        }
-                        const keywords = pattern.keywords;
-                        if (keywords !== undefined && (!Array.isArray(keywords) || keywords.length > 64)) {
-                            continue;
-                        }
-                        this.patterns.set(id, pattern);
-                        this.patternList.push(pattern);
+            const data = readJsonFileSync(getPatternsPath(), []);
+            if (Array.isArray(data)) {
+                // Validate each persisted pattern. The patterns file is part of the
+                // IPFS-distributed pattern transfer flow — without bounds checks, a
+                // malicious bundle can inject `confidence: 1e9` (deterministically wins
+                // every routing decision) or `keywords: [10000 strings]` (DoS on every
+                // findBestPatternMatch call).
+                for (const pattern of data) {
+                    if (!pattern || typeof pattern !== 'object')
+                        continue;
+                    const rec = pattern;
+                    const id = rec.id;
+                    if (typeof id !== 'string' || id.length === 0 || id.length > 256)
+                        continue;
+                    const conf = rec.confidence;
+                    if (conf !== undefined && (typeof conf !== 'number' || !Number.isFinite(conf) || conf < 0 || conf > 1)) {
+                        continue;
                     }
+                    const keywords = rec.keywords;
+                    if (keywords !== undefined && (!Array.isArray(keywords) || keywords.length > 64)) {
+                        continue;
+                    }
+                    // Build a well-typed StoredPattern instead of trusting the raw JSON
+                    // shape — this both satisfies the compiler (the previous code cast
+                    // `unknown` straight into the Map/array, which TS correctly rejected)
+                    // and hardens against malformed/malicious persisted entries (e.g. a
+                    // missing embedding array previously reached cosineSim() as `undefined`).
+                    const rawEmbedding = rec.embedding;
+                    const embedding = Array.isArray(rawEmbedding) && rawEmbedding.every(v => typeof v === 'number' && Number.isFinite(v))
+                        ? rawEmbedding
+                        : [];
+                    const rawUsage = rec.usageCount;
+                    const rawCreated = rec.createdAt;
+                    const rawLastUsed = rec.lastUsedAt;
+                    const stored = {
+                        id,
+                        type: typeof rec.type === 'string' ? rec.type : 'general',
+                        embedding,
+                        content: typeof rec.content === 'string' ? rec.content : '',
+                        confidence: typeof conf === 'number' ? conf : 0.5,
+                        usageCount: typeof rawUsage === 'number' && Number.isFinite(rawUsage) ? rawUsage : 0,
+                        createdAt: typeof rawCreated === 'number' && Number.isFinite(rawCreated) ? rawCreated : Date.now(),
+                        lastUsedAt: typeof rawLastUsed === 'number' && Number.isFinite(rawLastUsed) ? rawLastUsed : Date.now(),
+                        metadata: (rec.metadata && typeof rec.metadata === 'object') ? rec.metadata : undefined,
+                    };
+                    this.patterns.set(id, stored);
+                    this.patternList.push(stored);
                 }
             }
+            // MCP-trained patterns (neural-tools) now write directly to this
+            // ReasoningBank via intelligence.ts's public API, so no separate
+            // models.json bridge is needed.
         }
         catch {
             // Ignore load errors, start fresh
@@ -387,10 +412,7 @@ class LocalReasoningBank {
             return;
         try {
             ensureDataDir();
-            const path = getPatternsPath();
-            const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-            writeFileSync(tmp, JSON.stringify(this.patternList, null, 2), 'utf-8');
-            renameSync(tmp, path);
+            writeJsonFileAtomic(getPatternsPath(), this.patternList);
             this.dirty = false;
         }
         catch {
@@ -477,21 +499,11 @@ class LocalReasoningBank {
         this.saveToDisk();
     }
     /**
-     * Optimized cosine similarity
+     * Cosine similarity — delegates to shared utility
+     * (see src/utils/cosine-similarity.ts)
      */
     cosineSim(a, b) {
-        if (!a || !b || a.length === 0 || b.length === 0)
-            return 0;
-        const len = Math.min(a.length, b.length);
-        let dot = 0, normA = 0, normB = 0;
-        for (let i = 0; i < len; i++) {
-            const ai = a[i], bi = b[i];
-            dot += ai * bi;
-            normA += ai * ai;
-            normB += bi * bi;
-        }
-        const mag = Math.sqrt(normA * normB);
-        return mag === 0 ? 0 : dot / mag;
+        return sharedCosineSimilarity(a, b);
     }
     /**
      * Get statistics
@@ -612,7 +624,7 @@ async function _doInitializeIntelligence(config) {
         });
         // Load persisted stats if available
         loadPersistedStats();
-        // Seed neural learned patterns from @monomind/neural's LearningBridge flush.
+        // Seed neural learned patterns from pattern store.
         // This is the A→B bridge reader: connects the automatic learning loop to routing.
         const neuralPatternsPath = join(getDataDir(), 'patterns.json');
         if (existsSync(neuralPatternsPath) && statSync(neuralPatternsPath).size <= 50 * 1024 * 1024) {
@@ -756,7 +768,7 @@ export async function recordStep(step) {
             metadata: step.metadata,
             timestamp: step.timestamp || Date.now()
         });
-        // Add to current trajectory for RL tracking
+        // Add to current trajectory for outcome tracking
         const stepWithEmbedding = { ...step, embedding };
         sonaCoordinator.addTrajectoryStep(stepWithEmbedding);
         // Store in ReasoningBank for retrieval
@@ -770,7 +782,7 @@ export async function recordStep(step) {
                 metadata: step.metadata
             });
         }
-        // When a 'result' step arrives, end the trajectory and run RL loop
+        // When a 'result' step arrives, end the trajectory and run the confidence-update loop
         if (step.type === 'result' && reasoningBank) {
             // Determine verdict from metadata or default to 'partial'
             const verdict = step.metadata?.verdict || 'partial';
@@ -801,7 +813,7 @@ export async function recordTrajectory(steps, verdict) {
             verdict,
             timestamp: Date.now()
         });
-        // Apply RL: update pattern confidences based on verdict
+        // Update pattern confidences based on verdict
         if (reasoningBank) {
             // Load steps into the coordinator for endTrajectory processing
             for (const step of steps) {
@@ -904,8 +916,8 @@ export function getReasoningBank() {
     return reasoningBank;
 }
 /**
- * End the current trajectory with a verdict and apply RL updates.
- * This is the public API for the SONA RL loop.
+ * End the current trajectory with a verdict and apply confidence updates.
+ * This is the public API for the SONA feedback loop.
  *
  * @param verdict - 'success' (reward=1.0), 'partial' (0.5), or 'failure' (-0.5)
  * @returns Update statistics or null if not initialized
@@ -928,7 +940,7 @@ export async function endTrajectoryWithVerdict(verdict) {
 }
 /**
  * Distill learning from recent successful trajectories.
- * Applies LoRA-style confidence updates with EWC++ consolidation protection.
+ * Applies incremental confidence updates with EWC consolidation protection.
  *
  * @returns Distillation statistics or null if not initialized
  */

package/packages/@monomind/cli/dist/src/memory/memory-bridge.d.ts

@@ -26,6 +26,7 @@ export declare function bridgeStoreEntry(options: {
     guarded?: boolean;
     cached?: boolean;
     attested?: boolean;
+    duplicate?: boolean;
     error?: string;
 } | null>;
 export declare function bridgeSearchEntries(options: {

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -88,6 +88,25 @@ function getDbPath(customPath) {
         return resolved;
     return defaultDir;
 }
+function getAutomemConfig() {
+    const defaults = { dedupThreshold: 0.85, staleDays: 7 };
+    try {
+        const configPath = path.join(process.cwd(), '.monomind', 'automem-config.json');
+        if (!fs.existsSync(configPath))
+            return defaults;
+        const stat = fs.statSync(configPath);
+        if (stat.size > 64 * 1024)
+            return defaults;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return {
+            dedupThreshold: typeof config?.scaffold?.dedupThreshold === 'number' ? config.scaffold.dedupThreshold : defaults.dedupThreshold,
+            staleDays: typeof config?.scaffold?.staleDays === 'number' ? config.scaffold.staleDays : defaults.staleDays,
+        };
+    }
+    catch {
+        return defaults;
+    }
+}
 function generateId(prefix) {
     return `${prefix}_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
 }
@@ -212,6 +231,17 @@ export async function bridgeStoreEntry(options) {
             }
             catch { /* non-fatal */ }
         }
+        // Dedup gate: skip if a near-duplicate already exists
+        const automemCfg = getAutomemConfig();
+        if (embedding && !options.upsert) {
+            try {
+                const similar = await backend.search(embedding, { k: 1, threshold: automemCfg.dedupThreshold });
+                if (similar.length > 0 && similar[0].score >= automemCfg.dedupThreshold) {
+                    return { success: true, id: similar[0].entry.id, duplicate: true };
+                }
+            }
+            catch { /* non-fatal — store anyway */ }
+        }
         await backend.store(entry);
         return { success: true, id, embedding: embeddingInfo };
     }
@@ -241,21 +271,23 @@ export async function bridgeSearchEntries(options) {
                 results = searchResults.map((r) => ({
                     id: r.entry.id,
                     key: r.entry.key,
-                    content: (r.entry.content || '').substring(0, 60) + ((r.entry.content || '').length > 60 ? '...' : ''),
+                    content: r.entry.content || '',
                     score: r.score,
                     namespace: r.entry.namespace,
                     provenance: `semantic:${r.score.toFixed(3)}`,
+                    _createdAt: r.entry.createdAt || 0,
                 }));
                 searchMethod = 'semantic';
             }
             catch { /* fall through to keyword search */ }
         }
-        // Keyword fallback
+        // Keyword fallback — scan all entries in namespace (not just first 100)
+        // to avoid missing documents that were ingested later in the batch.
         if (results.length === 0) {
             const entries = await backend.query({
                 type: 'exact',
                 namespace: namespace ?? 'default',
-                limit: Math.max(limit * 10, 100),
+                limit: 50000,
             });
             const queryLower = queryStr.toLowerCase();
             results = entries
@@ -265,13 +297,23 @@ export async function bridgeSearchEntries(options) {
                 .map((e) => ({
                 id: e.id,
                 key: e.key,
-                content: (e.content || '').substring(0, 60) + ((e.content || '').length > 60 ? '...' : ''),
+                content: e.content || '',
                 score: 0.5,
                 namespace: e.namespace,
                 provenance: 'keyword',
+                _createdAt: e.createdAt || 0,
             }));
             searchMethod = 'keyword';
         }
+        // Filter stale entries based on automem config — skip for knowledge
+        // namespaces (documents should remain searchable indefinitely)
+        const isKnowledgeNs = namespace?.startsWith('knowledge:');
+        if (!isKnowledgeNs) {
+            const { staleDays } = getAutomemConfig();
+            const staleCutoff = Date.now() - staleDays * 86400000;
+            results = results.filter((r) => !r._createdAt || r._createdAt > staleCutoff);
+        }
+        results.forEach((r) => delete r._createdAt);
         return {
             success: true,
             results,
@@ -505,7 +547,7 @@ export async function bridgeSearchPatterns(options) {
         patterns: result.results.map(r => {
             let parsed = {};
             try {
-                parsed = JSON.parse(r.content + (r.content.endsWith('...') ? '' : ''));
+                parsed = JSON.parse(r.content);
             }
             catch { /* use raw */ }
             return {

package/packages/@monomind/cli/dist/src/memory/memory-read.js

@@ -11,6 +11,7 @@ import { safeParseEmbedding } from './memory-bridge.js';
 import { ensureSchemaColumns } from './memory-migrations.js';
 import { generateEmbedding } from './embedding-operations.js';
 import { searchHNSWIndex } from './hnsw-operations.js';
+import { cosineSimilarity as cosineSim } from '../utils/cosine-similarity.js';
 /** Maximum SQLite database file size accepted before read (256 MB). */
 const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
 // ADR-053: Lazy import of LanceDB memory bridge
@@ -29,25 +30,6 @@ async function getBridge() {
         return null;
     }
 }
-/**
- * Optimized cosine similarity
- * V8 JIT-friendly - avoids manual unrolling which can hurt performance
- * ~0.5μs per 384-dim vector comparison
- */
-function cosineSim(a, b) {
-    if (!a || !b || a.length === 0 || b.length === 0)
-        return 0;
-    const len = Math.min(a.length, b.length);
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < len; i++) {
-        const ai = a[i], bi = b[i];
-        dot += ai * bi;
-        normA += ai * ai;
-        normB += bi * bi;
-    }
-    const mag = Math.sqrt(normA * normB);
-    return mag === 0 ? 0 : dot / mag;
-}
 /**
  * Search entries using sql.js with vector similarity
  * Uses HNSW index for 150x faster search when available

package/packages/@monomind/cli/dist/src/suggest.js

@@ -125,21 +125,13 @@ export const COMMON_TYPOS = {
     'hive': 'hive-mind',
     'hivemind': 'hive-mind',
     'hive_mind': 'hive-mind',
-    'neurl': 'neural',
-    'nueral': 'neural',
     'securty': 'security',
     'sec': 'security',
     'perf': 'performance',
     'performace': 'performance',
     'provider': 'providers',
-    'dep': 'deployment',
-    'depoly': 'deployment',
-    'deploy': 'deployment',
-    'claim': 'claims',
     'embed': 'embeddings',
     'embeding': 'embeddings',
-    'daemon': 'daemon',
-    'deamon': 'daemon',
     'doc': 'doctor',
     'docter': 'doctor',
     'complete': 'completions',
@@ -149,10 +141,7 @@ export const COMMON_TYPOS = {
     'taks': 'task',
     'sessio': 'session',
     'sess': 'session',
-    'sesssion': 'session',
-    'workflow': 'workflow',
-    'wf': 'workflow',
-    'wokflow': 'workflow'
+    'sesssion': 'session'
 };
 /**
  * Get corrected command if it's a common typo

package/packages/@monomind/cli/dist/src/transfer/store/discovery.d.ts

@@ -49,9 +49,10 @@ export declare class PatternDiscovery {
      */
     fetchRegistry(cid: string, gateway: string): Promise<PatternRegistry | null>;
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    private getGenesisRegistry;
+    private getEmptyRegistry;
     /**
      * Verify registry signature.
      *

package/packages/@monomind/cli/dist/src/transfer/store/discovery.js

@@ -325,83 +325,35 @@ export class PatternDiscovery {
         catch {
             // GCS not available
         }
-        // Return fallback genesis registry if all else fails
-        console.log(`[Discovery] Using built-in genesis registry`);
-        return this.getGenesisRegistry(cid);
+        // No registry could be reached. Previously this fell back to a built-in
+        // "genesis registry" that invented a pattern with fabricated stats
+        // (1,000 downloads, 5.0 rating, 42 reviews). Return an honest empty
+        // registry instead.
+        console.log(`[Discovery] No registry reachable — transfer store requires a configured registry`);
+        return this.getEmptyRegistry();
     }
     /**
-     * Get built-in genesis registry (always available offline)
+     * Honest empty registry returned when no registry is reachable.
+     * Contains no patterns and no fabricated stats.
      */
-    getGenesisRegistry(cid) {
+    getEmptyRegistry() {
         return {
             version: '1.0.0',
             updatedAt: new Date().toISOString(),
-            ipnsName: 'k51qzi5uqu5dj0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8t9u0v',
+            ipnsName: '',
             previousCid: undefined,
-            patterns: [
-                {
-                    id: 'seraphine-genesis-v1',
-                    name: 'seraphine-genesis',
-                    displayName: 'Seraphine Genesis',
-                    description: 'The foundational Monomind pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
-                    version: '1.0.0',
-                    cid: 'bafybeibqsa442vty2cvhku4ujlrkupyl75536ene7ybqsa442v',
-                    size: 8808,
-                    checksum: '8df766b89d044815c84796e7f33ba30d7806bff7eb2a75e2a0b7d26b64c45231',
-                    author: {
-                        id: 'monomind-team',
-                        displayName: 'Monomind Team',
-                        verified: true,
-                        patterns: 1,
-                        totalDownloads: 1000,
-                    },
-                    license: 'MIT',
-                    categories: ['routing', 'coordination'],
-                    tags: ['genesis', 'foundational', 'routing', 'swarm', 'coordination', 'multi-agent', 'hello-world'],
-                    language: 'typescript',
-                    framework: 'monomind',
-                    downloads: 1000,
-                    rating: 5.0,
-                    ratingCount: 42,
-                    lastUpdated: new Date().toISOString(),
-                    createdAt: '2026-01-08T18:42:31.126Z',
-                    minMonomindVersion: '3.0.0',
-                    verified: true,
-                    trustLevel: 'verified',
-                    signature: 'ed25519:genesis-pattern-signature',
-                    publicKey: 'ed25519:monomind-team-key',
-                },
-            ],
-            categories: [
-                { id: 'routing', name: 'Task Routing', description: 'Task routing patterns', patternCount: 1, icon: '🔀' },
-                { id: 'coordination', name: 'Swarm Coordination', description: 'Multi-agent coordination', patternCount: 1, icon: '🐝' },
-                { id: 'security', name: 'Security', description: 'Security patterns', patternCount: 0, icon: '🔒' },
-                { id: 'performance', name: 'Performance', description: 'Performance patterns', patternCount: 0, icon: '⚡' },
-                { id: 'testing', name: 'Testing', description: 'Testing patterns', patternCount: 0, icon: '🧪' },
-            ],
-            authors: [
-                {
-                    id: 'monomind-team',
-                    displayName: 'Monomind Team',
-                    publicKey: 'ed25519:monomind-team-key',
-                    verified: true,
-                    patterns: 1,
-                    totalDownloads: 1000,
-                },
-            ],
-            totalPatterns: 1,
-            totalDownloads: 1000,
-            totalAuthors: 1,
-            featured: ['seraphine-genesis-v1'],
-            trending: ['seraphine-genesis-v1'],
-            newest: ['seraphine-genesis-v1'],
-            // No signature on the genesis fallback. Previously this slot used
-            // `crypto.randomBytes(32)` which is meaningless by construction — every
-            // call would produce a different "valid" signature that no real key
-            // signed. Trusted-registry callers must reject this fallback (the
-            // verification path requires `registrySignature` to be present and
-            // verified against a pinned public key).
-            registryPublicKey: 'ed25519:monomind-registry-key',
+            patterns: [],
+            categories: [],
+            authors: [],
+            totalPatterns: 0,
+            totalDownloads: 0,
+            totalAuthors: 0,
+            featured: [],
+            trending: [],
+            newest: [],
+            // No signature — trusted-registry callers must reject this fallback
+            // (the verification path requires `registrySignature` to be present
+            // and verified against a pinned public key).
         };
     }
     /**

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -46,7 +46,6 @@ const MONOMIND_PACKAGES = [
     '@monoes/monograph',
     '@monoes/memory',
     '@monoes/monodesign',
-    '@monomind/guidance',
     '@monomind/hooks',
     '@monomind/mcp',
     '@monomind/routing',

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared cosine similarity utility.
+ *
+ * Previously duplicated in 5 independent implementations:
+ *   - memory/intelligence.ts (ReasoningBank.cosineSim)
+ *   - mcp-tools/neural-tools.ts (cosineSimilarity)
+ *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *
+ * This is the single canonical implementation. Accepts number[] or
+ * Float32Array. Handles dimension mismatches gracefully (uses the shorter
+ * length) and returns 0 for zero-magnitude vectors.
+ */
+/**
+ * Compute cosine similarity between two vectors.
+ *
+ * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
+ * has zero magnitude.
+ */
+export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
+//# sourceMappingURL=cosine-similarity.d.ts.map

package/packages/@monomind/cli/dist/src/utils/cosine-similarity.js

@@ -0,0 +1,38 @@
+/**
+ * Shared cosine similarity utility.
+ *
+ * Previously duplicated in 5 independent implementations:
+ *   - memory/intelligence.ts (ReasoningBank.cosineSim)
+ *   - mcp-tools/neural-tools.ts (cosineSimilarity)
+ *   - mcp-tools/embeddings-tools.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/types.ts (cosineSimilarity)
+ *   - mcp-tools/coherence/coherence-check.ts (cosineSimilarity)
+ *
+ * This is the single canonical implementation. Accepts number[] or
+ * Float32Array. Handles dimension mismatches gracefully (uses the shorter
+ * length) and returns 0 for zero-magnitude vectors.
+ */
+/**
+ * Compute cosine similarity between two vectors.
+ *
+ * Returns a value in [-1, 1]. Returns 0 when either vector is empty or
+ * has zero magnitude.
+ */
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < len; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const mag = Math.sqrt(normA) * Math.sqrt(normB);
+    return mag === 0 ? 0 : dot / mag;
+}
+//# sourceMappingURL=cosine-similarity.js.map