mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/embedding-engine.js

@@ -1,326 +0,0 @@
-/**
- * MindForge v2.4.0 — Embedding Engine (RAG 2.0)
- * Local-first TF-IDF vector space for semantic similarity.
- *
- * No external API dependencies — runs entirely on local compute.
- * Provides vectorization and cosine similarity for the Knowledge Graph.
- *
- * Design:
- * - Sparse TF-IDF vectors stored as { token → weight } objects
- * - Cosine similarity for semantic matching between entries
- * - Embedding cache persisted to disk for fast session restarts
- * - Auto-edge inference when similarity exceeds threshold
- */
-'use strict';
-
-const fs     = require('fs');
-const path   = require('path');
-const crypto = require('crypto');
-
-// ── Configuration ─────────────────────────────────────────────────────────────
-const SIMILARITY_THRESHOLD   = 0.65;  // Auto-edge creation threshold
-const SHADOW_THRESHOLD       = 0.50;  // Minimum similarity for auto-shadow retrieval
-const MAX_VECTOR_TERMS       = 200;   // Cap sparse vector dimensionality
-const CACHE_SCHEMA_VERSION   = '1.0.0';
-
-// ── Stopwords (expanded for technical content) ────────────────────────────────
-const STOPWORDS = new Set([
-  'the', 'a', 'an', 'is', 'it', 'in', 'on', 'at', 'to', 'for', 'of', 'and',
-  'or', 'but', 'not', 'this', 'that', 'with', 'from', 'by', 'be', 'are',
-  'was', 'were', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
-  'could', 'should', 'may', 'might', 'can', 'use', 'using', 'used', 'when',
-  'where', 'which', 'what', 'how', 'why', 'who', 'all', 'any', 'some', 'we',
-  'our', 'they', 'their', 'you', 'your', 'my', 'its', 'also', 'just', 'more',
-  'very', 'been', 'being', 'each', 'then', 'than', 'into', 'only', 'other',
-  'such', 'like', 'over', 'after', 'before', 'between', 'through', 'about',
-  'will', 'shall', 'must', 'need', 'make', 'made', 'get', 'got', 'set',
-  'new', 'old', 'see', 'way', 'well', 'back', 'even', 'give', 'most',
-]);
-
-// ── Tokenizer ─────────────────────────────────────────────────────────────────
-
-/**
- * Tokenize text into normalized, filtered terms.
- * Handles camelCase, snake_case, and kebab-case splitting.
- * @param {string} text - Raw text to tokenize
- * @returns {string[]} Filtered tokens
- */
-function tokenize(text) {
-  if (!text || typeof text !== 'string') return [];
-
-  return text
-    // Split camelCase: "userId" → "user Id"
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    // Split snake_case and kebab-case
-    .replace(/[_-]/g, ' ')
-    // Remove non-alphanumeric (keep dots for versions)
-    .replace(/[^a-zA-Z0-9.\s]/g, ' ')
-    .toLowerCase()
-    .split(/\s+/)
-    .filter(w => w.length > 2 && !STOPWORDS.has(w));
-}
-
-/**
- * Extract n-grams (bigrams) from tokens for compound term matching.
- * "react memo" stays as a single feature "react_memo".
- * @param {string[]} tokens - Unigram tokens
- * @returns {string[]} Bigram tokens
- */
-function bigrams(tokens) {
-  const result = [];
-  for (let i = 0; i < tokens.length - 1; i++) {
-    result.push(`${tokens[i]}_${tokens[i + 1]}`);
-  }
-  return result;
-}
-
-// ── TF-IDF Vectorization ──────────────────────────────────────────────────────
-
-/**
- * Build a document-frequency map from a corpus of documents.
- * @param {Array<{id: string, tokens: string[]}>} corpus
- * @returns {Map<string, number>} token → document frequency
- */
-function buildDocumentFrequency(corpus) {
-  const df = new Map();
-  for (const doc of corpus) {
-    const unique = new Set(doc.tokens);
-    for (const token of unique) {
-      df.set(token, (df.get(token) || 0) + 1);
-    }
-  }
-  return df;
-}
-
-/**
- * Compute TF-IDF vector for a single document.
- * @param {string[]} tokens - Document tokens
- * @param {Map<string, number>} df - Document frequency map
- * @param {number} N - Total document count
- * @returns {Object<string, number>} Sparse vector { token → weight }
- */
-function computeTfIdfVector(tokens, df, N) {
-  if (tokens.length === 0) return {};
-
-  // Term frequency
-  const tf = {};
-  for (const t of tokens) {
-    tf[t] = (tf[t] || 0) + 1;
-  }
-
-  // TF-IDF weights
-  const vector = {};
-  for (const [term, count] of Object.entries(tf)) {
-    const termFreq = count / tokens.length;                // Normalized TF
-    const docFreq  = df.get(term) || 1;
-    const idf      = Math.log((N + 1) / (docFreq + 1)) + 1; // Smoothed IDF
-    vector[term]   = termFreq * idf;
-  }
-
-  // Cap dimensionality: keep only top-N terms by weight
-  const sorted = Object.entries(vector)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, MAX_VECTOR_TERMS);
-
-  const capped = {};
-  for (const [term, weight] of sorted) {
-    capped[term] = weight;
-  }
-
-  return capped;
-}
-
-// ── Similarity ────────────────────────────────────────────────────────────────
-
-/**
- * Compute cosine similarity between two sparse vectors.
- * @param {Object<string, number>} vecA - Sparse vector A
- * @param {Object<string, number>} vecB - Sparse vector B
- * @returns {number} Cosine similarity [0, 1]
- */
-function cosineSimilarity(vecA, vecB) {
-  if (!vecA || !vecB) return 0;
-
-  const keysA = Object.keys(vecA);
-  const keysB = Object.keys(vecB);
-  if (keysA.length === 0 || keysB.length === 0) return 0;
-
-  // Dot product (only over shared terms)
-  let dot = 0;
-  for (const key of keysA) {
-    if (vecB[key]) {
-      dot += vecA[key] * vecB[key];
-    }
-  }
-
-  if (dot === 0) return 0;
-
-  // Magnitudes
-  let magA = 0;
-  for (const v of Object.values(vecA)) magA += v * v;
-  magA = Math.sqrt(magA);
-
-  let magB = 0;
-  for (const v of Object.values(vecB)) magB += v * v;
-  magB = Math.sqrt(magB);
-
-  if (magA === 0 || magB === 0) return 0;
-
-  return dot / (magA * magB);
-}
-
-// ── Corpus Manager ────────────────────────────────────────────────────────────
-
-/**
- * Build embeddings for all knowledge entries.
- * @param {object[]} entries - Knowledge entries with { id, topic, content, tags }
- * @returns {{ vectors: Map<string, object>, df: Map<string, number> }}
- */
-function buildEmbeddings(entries) {
-  // Tokenize all entries
-  const corpus = entries
-    .filter(e => !e.deprecated)
-    .map(e => {
-      const text = `${e.topic || ''} ${e.content || ''} ${(e.tags || []).join(' ')}`;
-      const unigrams = tokenize(text);
-      const bi = bigrams(unigrams);
-      return { id: e.id, tokens: [...unigrams, ...bi] };
-    });
-
-  const df = buildDocumentFrequency(corpus);
-  const N  = corpus.length;
-
-  const vectors = new Map();
-  for (const doc of corpus) {
-    vectors.set(doc.id, computeTfIdfVector(doc.tokens, df, N));
-  }
-
-  return { vectors, df, N };
-}
-
-/**
- * Compute embedding for a single query string against an existing corpus.
- * @param {string} queryText - Natural language query
- * @param {Map<string, number>} df - Document frequency from corpus
- * @param {number} N - Total document count
- * @returns {Object<string, number>} Query vector
- */
-function embedQuery(queryText, df, N) {
-  const unigrams = tokenize(queryText);
-  const bi = bigrams(unigrams);
-  return computeTfIdfVector([...unigrams, ...bi], df, N);
-}
-
-/**
- * Find the top-K most similar entries to a query.
- * @param {string} queryText - Natural language query
- * @param {Map<string, object>} vectors - Precomputed entry vectors
- * @param {Map<string, number>} df - Document frequency
- * @param {number} N - Corpus size
- * @param {number} topK - Max results
- * @param {number} minSimilarity - Minimum cosine similarity (default: SHADOW_THRESHOLD)
- * @returns {Array<{id: string, similarity: number}>}
- */
-function findSimilar(queryText, vectors, df, N, topK = 10, minSimilarity = SHADOW_THRESHOLD) {
-  const queryVec = embedQuery(queryText, df, N);
-  const results = [];
-
-  for (const [id, vec] of vectors) {
-    const sim = cosineSimilarity(queryVec, vec);
-    if (sim >= minSimilarity) {
-      results.push({ id, similarity: sim });
-    }
-  }
-
-  return results
-    .sort((a, b) => b.similarity - a.similarity)
-    .slice(0, topK);
-}
-
-/**
- * Find entries that should be auto-linked (similarity > SIMILARITY_THRESHOLD).
- * @param {string} entryId - The new entry's ID
- * @param {Map<string, object>} vectors - All entry vectors
- * @returns {Array<{targetId: string, similarity: number}>} Candidate edges
- */
-function inferEdges(entryId, vectors) {
-  const entryVec = vectors.get(entryId);
-  if (!entryVec) return [];
-
-  const candidates = [];
-  for (const [id, vec] of vectors) {
-    if (id === entryId) continue;
-    const sim = cosineSimilarity(entryVec, vec);
-    if (sim >= SIMILARITY_THRESHOLD) {
-      candidates.push({ targetId: id, similarity: sim });
-    }
-  }
-
-  return candidates.sort((a, b) => b.similarity - a.similarity);
-}
-
-// ── Embedding Cache ───────────────────────────────────────────────────────────
-
-/**
- * Save embedding cache to disk.
- * @param {string} cachePath - Absolute path to cache file
- * @param {Map<string, object>} vectors - Entry vectors
- * @param {Map<string, number>} df - Document frequency
- * @param {number} N - Corpus size
- */
-function saveCache(cachePath, vectors, df, N) {
-  const data = {
-    schema_version: CACHE_SCHEMA_VERSION,
-    updated_at: new Date().toISOString(),
-    corpus_size: N,
-    df: Object.fromEntries(df),
-    vectors: Object.fromEntries(vectors),
-    checksum: '',
-  };
-
-  const payload = JSON.stringify(data);
-  data.checksum = crypto.createHash('sha256').update(payload).digest('hex');
-
-  const dir = path.dirname(cachePath);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(cachePath, JSON.stringify(data, null, 2));
-}
-
-/**
- * Load embedding cache from disk.
- * @param {string} cachePath - Absolute path to cache file
- * @returns {{ vectors: Map<string, object>, df: Map<string, number>, N: number } | null}
- */
-function loadCache(cachePath) {
-  if (!fs.existsSync(cachePath)) return null;
-
-  try {
-    const raw = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
-    if (raw.schema_version !== CACHE_SCHEMA_VERSION) return null;
-
-    return {
-      vectors: new Map(Object.entries(raw.vectors || {})),
-      df:      new Map(Object.entries(raw.df || {})),
-      N:       raw.corpus_size || 0,
-    };
-  } catch {
-    return null; // Corrupt cache — rebuild
-  }
-}
-
-// ── Exports ───────────────────────────────────────────────────────────────────
-module.exports = {
-  tokenize,
-  bigrams,
-  buildDocumentFrequency,
-  computeTfIdfVector,
-  cosineSimilarity,
-  buildEmbeddings,
-  embedQuery,
-  findSimilar,
-  inferEdges,
-  saveCache,
-  loadCache,
-  SIMILARITY_THRESHOLD,
-  SHADOW_THRESHOLD,
-};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/federated-sync.js

@@ -1,293 +0,0 @@
-/**
- * MindForge v5 — Federated Knowledge Sync
- * Upgrades the local global-sync.js to a distributed intelligence mesh.
- */
-'use strict';
-
-const fs    = require('node:fs');
-const path  = require('node:path');
-const Store = require('./knowledge-store');
-const EISClient = require('./eis-client');
-const crypto = require('node:crypto');
-const EmbeddingEngine = require('./embedding-engine');
-const adsEngine = require('../review/ads-engine');
-
-class FederatedSync {
-  constructor(config = {}) {
-    this.client = new EISClient(config);
-    this.localStore = Store;
-    this.syncHistoryPath = path.join(Store.getPaths().MEMORY_DIR, 'sync-history.jsonl');
-    this.circuitBreakerPath = path.join(Store.getPaths().MEMORY_DIR, 'circuit-breaker.json');
-    this.MAX_FAILURES = 3;
-    this.COOLDOWN_MS = 3600000; // 1 hour
-  }
-
-  /**
-   * [ENTERPRISE] Checks if the circuit is open.
-   */
-  isCircuitOpen() {
-    if (!fs.existsSync(this.circuitBreakerPath)) return false;
-    try {
-      const state = JSON.parse(fs.readFileSync(this.circuitBreakerPath, 'utf8'));
-      if (state.status === 'OPEN' && (Date.now() - state.trippedAt < this.COOLDOWN_MS)) {
-        return true;
-      }
-      // Reset if cooldown passed
-      if (state.status === 'OPEN') {
-        this.resetCircuit();
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  tripCircuit(reason) {
-    console.warn(`[CIRCUIT-BREAKER] ⚠️ Circuit Breaker TRIPPED: ${reason}. Mesh sync disabled for 1hr.`);
-    const state = { status: 'OPEN', trippedAt: Date.now(), reason };
-    fs.writeFileSync(this.circuitBreakerPath, JSON.stringify(state, null, 2));
-  }
-
-  resetCircuit() {
-    if (fs.existsSync(this.circuitBreakerPath)) {
-      fs.unlinkSync(this.circuitBreakerPath);
-    }
-  }
-
-  handleSyncFailure(err) {
-    const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
-    let stats = { failures: 0 };
-    if (fs.existsSync(statsPath)) {
-      stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
-    }
-    stats.failures = (stats.failures || 0) + 1;
-    stats.last_error = err.message;
-    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2));
-
-    if (stats.failures >= this.MAX_FAILURES) {
-      this.tripCircuit(err.message);
-    }
-  }
-
-  /**
-   * Performs an organizational-wide synchronization.
-   * This pushes local high-confidence entries and pulls new organizational knowledge.
-   */
-  async fullSync() {
-    if (this.isCircuitOpen()) {
-      console.warn('🛑 Federated Intelligence Sync: Circuit is OPEN. Skipping network calls.');
-      return { status: 'CIRCUIT_OPEN' };
-    }
-
-    console.log('🔄 Initiating Federated Intelligence Sync (v5.4.0 ENTERPRISE)...');
-    
-    try {
-      // 1. Get promotable entries (Tiers 1-3)
-      const localEntries = this.localStore.readAll(false).filter(e => e.confidence > 0.8 && !e.deprecated);
-      
-      // 2. Filter out already synced entries
-      const unsynced = localEntries.filter(e => !e.global && !this.isRecentlySynced(e.id));
-      
-      // 3. Push to EIS
-      if (unsynced.length > 0) {
-        const auth = await this.client.getAuthHeader('push', 'kb/global');
-        const results = await this.client.push(unsynced, { headers: auth });
-        this.logSyncEvent(results);
-      }
-      
-      // 4. [HARDEN] Delta Pull from EIS
-      const lastSync = this.getLastSyncTimestamp();
-      const authPull = await this.client.getAuthHeader('pull', 'kb/global');
-      const remoteEntries = await this.client.pull({ 
-        orgId: this.client.orgId,
-        since: lastSync,
-        headers: authPull 
-      });
-
-      if (remoteEntries.length > 0) {
-        this.mergeRemoteKnowledge(remoteEntries);
-      }
-      
-      this.updateLastSyncTimestamp();
-      this.resetFailures(); // Reset on success
-      console.log(`✅ Federated Intelligence Mesh: Sync complete. (Delta since ${lastSync})`);
-      return { pushed: unsynced.length, pulled: remoteEntries.length };
-    } catch (err) {
-      console.error('❌ Federated Intelligence Sync FAILED:', err.message);
-      this.handleSyncFailure(err);
-      throw err;
-    }
-  }
-
-  resetFailures() {
-    const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
-    if (fs.existsSync(statsPath)) {
-      const stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
-      stats.failures = 0;
-      fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2));
-    }
-  }
-
-  getLastSyncTimestamp() {
-    const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
-    if (!fs.existsSync(statsPath)) return '1970-01-01T00:00:00Z';
-    try {
-      const stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
-      return stats.last_sync || '1970-01-01T00:00:00Z';
-    } catch {
-      return '1970-01-01T00:00:00Z';
-    }
-  }
-
-  updateLastSyncTimestamp() {
-    const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
-    const stats = { last_sync: new Date().toISOString() };
-    fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2));
-  }
-
-  /**
-   * Merges remote knowledge into the local global-knowledge-base.jsonl.
-   * Uses LWW (Last-Write-Wins) with cryptographic version checks.
-   */
-  mergeRemoteKnowledge(remoteEntries) {
-    const globalPath = this.localStore.getPaths().GLOBAL_KB_PATH;
-    const existingGlobalLines = fs.existsSync(globalPath) 
-      ? fs.readFileSync(globalPath, 'utf8').split('\n').filter(Boolean)
-      : [];
-      
-    const existingById = new Map();
-    for (const line of existingGlobalLines) {
-      const e = JSON.parse(line);
-      existingById.set(e.id, e);
-    }
-
-    let mergedCount = 0;
-    for (const remote of remoteEntries) {
-      const local = existingById.get(remote.id);
-      
-      if (!local) {
-        fs.appendFileSync(globalPath, JSON.stringify(remote) + '\n');
-        mergedCount++;
-        continue;
-      }
-
-      // Pillar I (v5.2.0): Hybrid Semantic synthesis
-      let similarity = 0;
-      try {
-        similarity = EmbeddingEngine.cosineSimilarity(
-          EmbeddingEngine.computeTfIdfVector(EmbeddingEngine.tokenize(local.content), {}, 1),
-          EmbeddingEngine.computeTfIdfVector(EmbeddingEngine.tokenize(remote.content), {}, 1)
-        );
-      } catch (err) {
-        console.error(`[FIM-ERR] Semantic analysis failed for ${local.id}. Falling back to LWW.`, err);
-        // Fallback to basic LWW (Last-Write-Wins)
-        if (new Date(remote.timestamp) > new Date(local.timestamp)) {
-          this.writeToGlobalKB(remote, globalPath);
-        }
-        continue;
-      }
-
-      this.triggerHybridSynthesis(local, remote, similarity, globalPath);
-      mergedCount++;
-    }
-    
-    return mergedCount;
-  }
-
-  /**
-   * Hybrid Synthesis Logic (Pillar I v5.2.0)
-   */
-  async triggerHybridSynthesis(local, remote, similarity, globalPath) {
-    console.log(`[FIM-SYNC] Analyzing semantic overlap for ${local.id} (Similarity: ${similarity.toFixed(4)})`);
-
-    // 1. LWW (Similarity > 0.9) - Near identical
-    if (similarity > 0.9) {
-      if (new Date(remote.timestamp) > new Date(local.timestamp)) {
-        this.writeToGlobalKB(remote, globalPath);
-        this.logConflictTelemetry(local.id, 'LWW', similarity);
-        console.log('  └─ [LWW] Auto-resolved via timestamp.');
-      }
-      return;
-    }
-
-    // 2. Autonomous Merge (0.75 - 0.9) - Semantic Overlap
-    if (similarity > 0.75) {
-      console.log('  └─ [ADS] Triggering Autonomous Knowledge Synthesis...');
-      const merged = await this.triggerADSMerging(local, remote);
-      this.writeToGlobalKB(merged, globalPath);
-      this.logConflictTelemetry(local.id, 'ADS_MERGE', similarity);
-      return;
-    }
-
-    // 3. Human Stewardship (0.6 - 0.75) - Probable Disagreement
-    if (similarity > 0.6) {
-      console.log('  └─ [DHH] High disagreement. Triggering Nexus Handover...');
-      this.localStore.markConflict(local.id, remote);
-      this.logConflictTelemetry(local.id, 'DHH_HANDOVER', similarity);
-      return;
-    }
-
-    // 4. Collision Isolation (< 0.6) - Topic Mismatch
-    console.log('  └─ [ISO] Semantic collision (Topic mismatch). Isolating entries.');
-    this.writeToGlobalKB({ ...remote, id: `${remote.id}_collision_${Date.now()}` }, globalPath);
-    this.logConflictTelemetry(local.id, 'COLLISION_ISOLATION', similarity);
-  }
-
-  logConflictTelemetry(id, resolution, similarity) {
-    const telePath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-telemetry.jsonl');
-    const entry = JSON.stringify({
-      id,
-      resolution,
-      similarity,
-      timestamp: new Date().toISOString()
-    }) + '\n';
-    fs.appendFileSync(telePath, entry);
-  }
-
-  async triggerADSMerging(local, remote) {
-    const result = await adsEngine.runADSSynthesis({
-      phaseNum: 'SYNC',
-      goal: `Synthesize a unified knowledge entry for topic: ${local.topic || local.id}`,
-      context: `Local Entry: ${local.content}\n\nRemote Entry: ${remote.content}`,
-      sessionId: 'fim-sync-v5.2.0'
-    });
-
-    // Extract the final plan/content from ADS result
-    const mergedContent = fs.readFileSync(path.join(process.cwd(), '.planning', 'PLAN.md'), 'utf8');
-    
-    return {
-      ...remote,
-      content: mergedContent,
-      confidence: 1.0,
-      synthesis_id: result.ads_id,
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  writeToGlobalKB(entry, globalPath) {
-    fs.appendFileSync(globalPath, JSON.stringify(entry) + '\n');
-  }
-
-  isRecentlySynced(id) {
-    // Simple check against local sync-history log
-    if (!fs.existsSync(this.syncHistoryPath)) return false;
-    const history = fs.readFileSync(this.syncHistoryPath, 'utf8');
-    return history.includes(id);
-  }
-
-  logSyncEvent(results) {
-    const log = results.map(r => JSON.stringify({ ...r, timestamp: new Date().toISOString() })).join('\n') + '\n';
-    fs.mkdirSync(path.dirname(this.syncHistoryPath), { recursive: true });
-    fs.appendFileSync(this.syncHistoryPath, log);
-  }
-}
-
-/**
- * Migration helper from global-sync.js
- */
-async function runSync(options = {}) {
-  const sync = new FederatedSync(options);
-  return await sync.fullSync();
-}
-
-module.exports = { FederatedSync, runSync };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/ghost-pattern-detector.js

@@ -1,69 +0,0 @@
-/**
- * MindForge Ghost Pattern Detector
- * v4.2.5 — Proactive Risk Mitigation
- */
-
-const semanticHub = require('./semantic-hub');
-const fs = require('node:fs/promises');
-
-class GhostPatternDetector {
-  /**
-   * Analyzes a newly proposed pattern against the global Ghost Hub.
-   * @param {Object} proposedPattern - The architecture/pattern being proposed.
-   * @returns {Promise<Array<Object>>} - List of detected risks.
-   */
-  async analyzeRisk(proposedPattern) {
-    console.log(`[GHOST-DETECTOR] Analyzing proposed pattern: ${proposedPattern.id}`);
-
-    // 1. Fetch ghost patterns from semantic hub
-    const ghostPatterns = await semanticHub.getGhostPatterns();
-    if (ghostPatterns.length === 0) return [];
-
-    // 2. Fuzzy match or Tag overlap logic (Simulated)
-    const risks = ghostPatterns.filter(ghost => {
-      // Check for tag overlap
-      const overlap = ghost.tags.filter(t => proposedPattern.tags.includes(t));
-      
-      // If there's an overlap and the ghost is tagged 'failure', trigger a risk.
-      const isRisk = (overlap.length >= 2 || ghost.tags.includes('critical-fail'));
-      if (isRisk) {
-        console.warn(`[GHOST-DETECTOR] Found potential ghost match: ${ghost.id} (Tags: ${overlap.join(',')})`);
-      }
-      return isRisk;
-    });
-
-    return risks.map(r => ({
-      ghostId: r.id,
-      riskLevel: r.tags.includes('p0') ? 'CRITICAL' : 'HIGH',
-      description: `Pattern similarity detected with past failure: ${r.failureContext || 'N/A'}`,
-      mitigation: r.mitigationStrategy || 'Consult mf-reviewer for deep-audit.'
-    }));
-  }
-
-  /**
-   * Batch scan the local project for ghost patterns.
-   */
-  async fullScan() {
-    const localPatterns = await this.loadLocalPatterns();
-    const allRisks = [];
-
-    for (const p of localPatterns) {
-      const risks = await this.analyzeRisk(p);
-      if (risks.length > 0) allRisks.push({ patternId: p.id, risks });
-    }
-
-    return allRisks;
-  }
-
-  async loadLocalPatterns() {
-    const localFile = '.mindforge/memory/pattern-library.jsonl';
-    try {
-      const data = await fs.readFile(localFile, 'utf8');
-      return data.split('\n').filter(Boolean).map(JSON.parse);
-    } catch (e) {
-      return [];
-    }
-  }
-}
-
-module.exports = new GhostPatternDetector();