monomind 2.7.12 → 2.7.13

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

@@ -1,1456 +0,0 @@
-/**
- * V1 Intelligence Module
- * Optimized SONA (Self-Optimizing Neural Architecture) and ReasoningBank
- * for adaptive learning and pattern recognition
- *
- * Performance targets:
- * - Signal recording: <0.05ms (achieved: ~0.01ms)
- * - Pattern search: O(log n) with HNSW
- * - Memory efficient circular buffers
- *
- * @module v1/cli/intelligence
- */
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { cosineSimilarity as sharedCosineSimilarity } from '../utils/cosine-similarity.js';
-import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
-// ============================================================================
-// Persistence Configuration
-// ============================================================================
-/**
- * Get the data directory for neural pattern persistence
- * Uses .monomind/neural in the current working directory,
- * falling back to home directory
- */
-function getDataDir() {
-    // MONOMIND_CWD is the project root; process.cwd() is wherever the process
-    // happened to start. For a global or MCP install those differ — the server
-    // is launched by the editor, not from the project — so keying the pattern
-    // store off cwd scattered a project's learned patterns across whatever
-    // directory the server booted in (or fell through to ~/.monomind entirely).
-    // Every other consumer resolves the project this way; see getProjectCwd()
-    // in mcp-tools/types.ts. Inlined rather than imported to keep the memory
-    // layer independent of the MCP tool layer.
-    const cwd = process.env.MONOMIND_CWD || process.cwd();
-    const localDir = join(cwd, '.monomind', 'neural');
-    const homeDir = join(homedir(), '.monomind', 'neural');
-    // Prefer local directory if .monomind exists
-    if (existsSync(join(cwd, '.monomind'))) {
-        return localDir;
-    }
-    return homeDir;
-}
-/**
- * Ensure the data directory exists
- */
-function ensureDataDir() {
-    const dir = getDataDir();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    return dir;
-}
-/**
- * Get the patterns file path
- */
-function getPatternsPath() {
-    return join(getDataDir(), 'patterns.json');
-}
-// ── multi-process-safe patterns.json flush (P1-14) ─────────────────────────
-// patterns.json can be flushed by more than one process at once — e.g. the
-// long-lived MCP server process and a short-lived CJS hook subprocess each
-// load their own in-memory copy, then flush independently. Without a lock +
-// re-read-before-write, whichever flush lands last silently erases whatever
-// the other process added since its own load. flushToDisk() below re-reads
-// the current on-disk file immediately before writing and merges this
-// process's in-memory patterns in by `id` (keeping whichever record has the
-// newer `lastUsedAt`), guarded by a short advisory lock.
-function getPatternsLockPath() {
-    return `${getPatternsPath()}.lock`;
-}
-const PATTERNS_LOCK_STALE_MS = 10_000; // single JSON write — 10s is generous
-function isPidAlive(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (e) {
-        return e?.code === 'EPERM';
-    }
-}
-/**
- * Mirrors the stale-lock-breaking pattern in
- * .claude/helpers/control-start.cjs (claimSpawnLock/releaseSpawnLock):
- * wx-flag write to claim, break the lock if its holder is dead or the lock
- * is older than the stale threshold, retry once, then give up and proceed
- * unlocked (best-effort — a missed lock still merges via the re-read, it
- * just narrows a tiny TOCTOU window further).
- */
-function claimPatternsLock() {
-    const lockPath = getPatternsLockPath();
-    try {
-        mkdirSync(dirname(lockPath), { recursive: true });
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
-        return true;
-    }
-    catch {
-        try {
-            const stat = statSync(lockPath);
-            const holder = Number(readFileSync(lockPath, 'utf-8'));
-            if (Date.now() - stat.mtimeMs < PATTERNS_LOCK_STALE_MS && isPidAlive(holder))
-                return false;
-            unlinkSync(lockPath);
-            writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-function releasePatternsLock() {
-    const lockPath = getPatternsLockPath();
-    try {
-        if (Number(readFileSync(lockPath, 'utf-8')) === process.pid)
-            unlinkSync(lockPath);
-    }
-    catch {
-        /* ignore */
-    }
-}
-/**
- * Get the stats file path
- */
-function getStatsPath() {
-    return join(getDataDir(), 'stats.json');
-}
-// ============================================================================
-// Default Configuration
-// ============================================================================
-const DEFAULT_SONA_CONFIG = {
-    instantLoopEnabled: true,
-    backgroundLoopEnabled: false,
-    confidenceLearningRate: 0.001,
-    ewcLambda: 0.4,
-    maxTrajectorySize: 100,
-    patternThreshold: 0.7,
-    maxSignals: 10000,
-    maxPatterns: 5000
-};
-// ============================================================================
-// Optimized Local SONA Implementation
-// ============================================================================
-/**
- * Lightweight SONA Coordinator
- * Uses circular buffer for O(1) signal recording
- * Achieves <0.05ms per operation
- */
-class LocalSonaCoordinator {
-    config;
-    signals;
-    signalHead = 0;
-    signalCount = 0;
-    trajectories = [];
-    adaptationTimes = [];
-    currentTrajectorySteps = [];
-    constructor(config) {
-        this.config = config;
-        // Pre-allocate circular buffer
-        this.signals = new Array(config.maxSignals);
-    }
-    /**
-     * Record a signal - O(1) operation
-     * Target: <0.05ms
-     */
-    recordSignal(signal) {
-        const start = performance.now();
-        // Circular buffer insertion - constant time
-        this.signals[this.signalHead] = signal;
-        this.signalHead = (this.signalHead + 1) % this.config.maxSignals;
-        if (this.signalCount < this.config.maxSignals) {
-            this.signalCount++;
-        }
-        const elapsed = performance.now() - start;
-        this.adaptationTimes.push(elapsed);
-        if (this.adaptationTimes.length > 100) {
-            this.adaptationTimes.shift();
-        }
-    }
-    /**
-     * Record complete trajectory
-     */
-    recordTrajectory(trajectory) {
-        this.trajectories.push(trajectory);
-        if (this.trajectories.length > this.config.maxTrajectorySize) {
-            this.trajectories.shift();
-        }
-    }
-    /**
-     * Get recent signals
-     */
-    getRecentSignals(count = 10) {
-        const result = [];
-        const actualCount = Math.min(count, this.signalCount);
-        for (let i = 0; i < actualCount; i++) {
-            const idx = (this.signalHead - 1 - i + this.config.maxSignals) % this.config.maxSignals;
-            if (this.signals[idx]) {
-                result.push(this.signals[idx]);
-            }
-        }
-        return result;
-    }
-    /**
-     * Get average adaptation time
-     */
-    getAvgAdaptationTime() {
-        if (this.adaptationTimes.length === 0)
-            return 0;
-        return this.adaptationTimes.reduce((a, b) => a + b, 0) / this.adaptationTimes.length;
-    }
-    /**
-     * Add a step to the current in-progress trajectory
-     */
-    addTrajectoryStep(step) {
-        this.currentTrajectorySteps.push(step);
-        // Prevent unbounded growth
-        if (this.currentTrajectorySteps.length > this.config.maxTrajectorySize) {
-            this.currentTrajectorySteps.shift();
-        }
-    }
-    /**
-     * 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
-     * in the ReasoningBank. For failures, reduces confidence scores.
-     */
-    async endTrajectory(verdict, bank) {
-        const rewardMap = {
-            success: 1.0,
-            partial: 0.5,
-            failure: -0.5
-        };
-        const reward = rewardMap[verdict] ?? 0;
-        // Record the completed trajectory
-        const completedTrajectory = {
-            steps: [...this.currentTrajectorySteps],
-            verdict,
-            timestamp: Date.now()
-        };
-        this.recordTrajectory(completedTrajectory);
-        // Update pattern confidences based on reward
-        let patternsUpdated = 0;
-        const allPatterns = bank.getAll();
-        for (const step of this.currentTrajectorySteps) {
-            if (!step.embedding || step.embedding.length === 0)
-                continue;
-            // Find patterns similar to this trajectory step
-            const similar = bank.findSimilar(step.embedding, {
-                k: 3,
-                threshold: 0.3
-            });
-            for (const match of similar) {
-                const pattern = bank.get(match.id);
-                if (!pattern)
-                    continue;
-                // Adjust confidence: positive reward boosts, negative reduces
-                const delta = reward * 0.1; // small step per update
-                const newConfidence = Math.max(0.0, Math.min(1.0, pattern.confidence + delta));
-                pattern.confidence = newConfidence;
-                pattern.usageCount++;
-                pattern.lastUsedAt = Date.now();
-                patternsUpdated++;
-            }
-        }
-        // Clear current trajectory
-        this.currentTrajectorySteps = [];
-        return { reward, patternsUpdated };
-    }
-    /**
-     * Distill learning from recent successful trajectories.
-     * Applies incremental confidence updates and integrates EWC consolidation.
-     *
-     * For each successful trajectory step with high confidence,
-     * increases the pattern's stored confidence by confidenceLearningRate * reward.
-     * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
-     */
-    async distillLearning(bank) {
-        let patternsDistilled = 0;
-        let totalEwcPenalty = 0;
-        // Get recent successful trajectories
-        const recentSuccessful = this.trajectories.filter(t => t.verdict === 'success' || t.verdict === 'partial').slice(-10); // last 10 successful
-        if (recentSuccessful.length === 0) {
-            return { patternsDistilled: 0, ewcPenalty: 0 };
-        }
-        // Try to get EWC consolidator
-        let ewcConsolidator = null;
-        try {
-            const ewcModule = await import('./ewc-consolidation.js');
-            ewcConsolidator = await ewcModule.getEWCConsolidator({
-                lambda: this.config.ewcLambda
-            });
-        }
-        catch {
-            // EWC not available, proceed without consolidation protection
-        }
-        const rewardMap = {
-            success: 1.0,
-            partial: 0.5
-        };
-        // Collect confidence changes for EWC Fisher update
-        const confidenceChanges = [];
-        for (const trajectory of recentSuccessful) {
-            const reward = rewardMap[trajectory.verdict] ?? 0;
-            for (const step of trajectory.steps) {
-                if (!step.embedding || step.embedding.length === 0)
-                    continue;
-                const similar = bank.findSimilar(step.embedding, {
-                    k: 3,
-                    threshold: 0.4
-                });
-                for (const match of similar) {
-                    const pattern = bank.get(match.id);
-                    if (!pattern)
-                        continue;
-                    // Only distill from high-confidence matches
-                    if (match.confidence < 0.5)
-                        continue;
-                    const oldConfidence = pattern.confidence;
-                    // Check EWC penalty before applying update
-                    if (ewcConsolidator) {
-                        const oldWeights = [oldConfidence];
-                        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.confidenceLearningRate * reward) / (1 + penalty);
-                            pattern.confidence = Math.max(0.0, Math.min(1.0, oldConfidence + dampedDelta));
-                        }
-                        else {
-                            pattern.confidence = proposedConfidence;
-                        }
-                    }
-                    else {
-                        // 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++;
-                    confidenceChanges.push({
-                        id: pattern.id,
-                        oldConf: oldConfidence,
-                        newConf: pattern.confidence,
-                        embedding: pattern.embedding
-                    });
-                }
-            }
-        }
-        // Update EWC Fisher matrix with confidence changes
-        if (ewcConsolidator && confidenceChanges.length > 0) {
-            for (const change of confidenceChanges) {
-                // Use confidence delta as gradient proxy
-                const gradient = change.embedding.map(e => e * Math.abs(change.newConf - change.oldConf));
-                ewcConsolidator.recordGradient(change.id, gradient, true);
-            }
-        }
-        // Persist updated patterns
-        bank.flushToDisk();
-        return { patternsDistilled, ewcPenalty: totalEwcPenalty };
-    }
-    /**
-     * Get current trajectory steps (for inspection)
-     */
-    getCurrentTrajectorySteps() {
-        return [...this.currentTrajectorySteps];
-    }
-    /**
-     * Get statistics
-     */
-    stats() {
-        return {
-            signalCount: this.signalCount,
-            trajectoryCount: this.trajectories.length,
-            avgAdaptationMs: this.getAvgAdaptationTime()
-        };
-    }
-}
-/**
- * Lightweight ReasoningBank
- * Uses Map for O(1) storage and array for similarity search
- * Supports persistence to disk
- */
-class LocalReasoningBank {
-    patterns = new Map();
-    patternList = [];
-    maxSize;
-    persistenceEnabled;
-    dirty = false;
-    saveTimeout = null;
-    constructor(options) {
-        this.maxSize = options.maxSize;
-        this.persistenceEnabled = options.persistence !== false;
-        // Load persisted patterns
-        if (this.persistenceEnabled) {
-            this.loadFromDisk();
-        }
-    }
-    /**
-     * Load patterns from disk
-     */
-    loadFromDisk() {
-        try {
-            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 (e) {
-            // Ignore load errors, start fresh
-            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error('[intelligence] failed to load patterns.json, starting fresh:', e);
-        }
-    }
-    /**
-     * Save patterns to disk (debounced)
-     */
-    saveToDisk() {
-        if (!this.persistenceEnabled)
-            return;
-        this.dirty = true;
-        // Debounce saves to avoid excessive disk I/O
-        if (this.saveTimeout) {
-            clearTimeout(this.saveTimeout);
-        }
-        this.saveTimeout = setTimeout(() => {
-            this.flushToDisk();
-        }, 100);
-    }
-    /**
-     * Immediately flush patterns to disk
-     */
-    flushToDisk() {
-        if (!this.persistenceEnabled || !this.dirty)
-            return;
-        try {
-            ensureDataDir();
-            let acquired = claimPatternsLock();
-            if (!acquired)
-                acquired = claimPatternsLock(); // one retry — lock is short-lived
-            try {
-                // Re-read the current on-disk patterns and merge this process's
-                // in-memory changes in by id (newer lastUsedAt wins) instead of
-                // blindly overwriting the whole file with this.patternList — see
-                // the P1-14 comment above claimPatternsLock() for why.
-                const diskPatterns = readJsonFileSync(getPatternsPath(), []);
-                const merged = new Map();
-                if (Array.isArray(diskPatterns)) {
-                    for (const p of diskPatterns) {
-                        if (p && typeof p.id === 'string')
-                            merged.set(p.id, p);
-                    }
-                }
-                for (const p of this.patternList) {
-                    const existing = merged.get(p.id);
-                    if (!existing || (p.lastUsedAt ?? 0) >= (existing.lastUsedAt ?? 0)) {
-                        merged.set(p.id, p);
-                    }
-                }
-                writeJsonFileAtomic(getPatternsPath(), Array.from(merged.values()));
-            }
-            finally {
-                if (acquired)
-                    releasePatternsLock();
-            }
-            this.dirty = false;
-        }
-        catch {
-            // Log but don't throw - persistence failures shouldn't break training
-            // Do not reflect raw error to avoid leaking internal paths
-            console.error('Failed to persist patterns');
-        }
-    }
-    /**
-     * Store a pattern - O(1)
-     */
-    store(pattern) {
-        const now = Date.now();
-        const stored = {
-            ...pattern,
-            usageCount: pattern.usageCount ?? 0,
-            createdAt: pattern.createdAt ?? now,
-            lastUsedAt: pattern.lastUsedAt ?? now
-        };
-        // Update or insert
-        if (this.patterns.has(pattern.id)) {
-            const existing = this.patterns.get(pattern.id);
-            // Preserve accumulated metadata from the existing entry
-            stored.usageCount = existing.usageCount + 1;
-            stored.createdAt = existing.createdAt;
-            // Update in-place: both Map and patternList hold the same object reference,
-            // so mutating it here updates both without an O(n) list scan (no findIndex).
-            Object.assign(existing, stored);
-            // No need to re-insert into Map or patternList — reference unchanged.
-            this.saveToDisk();
-            return;
-        }
-        else {
-            // Evict oldest if at capacity
-            if (this.patterns.size >= this.maxSize) {
-                const oldest = this.patternList.shift();
-                if (oldest) {
-                    this.patterns.delete(oldest.id);
-                }
-            }
-            this.patternList.push(stored);
-        }
-        this.patterns.set(pattern.id, stored);
-        // Trigger persistence (debounced)
-        this.saveToDisk();
-    }
-    /**
-     * Find similar patterns by embedding.
-     *
-     * This is a pure read operation: it does NOT mutate usageCount or
-     * lastUsedAt, so no disk save is triggered. Callers that need to record
-     * a usage hit should call `recordUsage(id)` explicitly after consuming
-     * the results.
-     */
-    findSimilar(queryEmbedding, options) {
-        const { k = 5, threshold = 0.5, type } = options;
-        // Filter by type if specified
-        const candidates = type
-            ? this.patternList.filter(p => p.type === type)
-            : this.patternList;
-        // Compute similarities without mutating patterns
-        const scored = [];
-        for (const pattern of candidates) {
-            const score = this.cosineSim(queryEmbedding, pattern.embedding);
-            if (score >= threshold) {
-                scored.push({ pattern, score });
-            }
-        }
-        // Sort descending and slice, returning snapshot copies with confidence=score
-        scored.sort((a, b) => b.score - a.score);
-        return scored.slice(0, k).map(s => ({ ...s.pattern, confidence: s.score }));
-    }
-    /**
-     * Record that a pattern was used, updating its usage metrics and scheduling
-     * a debounced disk save. Separated from findSimilar to keep searches pure.
-     */
-    recordUsage(id) {
-        const pattern = this.patterns.get(id);
-        if (!pattern)
-            return;
-        pattern.usageCount++;
-        pattern.lastUsedAt = Date.now();
-        // Update list entry in-place using the Map reference (already same object)
-        this.saveToDisk();
-    }
-    /**
-     * Cosine similarity — delegates to shared utility
-     * (see src/utils/cosine-similarity.ts)
-     */
-    cosineSim(a, b) {
-        return sharedCosineSimilarity(a, b);
-    }
-    /**
-     * Get statistics
-     */
-    stats() {
-        return {
-            size: this.patterns.size,
-            patternCount: this.patternList.length
-        };
-    }
-    /**
-     * Get pattern by ID
-     */
-    get(id) {
-        return this.patterns.get(id);
-    }
-    /**
-     * Get all patterns
-     */
-    getAll() {
-        return [...this.patternList];
-    }
-    /**
-     * Get patterns by type
-     */
-    getByType(type) {
-        return this.patternList.filter(p => p.type === type);
-    }
-    /**
-     * Delete a pattern by ID
-     */
-    delete(id) {
-        const pattern = this.patterns.get(id);
-        if (!pattern)
-            return false;
-        this.patterns.delete(id);
-        const idx = this.patternList.findIndex(p => p.id === id);
-        if (idx >= 0) {
-            this.patternList.splice(idx, 1);
-        }
-        this.saveToDisk();
-        return true;
-    }
-    /**
-     * Clear all patterns
-     */
-    clear() {
-        this.patterns.clear();
-        this.patternList = [];
-        this.saveToDisk();
-    }
-}
-// ============================================================================
-// Module State
-// ============================================================================
-let sonaCoordinator = null;
-let reasoningBank = null;
-let intelligenceInitialized = false;
-let initPromise = null;
-let globalStats = {
-    trajectoriesRecorded: 0,
-    lastAdaptation: null
-};
-// ============================================================================
-// Stats Persistence
-// ============================================================================
-/**
- * Load persisted stats from disk
- */
-function loadPersistedStats() {
-    try {
-        const path = getStatsPath();
-        if (existsSync(path) && statSync(path).size <= 10 * 1024 * 1024) {
-            const data = JSON.parse(readFileSync(path, 'utf-8'));
-            if (data && typeof data === 'object') {
-                globalStats.trajectoriesRecorded = data.trajectoriesRecorded ?? 0;
-                globalStats.lastAdaptation = data.lastAdaptation ?? null;
-            }
-        }
-    }
-    catch (e) {
-        // Ignore load errors, start fresh
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] failed to load stats.json, starting fresh:', e);
-    }
-}
-/**
- * Save stats to disk
- */
-function savePersistedStats() {
-    try {
-        ensureDataDir();
-        const path = getStatsPath();
-        writeFileSync(path, JSON.stringify(globalStats, null, 2), 'utf-8');
-    }
-    catch (e) {
-        // Ignore save errors
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] failed to save stats.json:', e);
-    }
-}
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Initialize the intelligence system (SONA + ReasoningBank)
- * Uses optimized local implementations
- */
-async function _doInitializeIntelligence(config) {
-    try {
-        // Merge config with defaults
-        const finalConfig = {
-            ...DEFAULT_SONA_CONFIG,
-            ...config
-        };
-        // Initialize local SONA (optimized for <0.05ms)
-        sonaCoordinator = new LocalSonaCoordinator(finalConfig);
-        // Initialize local ReasoningBank with persistence enabled
-        reasoningBank = new LocalReasoningBank({
-            maxSize: finalConfig.maxPatterns,
-            persistence: true
-        });
-        // Load persisted stats if available
-        loadPersistedStats();
-        // 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) {
-            try {
-                const { generateEmbedding: genEmb } = await import('./memory-initializer.js').catch(() => ({ generateEmbedding: null }));
-                const raw = readFileSync(neuralPatternsPath, 'utf-8');
-                const entries = JSON.parse(raw);
-                if (Array.isArray(entries)) {
-                    for (const p of entries.slice(0, 200)) {
-                        try {
-                            if (!p.id || typeof p.id !== 'string' || p.id.length > 512)
-                                continue;
-                            if (!p.content || typeof p.content !== 'string' || p.content.length > 4096)
-                                continue;
-                            const conf = p.confidence ?? 0.5;
-                            if (!Number.isFinite(conf) || conf < 0 || conf > 1)
-                                continue;
-                            const embedding = (p.embedding && Array.isArray(p.embedding) && p.embedding.length > 0)
-                                ? p.embedding
-                                : (genEmb ? (await genEmb(p.content))?.embedding ?? [] : []);
-                            if (embedding.some((v) => !Number.isFinite(v)))
-                                continue;
-                            // Only store if not already present, or if we now have an embedding
-                            // where the existing entry has none — avoids inflating usageCount on
-                            // every cold-start re-seed.
-                            const existing = reasoningBank.get(p.id);
-                            if (!existing || (existing.embedding.length === 0 && embedding.length > 0)) {
-                                reasoningBank.store({
-                                    id: p.id,
-                                    type: p.type ?? 'general',
-                                    content: p.content,
-                                    confidence: conf,
-                                    embedding,
-                                    usageCount: p.usageCount ?? 0,
-                                });
-                            }
-                        }
-                        catch { /* skip invalid entries */ }
-                    }
-                }
-            }
-            catch (e) {
-                /* neural patterns file unreadable — skip */
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[intelligence] failed to seed patterns.json into ReasoningBank:', e);
-            }
-        }
-        // Seed SONA routing patterns into the ReasoningBank so keyword-based
-        // routing knowledge from .swarm/sona-patterns.json participates in
-        // similarity search alongside neural patterns.
-        const sonaRouting = loadSonaRoutingPatterns();
-        if (sonaRouting.length > 0) {
-            const { generateEmbedding } = await import('./memory-initializer.js').catch(() => ({ generateEmbedding: null }));
-            for (const p of sonaRouting.slice(0, 100)) { // cap seeding to 100 entries
-                try {
-                    // M2: validate before seeding — malformed sona-patterns.json must not corrupt bank
-                    if (!p.id || typeof p.id !== 'string' || p.id.length > 512)
-                        continue;
-                    if (!Number.isFinite(p.confidence) || p.confidence < 0 || p.confidence > 1)
-                        continue;
-                    if (!p.content || typeof p.content !== 'string' || p.content.length > 4096)
-                        continue;
-                    const embResult = generateEmbedding ? await generateEmbedding(p.content) : null;
-                    const embedding = embResult?.embedding ?? [];
-                    // Reject NaN/Infinity in embedding
-                    if (embedding.some((v) => !Number.isFinite(v)))
-                        continue;
-                    reasoningBank.store({
-                        id: p.id,
-                        type: p.type,
-                        content: p.content,
-                        confidence: p.confidence,
-                        embedding,
-                        usageCount: p.usageCount,
-                    });
-                }
-                catch { /* skip unembeddable entries */ }
-            }
-        }
-        intelligenceInitialized = true;
-        return {
-            success: true,
-            sonaEnabled: true,
-            reasoningBankEnabled: true
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            sonaEnabled: false,
-            reasoningBankEnabled: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Initialize the intelligence system (SONA + ReasoningBank).
- * Promise-based singleton: concurrent callers share a single init flight.
- */
-export async function initializeIntelligence(config) {
-    if (intelligenceInitialized) {
-        return { success: true, sonaEnabled: !!sonaCoordinator, reasoningBankEnabled: !!reasoningBank };
-    }
-    if (!initPromise) {
-        initPromise = _doInitializeIntelligence(config);
-    }
-    return initPromise;
-}
-/**
- * Record a trajectory step for learning
- * Performance: <0.05ms without embedding generation
- */
-export async function recordStep(step) {
-    if (!sonaCoordinator) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    try {
-        // Generate embedding if not provided
-        // ADR-053: Try SQLite-backed memory bridge embedder first
-        let embedding = step.embedding;
-        if (!embedding) {
-            try {
-                const bridge = await import('./memory-bridge.js');
-                const bridgeResult = await bridge.bridgeGenerateEmbedding(step.content);
-                if (bridgeResult) {
-                    embedding = bridgeResult.embedding;
-                }
-            }
-            catch {
-                // Bridge not available
-            }
-            if (!embedding) {
-                const { generateEmbedding } = await import('./memory-initializer.js');
-                const result = await generateEmbedding(step.content);
-                embedding = result.embedding;
-            }
-        }
-        // Record in SONA - <0.05ms
-        sonaCoordinator.recordSignal({
-            type: step.type,
-            content: step.content,
-            embedding,
-            metadata: step.metadata,
-            timestamp: step.timestamp || Date.now()
-        });
-        // Add to current trajectory for outcome tracking
-        const stepWithEmbedding = { ...step, embedding };
-        sonaCoordinator.addTrajectoryStep(stepWithEmbedding);
-        // Store in ReasoningBank for retrieval
-        if (reasoningBank) {
-            reasoningBank.store({
-                id: `step_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-                type: step.type,
-                embedding,
-                content: step.content,
-                confidence: 1.0,
-                metadata: step.metadata
-            });
-        }
-        // 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';
-            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
-            // Distill learning from recent successful trajectories
-            await sonaCoordinator.distillLearning(reasoningBank);
-            globalStats.lastAdaptation = Date.now();
-        }
-        globalStats.trajectoriesRecorded++;
-        return true;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] recordStep failed:', e);
-        return false;
-    }
-}
-/**
- * Record a complete trajectory with verdict
- */
-export async function recordTrajectory(steps, verdict) {
-    if (!sonaCoordinator) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    try {
-        sonaCoordinator.recordTrajectory({
-            steps,
-            verdict,
-            timestamp: Date.now()
-        });
-        // Update pattern confidences based on verdict
-        if (reasoningBank) {
-            // Load steps into the coordinator for endTrajectory processing
-            for (const step of steps) {
-                sonaCoordinator.addTrajectoryStep(step);
-            }
-            await sonaCoordinator.endTrajectory(verdict, reasoningBank);
-            await sonaCoordinator.distillLearning(reasoningBank);
-        }
-        globalStats.trajectoriesRecorded++;
-        globalStats.lastAdaptation = Date.now();
-        savePersistedStats();
-        return true;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] recordTrajectory failed:', e);
-        return false;
-    }
-}
-export async function findSimilarPatterns(query, options) {
-    // Cap query length to prevent OOM via embedding generation on unbounded input
-    if (typeof query === 'string' && query.length > 2000) {
-        query = query.slice(0, 2000);
-    }
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    try {
-        // ADR-053: Try SQLite-backed memory bridge embedder first
-        let queryEmbedding = null;
-        try {
-            const bridge = await import('./memory-bridge.js');
-            const bridgeResult = await bridge.bridgeGenerateEmbedding(query);
-            if (bridgeResult) {
-                queryEmbedding = bridgeResult.embedding;
-            }
-        }
-        catch {
-            // Bridge not available
-        }
-        if (!queryEmbedding) {
-            const { generateEmbedding } = await import('./memory-initializer.js');
-            const queryResult = await generateEmbedding(query);
-            queryEmbedding = queryResult.embedding;
-        }
-        // Hash-fallback embeddings (128-dim) produce lower cosine similarities
-        // than ONNX/transformer embeddings, so use a lower default threshold
-        const isHashFallback = queryEmbedding.length === 128;
-        const defaultThreshold = isHashFallback ? 0.1 : 0.5;
-        const results = reasoningBank.findSimilar(queryEmbedding, {
-            k: options?.k ?? 5,
-            threshold: options?.threshold ?? defaultThreshold,
-            type: options?.type
-        });
-        // Record usage for each matched pattern (findSimilar is now a pure read)
-        for (const r of results) {
-            reasoningBank.recordUsage(r.id);
-        }
-        return results.map((r) => ({
-            id: r.id,
-            type: r.type,
-            embedding: r.embedding,
-            content: r.content,
-            confidence: r.confidence,
-            usageCount: r.usageCount,
-            createdAt: r.createdAt,
-            lastUsedAt: r.lastUsedAt,
-            similarity: r.similarity ?? r.confidence ?? 0.5
-        }));
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] findSimilarPatterns failed:', e);
-        return [];
-    }
-}
-/**
- * Get intelligence system statistics
- */
-export function getIntelligenceStats() {
-    const sonaStats = sonaCoordinator?.stats();
-    const bankStats = reasoningBank?.stats();
-    return {
-        sonaEnabled: !!sonaCoordinator,
-        reasoningBankSize: bankStats?.size ?? 0,
-        patternsLearned: bankStats?.patternCount ?? 0,
-        trajectoriesRecorded: globalStats.trajectoriesRecorded,
-        lastAdaptation: globalStats.lastAdaptation,
-        avgAdaptationTime: sonaStats?.avgAdaptationMs ?? 0
-    };
-}
-/**
- * Get SONA coordinator for advanced operations
- */
-export function getSonaCoordinator() {
-    return sonaCoordinator;
-}
-/**
- * Get ReasoningBank for advanced operations
- */
-export function getReasoningBank() {
-    return reasoningBank;
-}
-/**
- * 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
- */
-export async function endTrajectoryWithVerdict(verdict) {
-    if (!sonaCoordinator || !reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return null;
-    }
-    try {
-        const result = await sonaCoordinator.endTrajectory(verdict, reasoningBank);
-        globalStats.lastAdaptation = Date.now();
-        savePersistedStats();
-        return result;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] endTrajectoryWithVerdict failed:', e);
-        return null;
-    }
-}
-/**
- * Distill learning from recent successful trajectories.
- * Applies incremental confidence updates with EWC consolidation protection.
- *
- * @returns Distillation statistics or null if not initialized
- */
-export async function distillLearning() {
-    if (!sonaCoordinator || !reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return null;
-    }
-    try {
-        const result = await sonaCoordinator.distillLearning(reasoningBank);
-        globalStats.lastAdaptation = Date.now();
-        savePersistedStats();
-        return result;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] distillLearning failed:', e);
-        return null;
-    }
-}
-/**
- * Clear intelligence state
- */
-export function clearIntelligence() {
-    sonaCoordinator = null;
-    reasoningBank = null;
-    intelligenceInitialized = false;
-    // Must be dropped too. initializeIntelligence() returns an existing
-    // initPromise without re-running init, so leaving the resolved promise here
-    // made every later init report success while sonaCoordinator and
-    // reasoningBank stayed null — after which the non-null assertions in
-    // clearAllPatterns()/getAllPatterns() etc. threw
-    // "Cannot read properties of null". Intelligence could never be
-    // re-initialized after a clear, for the life of the process.
-    initPromise = null;
-    globalStats = {
-        trajectoriesRecorded: 0,
-        lastAdaptation: null
-    };
-}
-/**
- * Benchmark SONA adaptation time
- */
-export function benchmarkAdaptation(iterations = 1000) {
-    if (!sonaCoordinator) {
-        return { totalMs: 0, avgMs: 0, minMs: 0, maxMs: 0, targetMet: false };
-    }
-    // Cap iterations to prevent OOM/CPU exhaustion from unbounded caller input
-    const safeIterations = Math.min(Math.max(1, iterations >>> 0), 100_000);
-    const times = [];
-    const testEmbedding = Array.from({ length: 384 }, () => Math.random());
-    for (let i = 0; i < safeIterations; i++) {
-        const start = performance.now();
-        sonaCoordinator.recordSignal({
-            type: 'test',
-            content: `benchmark_${i}`,
-            embedding: testEmbedding,
-            timestamp: Date.now()
-        });
-        times.push(performance.now() - start);
-    }
-    const totalMs = times.reduce((a, b) => a + b, 0);
-    const avgMs = totalMs / safeIterations;
-    const minMs = Math.min(...times);
-    const maxMs = Math.max(...times);
-    return {
-        totalMs,
-        avgMs,
-        minMs,
-        maxMs,
-        targetMet: avgMs < 0.05
-    };
-}
-// ============================================================================
-// Pattern Persistence API
-// ============================================================================
-/**
- * Read routing patterns from the SONA optimizer's .swarm/sona-patterns.json
- * and convert them to the standard Pattern shape used by intelligence.ts.
- * Returns an empty array when the file is absent or unreadable.
- */
-function loadSonaRoutingPatterns() {
-    try {
-        const sonaPath = join(process.cwd(), '.swarm', 'sona-patterns.json');
-        if (!existsSync(sonaPath))
-            return [];
-        if (statSync(sonaPath).size > 10 * 1024 * 1024)
-            return [];
-        const raw = JSON.parse(readFileSync(sonaPath, 'utf-8'));
-        const persisted = raw;
-        if (!persisted.patterns || typeof persisted.patterns !== 'object' || Array.isArray(persisted.patterns))
-            return [];
-        const now = Date.now();
-        const results = [];
-        // Cap total entries to prevent DoS via an unbounded patterns map.
-        // sona-patterns.json is written by the SONA optimizer but could be
-        // replaced by a malicious IPFS bundle — validate every field before use.
-        const MAX_SONA_ENTRIES = 500;
-        let entryCount = 0;
-        for (const [key, p] of Object.entries(persisted.patterns)) {
-            // Prototype pollution guard — skip __proto__ / constructor / prototype keys.
-            if (key === '__proto__' || key === 'constructor' || key === 'prototype')
-                continue;
-            if (typeof key !== 'string' || key.length === 0 || key.length > 256)
-                continue;
-            if (entryCount++ >= MAX_SONA_ENTRIES)
-                break;
-            if (!p || typeof p !== 'object')
-                continue;
-            // Validate keywords: must be a bounded array of short strings.
-            const rawKw = p.keywords;
-            let keywords;
-            if (rawKw === undefined) {
-                keywords = [key];
-            }
-            else if (Array.isArray(rawKw) && rawKw.length <= 64
-                && rawKw.every(k => typeof k === 'string' && k.length > 0 && k.length <= 128)) {
-                keywords = rawKw;
-            }
-            else {
-                continue; // malformed keywords — skip entry
-            }
-            // Validate agent string.
-            const agent = p.agent;
-            if (agent !== undefined && (typeof agent !== 'string' || agent.length === 0 || agent.length > 128))
-                continue;
-            // Validate confidence is a finite number in [0, 1].
-            const rawConf = p.confidence;
-            const confidence = rawConf !== undefined ? rawConf : 0.5;
-            if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1)
-                continue;
-            // Validate usage counts are safe integers.
-            const sc = p.successCount ?? 0;
-            const fc = p.failureCount ?? 0;
-            if (typeof sc !== 'number' || !Number.isFinite(sc) || sc < 0 || sc > 1e9)
-                continue;
-            if (typeof fc !== 'number' || !Number.isFinite(fc) || fc < 0 || fc > 1e9)
-                continue;
-            // Validate createdAt is a reasonable epoch ms value.
-            const rawTs = p.createdAt;
-            const createdAt = (rawTs !== undefined && typeof rawTs === 'number' && Number.isFinite(rawTs) && rawTs >= 0 && rawTs <= 9.9e12)
-                ? rawTs
-                : now;
-            results.push({
-                id: `sona:${key}`,
-                type: agent ?? 'routing',
-                content: keywords.join(' '),
-                confidence,
-                usageCount: sc + fc,
-                embedding: [],
-                createdAt,
-                lastUsedAt: now,
-            });
-        }
-        return results;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[intelligence] failed to load .swarm/sona-patterns.json:', e);
-        return [];
-    }
-}
-/**
- * Get all patterns from ReasoningBank, merged with SONA routing patterns.
- * Returns persisted patterns even after process restart.
- */
-export async function getAllPatterns() {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    const bankPatterns = reasoningBank.getAll().map(p => ({
-        id: p.id,
-        type: p.type,
-        embedding: p.embedding,
-        content: p.content,
-        confidence: p.confidence,
-        usageCount: p.usageCount,
-        createdAt: p.createdAt,
-        lastUsedAt: p.lastUsedAt
-    }));
-    // Merge in SONA routing patterns so `neural patterns list` shows what
-    // the hooks SONA optimizer has learned, not just ReasoningBank entries.
-    const bankIds = new Set(bankPatterns.map(p => p.id));
-    const sonaPatterns = loadSonaRoutingPatterns().filter(p => !bankIds.has(p.id));
-    return [...bankPatterns, ...sonaPatterns];
-}
-/**
- * Get patterns by type from ReasoningBank
- */
-export async function getPatternsByType(type) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return [];
-    }
-    return reasoningBank.getByType(type).map(p => ({
-        id: p.id,
-        type: p.type,
-        embedding: p.embedding,
-        content: p.content,
-        confidence: p.confidence,
-        usageCount: p.usageCount,
-        createdAt: p.createdAt,
-        lastUsedAt: p.lastUsedAt
-    }));
-}
-/**
- * Flush patterns to disk immediately
- * Call this at the end of training to ensure all patterns are saved
- */
-export function flushPatterns() {
-    if (reasoningBank) {
-        reasoningBank.flushToDisk();
-    }
-    savePersistedStats();
-}
-/**
- * Compact patterns by removing duplicates/similar patterns
- * @param threshold Similarity threshold (0-1), patterns above this are considered duplicates
- */
-export async function compactPatterns(threshold = 0.95) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success) {
-            return { before: 0, after: 0, removed: 0 };
-        }
-    }
-    const patterns = reasoningBank.getAll();
-    const before = patterns.length;
-    // Find duplicates using cosine similarity
-    const toRemove = new Set();
-    for (let i = 0; i < patterns.length; i++) {
-        if (toRemove.has(patterns[i].id))
-            continue;
-        const embA = patterns[i].embedding;
-        if (!embA || embA.length === 0)
-            continue;
-        for (let j = i + 1; j < patterns.length; j++) {
-            if (toRemove.has(patterns[j].id))
-                continue;
-            const embB = patterns[j].embedding;
-            if (!embB || embB.length === 0 || embA.length !== embB.length)
-                continue;
-            // Compute cosine similarity
-            let dotProduct = 0;
-            let normA = 0;
-            let normB = 0;
-            for (let k = 0; k < embA.length; k++) {
-                dotProduct += embA[k] * embB[k];
-                normA += embA[k] * embA[k];
-                normB += embB[k] * embB[k];
-            }
-            const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-            if (similarity >= threshold) {
-                // Remove the one with lower usage count
-                const useA = patterns[i].usageCount || 0;
-                const useB = patterns[j].usageCount || 0;
-                toRemove.add(useA >= useB ? patterns[j].id : patterns[i].id);
-            }
-        }
-    }
-    // Remove duplicates
-    for (const id of toRemove) {
-        reasoningBank.delete(id);
-    }
-    // Flush to disk
-    flushPatterns();
-    return {
-        before,
-        after: before - toRemove.size,
-        removed: toRemove.size,
-    };
-}
-/**
- * Delete a pattern by ID
- */
-export async function deletePattern(id) {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return false;
-    }
-    return reasoningBank.delete(id);
-}
-/**
- * Clear all patterns (both in memory and on disk)
- */
-export async function clearAllPatterns() {
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return;
-    }
-    reasoningBank.clear();
-}
-const memoryProficiencyStats = {
-    totalDecisions: 0,
-    successfulDecisions: 0,
-    patternHits: 0,
-    patternMisses: 0,
-};
-/**
- * Record a memory decision from a completed task. Stores successful patterns
- * in the 'memory-proficiency' domain so future PLAN routines can retrieve them.
- */
-export async function recordMemoryDecision(input) {
-    memoryProficiencyStats.totalDecisions++;
-    if (input.success)
-        memoryProficiencyStats.successfulDecisions++;
-    if (!input.success || !input.taskDescription || input.taskDescription.length < 10)
-        return;
-    if (!reasoningBank) {
-        const init = await initializeIntelligence();
-        if (!init.success)
-            return;
-    }
-    try {
-        let embedding = null;
-        try {
-            const bridge = await import('./memory-bridge.js');
-            const result = await bridge.bridgeGenerateEmbedding(input.taskDescription);
-            if (result)
-                embedding = result.embedding;
-        }
-        catch { /* bridge unavailable */ }
-        if (!embedding) {
-            const { generateEmbedding } = await import('./memory-initializer.js');
-            embedding = (await generateEmbedding(input.taskDescription)).embedding;
-        }
-        // Check for similar existing pattern to avoid redundant storage
-        const existing = reasoningBank.findSimilar(embedding, { k: 1, threshold: 0.85, type: 'memory-proficiency' });
-        if (existing.length > 0) {
-            reasoningBank.recordUsage(existing[0].id);
-            memoryProficiencyStats.patternHits++;
-            return;
-        }
-        memoryProficiencyStats.patternMisses++;
-        reasoningBank.store({
-            id: `mprof_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
-            type: 'memory-proficiency',
-            embedding,
-            content: `[${input.agent}] ${input.taskDescription}`,
-            confidence: input.success ? 0.8 : 0.3,
-            metadata: {
-                agent: input.agent,
-                latencyMs: input.latencyMs,
-            },
-        });
-    }
-    catch { /* non-fatal */ }
-}
-/**
- * Return memory proficiency stats for doctor health check.
- */
-export function getMemoryProficiencyStats() {
-    const { totalDecisions, successfulDecisions, patternHits, patternMisses } = memoryProficiencyStats;
-    const proficiencyPatterns = reasoningBank?.getByType('memory-proficiency').length ?? 0;
-    const totalLookups = patternHits + patternMisses;
-    return {
-        totalDecisions,
-        successRate: totalDecisions > 0 ? successfulDecisions / totalDecisions : 0,
-        proficiencyPatterns,
-        patternHitRate: totalLookups > 0 ? patternHits / totalLookups : 0,
-    };
-}
-/**
- * Get the neural data directory path
- */
-export function getNeuralDataDir() {
-    return getDataDir();
-}
-/**
- * Get persistence status
- */
-export function getPersistenceStatus() {
-    const dataDir = getDataDir();
-    const patternsFile = getPatternsPath();
-    const statsFile = getStatsPath();
-    return {
-        enabled: true,
-        dataDir,
-        patternsFile,
-        statsFile,
-        patternsExist: existsSync(patternsFile),
-        statsExist: existsSync(statsFile)
-    };
-}
-//# sourceMappingURL=intelligence.js.map