mindforge-cc 10.0.3 → 11.0.0

package/bin/governance/ztai-manager.js

@@ -122,9 +122,10 @@ class QuantumSafeKeyProvider extends KeyProvider {
   async sign(did, data) {
     const record = this.keyStore.get(did);
     if (!record) throw new Error(`PQ record not found for ${did}`);
-    
+
     console.log(`[PQAS-DILITHIUM] Delegating signature to lattice enclave [DID: ${did}]`);
-    return await this.quantumCrypto.signPQ(data, record.privateKey);
+    const result = await this.quantumCrypto.signPQ(data, record.privateKey);
+    return result;
   }
 
   async rotate(did) {
@@ -148,24 +149,34 @@ class ZTAIManager {
 
   /**
    * Registers a new agent and assigns a provider based on Trust Tier.
+   * @param {string} persona - Agent persona identifier
+   * @param {number} tier - Trust tier (1-4)
+   * @param {string|null} sessionId - Optional session scope for isolation
    */
-  async registerAgent(persona, tier = 1) {
+  async registerAgent(persona, tier = 1, sessionId = null) {
     const uuid = crypto.randomUUID();
     const did = `did:mindforge:${uuid}`;
-    
+
     // Tier 3 agents use the SecureEnclaveProvider
     const providerType = tier >= 3 ? 'enclave' : 'local';
     const provider = this.providers[providerType];
-    
+
     const publicKeyPEM = await provider.generate(did);
 
-    this.agentRegistry.set(did, {
+    const agentData = {
       publicKey: publicKeyPEM,
       persona,
       tier,
       providerType,
       createdAt: new Date().toISOString()
-    });
+    };
+
+    // Store sessionId if provided for session-scoped isolation
+    if (sessionId) {
+      agentData.sessionId = sessionId;
+    }
+
+    this.agentRegistry.set(did, agentData);
 
     return did;
   }
@@ -219,6 +230,37 @@ class ZTAIManager {
     return this.agentRegistry.get(did);
   }
 
+  /**
+   * Returns all agents registered under a specific session.
+   * @param {string} sessionId - Session identifier to filter by
+   */
+  getSessionAgents(sessionId) {
+    const results = [];
+    for (const [did, agent] of this.agentRegistry.entries()) {
+      if (agent.sessionId === sessionId) {
+        results.push({ did, ...agent });
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Revokes all agents belonging to a session. Used for session cleanup.
+   * @param {string} sessionId - Session identifier
+   */
+  revokeSessionAgents(sessionId) {
+    const dids = [];
+    for (const [did, agent] of this.agentRegistry.entries()) {
+      if (agent.sessionId === sessionId) {
+        dids.push(did);
+      }
+    }
+    for (const did of dids) {
+      this.revokeAgent(did);
+    }
+    return dids;
+  }
+
   /**
    * Specialized signing for FinOps budget decisions (Pillar V).
    */

package/bin/hindsight-injector.js

@@ -43,9 +43,9 @@ class HindsightInjector {
       }
 
       // 4. Capture the new state immediately
-      TemporalHub.captureState(hindsightEvent.id, { 
-        event: 'hindsight_injected', 
-        target_id: auditId 
+      await TemporalHub.captureState(hindsightEvent.id, {
+        event: 'hindsight_injected',
+        target_id: auditId
       });
 
       return { success: true, event: hindsightEvent };

package/bin/memory/eis-client.js

@@ -22,19 +22,42 @@ class EISClient {
    * @param {Array} entries - Local knowledge entries to sync.
    */
   async push(entries) {
-    console.log(`[EIS-SYNC] Pushing ${entries.length} entries to Enterprise Intelligence Service...`);
-    
-    // Simulate network request
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        const results = entries.map(e => ({
-          id: e.id,
-          status: 'synced',
-          version: crypto.createHash('sha256').update(JSON.stringify(e)).digest('hex').slice(0, 8)
-        }));
-        resolve(results);
-      }, 500);
-    });
+    if (!this.endpoint || this.endpoint === 'http://localhost:7340') {
+      return {
+        synced: entries.length,
+        hashes: entries.map(e => e.id || crypto.createHash('sha256').update(JSON.stringify(e)).digest('hex').slice(0, 8))
+      };
+    }
+
+    const url = `${this.endpoint}/api/v1/knowledge/push`;
+    const body = JSON.stringify({ entries, orgId: this.orgId });
+
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const headers = await this.getAuthHeader('push', 'knowledge');
+        headers['Content-Type'] = 'application/json';
+
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: AbortSignal.timeout(10000)
+        });
+
+        if (!response.ok) {
+          throw new Error(`EIS push failed: ${response.status}`);
+        }
+
+        return await response.json();
+      } catch (e) {
+        lastError = e;
+        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+      }
+    }
+
+    console.warn(`[EIS] Push failed after 3 retries: ${lastError.message}`);
+    return { synced: 0, error: lastError.message };
   }
 
   /**
@@ -42,35 +65,49 @@ class EISClient {
    * @param {Object} filter - Filter criteria (e.g. since timestamp).
    */
   async pull(filter = {}) {
-    console.log(`[EIS-SYNC] Pulling new organizational knowledge from ${this.endpoint}...`);
-    
-    // Simulate network response
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        // Return empty array for now as this is a simulation
-        resolve([]);
-      }, 300);
-    });
+    if (!this.endpoint || this.endpoint === 'http://localhost:7340') {
+      return [];
+    }
+
+    const url = `${this.endpoint}/api/v1/knowledge/pull`;
+    const body = JSON.stringify({ filter, orgId: this.orgId });
+
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const headers = await this.getAuthHeader('pull', 'knowledge');
+        headers['Content-Type'] = 'application/json';
+
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: AbortSignal.timeout(10000)
+        });
+
+        if (!response.ok) {
+          throw new Error(`EIS pull failed: ${response.status}`);
+        }
+
+        return await response.json();
+      } catch (e) {
+        lastError = e;
+        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+      }
+    }
+
+    console.warn(`[EIS] Pull failed after 3 retries: ${lastError.message}`);
+    return [];
   }
 
-  /**
-   * Verifies the authenticity of a remote knowledge entry.
-   * @param {Object} entry - The remote entry.
-   * @param {String} signature - The ZTAI signature from the remote agent.
-   */
+  // TODO: implement when remote nodes are available
   verifyRemoteProvenance(entry, signature) {
     if (!signature) return false;
-    // Real implementation would use ZTAIManager to verify the DID signature
     return true;
   }
 
-  /**
-   * Resolves a remote node reference.
-   * @param {String} nodeId - The ID of the remote node.
-   */
+  // TODO: implement when remote nodes are available
   async resolveRemoteNode(nodeId) {
-    console.log(`[EIS-RESOLVE] Resolving remote node: ${nodeId}`);
-    // Real implementation would fetch from the EIS API
     return null;
   }
 

package/bin/memory/embedding-engine.js

@@ -130,6 +130,65 @@ function computeTfIdfVector(tokens, df, N) {
   return capped;
 }
 
+// ── BM25 Scoring ─────────────────────────────────────────────────────────────
+
+/**
+ * BM25 relevance scoring with document length normalization.
+ * @param {string[]} queryTokens - Tokenized query
+ * @param {string[]} docTokens - Tokenized document
+ * @param {Object<string, number>} docFrequency - term → number of docs containing term
+ * @param {number} totalDocs - Total documents in corpus
+ * @param {number} avgDocLength - Average document length across corpus
+ * @returns {number} BM25 score
+ */
+function bm25Score(queryTokens, docTokens, docFrequency, totalDocs, avgDocLength) {
+  const k1 = 1.5;
+  const b = 0.75;
+  let score = 0;
+  const docLength = docTokens.length;
+
+  for (const term of queryTokens) {
+    const tf = docTokens.filter(t => t === term).length;
+    const df = docFrequency[term] || 0;
+    const idf = Math.log((totalDocs - df + 0.5) / (df + 0.5) + 1);
+    const tfNorm = (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * (docLength / avgDocLength)));
+    score += idf * tfNorm;
+  }
+  return score;
+}
+
+/**
+ * Build a reusable BM25 index structure from knowledge entries.
+ * Applies 2x weighting to compound terms (camelCase/underscore bigrams).
+ * @param {object[]} entries - Knowledge entries with { id, topic, content, tags }
+ * @returns {{ docFrequency: Object<string, number>, avgDocLength: number, tokenizedDocs: Array<{id: string, tokens: string[]}> }}
+ */
+function buildBM25Index(entries) {
+  const tokenizedDocs = entries
+    .filter(e => !e.deprecated)
+    .map(e => {
+      const text = `${e.topic || ''} ${e.content || ''} ${(e.tags || []).join(' ')}`;
+      const unigrams = tokenize(text);
+      const bi = bigrams(unigrams);
+      // Weight compound terms at 2x by duplicating bigrams
+      const tokens = [...unigrams, ...bi, ...bi];
+      return { id: e.id, tokens };
+    });
+
+  const docFrequency = {};
+  for (const doc of tokenizedDocs) {
+    const unique = new Set(doc.tokens);
+    for (const term of unique) {
+      docFrequency[term] = (docFrequency[term] || 0) + 1;
+    }
+  }
+
+  const totalTokens = tokenizedDocs.reduce((sum, doc) => sum + doc.tokens.length, 0);
+  const avgDocLength = tokenizedDocs.length > 0 ? totalTokens / tokenizedDocs.length : 0;
+
+  return { docFrequency, avgDocLength, tokenizedDocs };
+}
+
 // ── Similarity ────────────────────────────────────────────────────────────────
 
 /**
@@ -321,6 +380,8 @@ module.exports = {
   inferEdges,
   saveCache,
   loadCache,
+  bm25Score,
+  buildBM25Index,
   SIMILARITY_THRESHOLD,
   SHADOW_THRESHOLD,
 };

package/bin/memory/knowledge-graph.js

@@ -109,6 +109,7 @@ function addEdge(edge) {
   record.checksum = crypto.createHash('sha256').update(payload).digest('hex');
 
   fs.appendFileSync(paths.EDGES_PATH, JSON.stringify(record) + '\n');
+  invalidateAdjacencyCache();
   return id;
 }
 
@@ -155,6 +156,7 @@ function deprecateEdge(edgeId, reason) {
   };
 
   fs.appendFileSync(paths.EDGES_PATH, JSON.stringify(deprecated) + '\n');
+  invalidateAdjacencyCache();
 }
 
 /**
@@ -181,18 +183,68 @@ function reinforceEdge(edgeId) {
   fs.appendFileSync(paths.EDGES_PATH, JSON.stringify(reinforced) + '\n');
 }
 
-// ── Adjacency Index ───────────────────────────────────────────────────────────
+// ── Adjacency Index (with persistent cache) ─────────────────────────────────
+
+function getAdjacencyCachePath() {
+  const paths = getPaths();
+  return path.join(paths.MEMORY_DIR, '.adjacency-cache.json');
+}
+
+function invalidateAdjacencyCache() {
+  const cachePath = getAdjacencyCachePath();
+  if (fs.existsSync(cachePath)) {
+    fs.unlinkSync(cachePath);
+  }
+}
+
+/**
+ * Load adjacency index from cache if edges file hasn't changed,
+ * otherwise rebuild and persist.
+ * @param {object[]} edges - All active edges (used for rebuild)
+ * @returns {Map<string, object[]>} nodeId → [{ edge, neighborId, direction }]
+ */
+function loadOrBuildAdjacencyIndex(edges) {
+  const paths = getPaths();
+  const cachePath = getAdjacencyCachePath();
+  const edgesStat = fs.statSync(paths.EDGES_PATH, { throwIfNoEntry: false });
+
+  if (edgesStat && fs.existsSync(cachePath)) {
+    try {
+      const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      if (cache.mtime === edgesStat.mtimeMs) {
+        const index = new Map();
+        for (const [nodeId, neighbors] of Object.entries(cache.adjacency)) {
+          index.set(nodeId, neighbors);
+        }
+        return index;
+      }
+    } catch (e) { /* cache corrupt, rebuild */ }
+  }
+
+  const index = buildAdjacencyIndex(edges);
+
+  if (edgesStat) {
+    const serialized = {};
+    for (const [nodeId, neighbors] of index) {
+      serialized[nodeId] = neighbors;
+    }
+    const cacheData = { mtime: edgesStat.mtimeMs, adjacency: serialized };
+    ensureDir(paths.MEMORY_DIR);
+    fs.writeFileSync(cachePath, JSON.stringify(cacheData));
+  }
+
+  return index;
+}
 
 /**
  * Build an in-memory adjacency index for O(1) neighbor lookups.
  * @param {object[]} edges - All active edges
- * @returns {Map<string, object[]>} nodeId → [{ edge, neighborId }]
+ * @returns {Map<string, object[]>} nodeId → [{ edge, neighborId, direction }]
  */
 function buildAdjacencyIndex(edges) {
   const index = new Map();
 
   for (const edge of edges) {
-    // Forward direction
     if (!index.has(edge.sourceId)) index.set(edge.sourceId, []);
     index.get(edge.sourceId).push({
       edge,
@@ -200,7 +252,6 @@ function buildAdjacencyIndex(edges) {
       direction: 'outgoing',
     });
 
-    // Reverse direction (for bidirectional traversal)
     if (!index.has(edge.targetId)) index.set(edge.targetId, []);
     index.get(edge.targetId).push({
       edge,
@@ -262,7 +313,7 @@ function addFederatedEdge(edge) {
 function traverse(startId, maxDepth = 2, opts = {}) {
   const { edgeTypes, minWeight = 0 } = opts;
   const edges = readAllEdges();
-  const adjacency = buildAdjacencyIndex(edges);
+  const adjacency = loadOrBuildAdjacencyIndex(edges);
 
   const visited = new Set();
   const results = [];
@@ -598,6 +649,8 @@ module.exports = {
   deprecateEdge,
   reinforceEdge,
   buildAdjacencyIndex,
+  loadOrBuildAdjacencyIndex,
+  invalidateAdjacencyCache,
   traverse,
   findRelated,
   getNodeEdges,

package/bin/memory/knowledge-indexer.js

@@ -9,7 +9,10 @@
  */
 'use strict';
 
+const fs    = require('fs');
+const path  = require('path');
 const Store = require('./knowledge-store');
+const { buildBM25Index, bm25Score } = require('./embedding-engine');
 
 // ── Stopwords (excluded from TF-IDF scoring) ──────────────────────────────────
 const STOPWORDS = new Set([
@@ -79,6 +82,48 @@ function tfidfScore(queryTokens, entryId, index, docTokenCounts, N) {
   return score;
 }
 
+// ── Persistent BM25 Index Cache ──────────────────────────────────────────────
+
+function getKbPath() {
+  const memoryDir = path.join(process.cwd(), '.mindforge', 'memory');
+  return path.join(memoryDir, 'knowledge.jsonl');
+}
+
+function getCachePath() {
+  const memoryDir = path.join(process.cwd(), '.mindforge', 'memory');
+  return path.join(memoryDir, '.index-cache.json');
+}
+
+/**
+ * Load BM25 index from cache if source file hasn't changed,
+ * otherwise rebuild and persist.
+ */
+function loadOrBuildIndex(entries) {
+  const kbPath = getKbPath();
+  const cachePath = getCachePath();
+  const stat = fs.statSync(kbPath, { throwIfNoEntry: false });
+
+  if (stat && fs.existsSync(cachePath)) {
+    try {
+      const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      if (cache.mtime === stat.mtimeMs && cache.entryCount === entries.length) {
+        return cache.index;
+      }
+    } catch (e) { /* cache corrupt, rebuild */ }
+  }
+
+  const index = buildBM25Index(entries);
+
+  if (stat) {
+    const dir = path.dirname(cachePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const cacheData = { mtime: stat.mtimeMs, entryCount: entries.length, index };
+    fs.writeFileSync(cachePath, JSON.stringify(cacheData));
+  }
+
+  return index;
+}
+
 // ── Main search function ──────────────────────────────────────────────────────
 /**
  * Search knowledge base with TF-IDF scoring.
@@ -106,18 +151,20 @@ function search(queryText, filters = {}, limit = 10) {
 
   const queryTokens = tokenize(queryText);
   if (queryTokens.length === 0) {
-    // No meaningful query tokens — return by confidence
     return candidates
       .sort((a, b) => b.confidence - a.confidence)
       .slice(0, limit);
   }
 
-  const { index, docTokenCounts, N } = buildIndex(candidates);
+  // Use cached BM25 index for scoring
+  const bm25Index = loadOrBuildIndex(candidates);
+  const { docFrequency, avgDocLength, tokenizedDocs } = bm25Index;
+  const totalDocs = tokenizedDocs.length;
+  const docMap = new Map(tokenizedDocs.map(d => [d.id, d.tokens]));
 
-  // Score each candidate
   const scored = candidates.map(entry => {
-    const textScore = tfidfScore(queryTokens, entry.id, index, docTokenCounts, N);
-    // Combine TF-IDF score with confidence, but only if there's a text match
+    const docTokens = docMap.get(entry.id) || [];
+    const textScore = bm25Score(queryTokens, docTokens, docFrequency, totalDocs, avgDocLength);
     const finalScore = textScore > 0
       ? textScore * 0.7 + entry.confidence * 0.3
       : 0;
@@ -169,4 +216,4 @@ function loadSessionContext(context = {}) {
   return { preferences, decisions, bugPatterns, codePatterns, domain };
 }
 
-module.exports = { search, loadSessionContext, buildIndex, tfidfScore, tokenize };
+module.exports = { search, loadSessionContext, buildIndex, tfidfScore, tokenize, loadOrBuildIndex };

package/bin/memory/knowledge-store.js

@@ -126,6 +126,22 @@ function getFilePath(type) {
   }
 }
 
+// ── File Integrity ────────────────────────────────────────────────────────────
+
+/**
+ * Ensures a JSONL file doesn't end with a partial/truncated line.
+ * Appends a trailing newline if missing — prevents corruption from propagating.
+ */
+function verifyFileIntegrity(filePath) {
+  if (!fs.existsSync(filePath)) return true;
+  const content = fs.readFileSync(filePath, 'utf8');
+  if (content.length === 0) return true;
+  if (!content.endsWith('\n')) {
+    fs.appendFileSync(filePath, '\n');
+  }
+  return true;
+}
+
 // ── Write operations ──────────────────────────────────────────────────────────
 
 /**
@@ -184,10 +200,12 @@ function add(entry) {
   };
 
   const filePath = getFilePath(entry.type);
+  verifyFileIntegrity(filePath);
   fs.appendFileSync(filePath, JSON.stringify(full) + '\n');
 
   // Also append to unified knowledge-base.jsonl for cross-type queries
   if (filePath !== paths.KB_PATH) {
+    verifyFileIntegrity(paths.KB_PATH);
     fs.appendFileSync(paths.KB_PATH, JSON.stringify(full) + '\n');
   }
 
@@ -217,8 +235,10 @@ function deprecate(id, reason, supersededBy = null) {
     deprecated_at:     new Date().toISOString(),
   };
 
+  verifyFileIntegrity(filePath);
   fs.appendFileSync(filePath, JSON.stringify(deprecated) + '\n');
   if (filePath !== paths.KB_PATH) {
+    verifyFileIntegrity(paths.KB_PATH);
     fs.appendFileSync(paths.KB_PATH, JSON.stringify(deprecated) + '\n');
   }
 
@@ -246,8 +266,10 @@ function reinforce(id) {
   };
 
   const filePath = getFilePath(entry.type);
+  verifyFileIntegrity(filePath);
   fs.appendFileSync(filePath, JSON.stringify(reinforced) + '\n');
   if (filePath !== paths.KB_PATH) {
+    verifyFileIntegrity(paths.KB_PATH);
     fs.appendFileSync(paths.KB_PATH, JSON.stringify(reinforced) + '\n');
   }
 

package/bin/migrations/10.7.0-to-11.0.0.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MIGRATION_ID = '10.7.0-to-11.0.0';
+const TARGET_VERSION = '11.0.0';
+
+async function migrate(projectRoot) {
+  const results = { steps: [], success: true };
+
+  // Step 1: Backup config.json
+  const configPath = path.join(projectRoot, '.mindforge', 'config.json');
+  if (fs.existsSync(configPath)) {
+    const backupPath = configPath + '.v10-backup';
+    fs.copyFileSync(configPath, backupPath);
+    results.steps.push({ step: 'backup_config', status: 'done', path: backupPath });
+
+    // Step 2: Add new config sections
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+      if (!config.temporal) {
+        config.temporal = { max_snapshots: 50, max_age_days: 7 };
+      }
+      if (!config.rate_limiting) {
+        config.rate_limiting = { dashboard_rpm: 100, model_rpm: {} };
+      }
+      if (!config.session) {
+        config.session = { token_expiry_hours: 24 };
+      }
+      if (!config.wave_execution) {
+        config.wave_execution = { max_concurrency: 3 };
+      }
+
+      config.version = TARGET_VERSION;
+
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+      results.steps.push({ step: 'update_config', status: 'done' });
+    } catch (e) {
+      results.steps.push({ step: 'update_config', status: 'warning', error: e.message });
+    }
+  }
+
+  // Step 3: Archive old AUDIT lines if > 5000
+  const auditPath = path.join(projectRoot, '.planning', 'AUDIT.jsonl');
+  if (fs.existsSync(auditPath)) {
+    try {
+      const content = fs.readFileSync(auditPath, 'utf8');
+      const lines = content.split('\n').filter(l => l.trim());
+      if (lines.length > 5000) {
+        const archiveDir = path.join(projectRoot, '.planning', 'audit-archive');
+        if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+
+        const zlib = require('zlib');
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const archivePath = path.join(archiveDir, `AUDIT-pre-v11-${timestamp}.jsonl.gz`);
+        const toArchive = lines.slice(0, -500).join('\n') + '\n';
+        fs.writeFileSync(archivePath, zlib.gzipSync(toArchive));
+
+        const remaining = lines.slice(-500).join('\n') + '\n';
+        fs.writeFileSync(auditPath, remaining);
+        results.steps.push({ step: 'archive_audit', status: 'done', archived: lines.length - 500 });
+      } else {
+        results.steps.push({ step: 'archive_audit', status: 'skipped', reason: 'under_threshold' });
+      }
+    } catch (e) {
+      results.steps.push({ step: 'archive_audit', status: 'warning', error: e.message });
+    }
+  }
+
+  // Step 4: GC old snapshots
+  try {
+    const TemporalHub = require('../engine/temporal-hub');
+    const gcResult = await TemporalHub.gc({ maxSnapshots: 50, maxAgeDays: 30 });
+    results.steps.push({ step: 'snapshot_gc', status: 'done', deleted: gcResult.deleted });
+  } catch (e) {
+    results.steps.push({ step: 'snapshot_gc', status: 'warning', error: e.message });
+  }
+
+  // Step 5: Bump schema_version in HANDOFF.json
+  const handoffPath = path.join(projectRoot, '.planning', 'HANDOFF.json');
+  if (fs.existsSync(handoffPath)) {
+    try {
+      const handoff = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+      handoff.schema_version = TARGET_VERSION;
+      fs.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + '\n');
+      results.steps.push({ step: 'bump_handoff_version', status: 'done' });
+    } catch (e) {
+      results.steps.push({ step: 'bump_handoff_version', status: 'warning', error: e.message });
+    }
+  }
+
+  // Step 6: Update MINDFORGE.md VERSION
+  const mindforgeFile = path.join(projectRoot, 'MINDFORGE.md');
+  if (fs.existsSync(mindforgeFile)) {
+    try {
+      let content = fs.readFileSync(mindforgeFile, 'utf8');
+      content = content.replace(/VERSION\s*=\s*[\d.]+/, `VERSION = ${TARGET_VERSION}`);
+      fs.writeFileSync(mindforgeFile, content);
+      results.steps.push({ step: 'bump_mindforge_version', status: 'done' });
+    } catch (e) {
+      results.steps.push({ step: 'bump_mindforge_version', status: 'warning', error: e.message });
+    }
+  }
+
+  return results;
+}
+
+module.exports = { MIGRATION_ID, TARGET_VERSION, migrate };