mindforge-cc 8.1.1 → 8.2.0

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

@@ -0,0 +1,326 @@
+/**
+ * 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

@@ -0,0 +1,293 @@
+/**
+ * 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

@@ -0,0 +1,69 @@
+/**
+ * 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();