mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/semantic-hub.js

@@ -0,0 +1,211 @@
+/**
+ * MindForge Semantic Hub
+ * v4.2.5 — Global Intelligence Mesh
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const vectorHub = require('./vector-hub'); // v8 Pillar XV
+
+class SemanticHub {
+  constructor() {
+    this.localPath = '.mindforge/memory';
+    this.globalPath = path.join(os.homedir(), '.mindforge/memory/global');
+    this.syncManifest = path.join(this.localPath, 'sync-manifest.json');
+    this.vhInitialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
+  }
+
+  /**
+   * Initializes the global memory store if it doesn't exist.
+   */
+  async ensureGlobalStore() {
+    try {
+      await fs.mkdir(this.globalPath, { recursive: true });
+      console.log(`[SEMANTIC-HUB] Global Store Initialized: ${this.globalPath}`);
+    } catch (err) {
+      console.error(`[SEMANTIC-HUB] Failed to initialize global store: ${err.message}`);
+    }
+  }
+
+  /**
+   * Syncs a local library with the global hub.
+   * @param {string} libraryName - e.g., 'pattern-library.jsonl'
+   */
+  async syncLibrary(libraryName) {
+    const localFile = path.join(this.localPath, libraryName);
+    const globalFile = path.join(this.globalPath, libraryName);
+
+    try {
+      // 1. Read local entries
+      const localData = await fs.readFile(localFile, 'utf8');
+      const localEntries = localData.split('\n').filter(Boolean).map(JSON.parse);
+
+      // 2. Read global entries (if exist)
+      let globalEntries = [];
+      try {
+        const globalData = await fs.readFile(globalFile, 'utf8');
+        globalEntries = globalData.split('\n').filter(Boolean).map(JSON.parse);
+      } catch (e) {
+        // Global doesn't exist yet, that's fine.
+      }
+
+      // 3. Simple ID-based deduplication Logic
+      const globalIds = new Set(globalEntries.map(e => e.id));
+      const newEntries = localEntries.filter(e => !globalIds.has(e.id));
+
+      if (newEntries.length > 0) {
+        // Append new entries to global store
+        const appendData = newEntries.map(e => JSON.stringify(e)).join('\n') + '\n';
+        await fs.appendFile(globalFile, appendData);
+        console.log(`[SEMANTIC-HUB] Synced ${newEntries.length} new entries to global ${libraryName}`);
+      }
+
+      // 4. Update sync manifest
+      await this.updateManifest(libraryName, localEntries.length);
+      
+      return true;
+    } catch (err) {
+      console.error(`[SEMANTIC-HUB] Sync failed for ${libraryName}: ${err.message}`);
+      return false;
+    }
+  }
+
+  async updateManifest(libraryName, count) {
+    let manifest = {};
+    try {
+      const data = await fs.readFile(this.syncManifest, 'utf8');
+      manifest = JSON.parse(data);
+    } catch (e) {}
+
+    manifest[libraryName] = {
+      lastSync: new Date().toISOString(),
+      localCount: count
+    };
+
+    await fs.writeFile(this.syncManifest, JSON.stringify(manifest, null, 2));
+  }
+
+  /**
+   * Retrieves all 'golden_trace' types from the global hub and local SQLite.
+   */
+  async getGoldenTraces(skillFilter = null) {
+    await this.ensureInit();
+    
+    // v8: Prioritize SQLite search for high-speed retrieval
+    let sqliteTraces = [];
+    try {
+      if (skillFilter) {
+        sqliteTraces = await vectorHub.searchTraces(skillFilter);
+      } else {
+        sqliteTraces = await vectorHub.db.selectFrom('traces')
+          .selectAll()
+          .where('event', '=', 'reasoning_trace')
+          .limit(20)
+          .execute();
+      }
+    } catch (err) {
+      console.warn(`[SEMANTIC-HUB] SQLite trace lookup failed: ${err.message}`);
+    }
+
+    // Legacy file-based fallback/global sync
+    const patternFile = path.join(this.globalPath, 'pattern-library.jsonl');
+    let fileTraces = [];
+    try {
+      const data = await fs.readFile(patternFile, 'utf8');
+      fileTraces = data.split('\n')
+        .filter(Boolean)
+        .map(JSON.parse)
+        .filter(p => p.type === 'golden-trace' || p.tags?.includes('success'));
+      
+      if (skillFilter) {
+        fileTraces = fileTraces.filter(t => t.skill === skillFilter || t.tags?.includes(skillFilter));
+      }
+    } catch (e) {
+      // Fallback is silent
+    }
+
+    // Merge and deduplicate
+    const allTraces = [...sqliteTraces, ...fileTraces];
+    const uniqueTraces = Array.from(new Map(allTraces.map(t => [t.id || t.trace_id, t])).values());
+    
+    return uniqueTraces;
+  }
+
+  /**
+   * Retrieves all 'ghost_pattern' types for proactive risk detection.
+   */
+  async getGhostPatterns() {
+    await this.ensureInit();
+
+    // 1. Fetch from legacy file-based global hub
+    const patternFile = path.join(this.globalPath, 'pattern-library.jsonl');
+    let ghostPatterns = [];
+    try {
+      const data = await fs.readFile(patternFile, 'utf8');
+      ghostPatterns = data.split('\n')
+        .filter(Boolean)
+        .map(JSON.parse)
+        .filter(p => p.type === 'ghost-pattern' || p.tags?.includes('failure'));
+    } catch (e) {
+      // Missing library is handled gracefully
+    }
+
+    // 2. Fetch from SQLite high-drift traces (v8 specific ghosting)
+    try {
+      const v8Ghosts = await vectorHub.db.selectFrom('traces')
+        .selectAll()
+        .where('drift_score', '>', 0.5)
+        .limit(20)
+        .execute();
+      
+      const v8Mapped = v8Ghosts.map(g => ({
+        id: g.id,
+        tags: ['v8-drift-risk', 'failure'],
+        failureContext: g.content,
+        mitigationStrategy: 'Review logic drift in v8 trace logs.'
+      }));
+
+      ghostPatterns = [...ghostPatterns, ...v8Mapped];
+    } catch (err) {
+      console.warn(`[SEMANTIC-HUB] SQLite ghost lookup failed: ${err.message}`);
+    }
+
+    return ghostPatterns;
+  }
+
+  /**
+   * Saves a discovered skill to SQLite.
+   */
+  async saveSkill(skill) {
+    await this.ensureInit();
+    await vectorHub.db.insertInto('skills')
+      .values({
+        skill_id: skill.id || `sk_${Math.random().toString(36).substr(2, 6)}`,
+        name: skill.name,
+        description: skill.description || '',
+        path: skill.path || '',
+        success_rate: skill.success_rate || 0.0,
+        last_verified: new Date().toISOString()
+      })
+      .onConflict(oc => oc.column('skill_id').doUpdateSet({
+        success_rate: skill.success_rate,
+        last_verified: new Date().toISOString()
+      }))
+      .execute();
+    
+    // v8 Pillar XVII: Metadata provenance for evolved skills
+    if (skill.is_autonomous) {
+      console.log(`[SEMANTIC-HUB] Persistence acknowledged for ASE evolved skill: ${skill.name}`);
+    }
+  }
+}
+
+module.exports = new SemanticHub();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/session-memory-loader.js

@@ -0,0 +1,137 @@
+/**
+ * MindForge v2 — Session Memory Loader
+ * Loads relevant knowledge at session start and formats it for CLAUDE.md injection.
+ *
+ * Called at session boot to populate the agent with accumulated knowledge
+ * before any task begins.
+ */
+'use strict';
+
+const fs      = require('fs');
+const path    = require('path');
+const Indexer = require('./knowledge-indexer');
+const Store   = require('./knowledge-store');
+
+/**
+ * Load relevant session context from the knowledge graph.
+ * Returns a formatted string for injection into agent context at session start.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.techStack  - Tech stack from PROJECT.md (for relevance filtering)
+ * @param {string}   opts.phase      - Current phase description
+ * @param {string}   opts.topic      - Current task/topic focus
+ * @param {number}   opts.maxEntries - Maximum entries to load (default: 20)
+ */
+function loadForSession(opts = {}) {
+  const { techStack = [], phase = '', topic = '', maxEntries = 20 } = opts;
+
+  const context = Indexer.loadSessionContext({ techStack, phase, topic });
+  const allLoaded = [
+    ...context.preferences,
+    ...context.decisions,
+    ...context.bugPatterns,
+    ...context.codePatterns,
+    ...context.domain,
+  ];
+
+  if (allLoaded.length === 0) {
+    return { formatted: '', entries: [], count: 0 };
+  }
+
+  // Reinforce all loaded entries (they are being actively used)
+  for (const entry of allLoaded) {
+    try { Store.reinforce(entry.id); } catch (e) { /* ignore cleanup errors */ }
+  }
+
+  const formatted = formatForContext(context);
+
+  return {
+    formatted,
+    entries:     allLoaded,
+    count:       allLoaded.length,
+    preferences: context.preferences.length,
+    decisions:   context.decisions.length,
+    bugPatterns: context.bugPatterns.length,
+    codePatterns: context.codePatterns.length,
+    domain:      context.domain.length,
+  };
+}
+
+/**
+ * Format loaded knowledge entries for agent context injection.
+ */
+function formatForContext(context) {
+  const sections = [];
+
+  if (context.preferences.length > 0) {
+    sections.push('### Team Preferences');
+    context.preferences.forEach(e => {
+      sections.push(`- [${(e.confidence * 100).toFixed(0)}% confidence] ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.decisions.length > 0) {
+    sections.push('\n### Architectural Decisions (from this project)');
+    context.decisions.forEach(e => {
+      const adr = e.adr_reference ? ` (${e.adr_reference})` : '';
+      sections.push(`- ${e.topic}${adr}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.bugPatterns.length > 0) {
+    sections.push('\n### Bug Patterns to Avoid');
+    context.bugPatterns.forEach(e => {
+      sections.push(`- ⚠️  ${e.topic}: ${e.root_cause?.slice(0, 150) || e.content.slice(0, 150)}`);
+      if (e.fix) sections.push(`  Fix: ${e.fix.slice(0, 100)}`);
+    });
+  }
+
+  if (context.domain.length > 0) {
+    sections.push('\n### Domain Knowledge');
+    context.domain.forEach(e => {
+      sections.push(`- ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Read tech stack from PROJECT.md for relevance filtering.
+ */
+function readTechStack() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return [];
+  const content = fs.readFileSync(projectMd, 'utf8');
+  // Extract tech stack section
+  const techSection = content.match(/## Tech stack\n+([\s\S]*?)(?=\n##|$)/i)?.[1] || '';
+  return techSection
+    .split('\n')
+    .map(l => l.replace(/^[-*•]\s*/, '').split(/[\s,/]/).filter(w => w.length > 2))
+    .flat()
+    .filter(Boolean)
+    .slice(0, 20);
+}
+
+/**
+ * Generate the memory header displayed at session start.
+ */
+function generateSessionHeader(loadResult) {
+  if (loadResult.count === 0) {
+    return '🧠 Knowledge Base — no relevant memories for this session\n';
+  }
+
+  const lines = [
+    `🧠 Knowledge Base — ${loadResult.count} relevant memories loaded:`,
+  ];
+
+  if (loadResult.preferences > 0)  lines.push(`  Preferences  : ${loadResult.preferences}`);
+  if (loadResult.decisions > 0)    lines.push(`  Decisions    : ${loadResult.decisions}`);
+  if (loadResult.bugPatterns > 0)  lines.push(`  Bug patterns : ${loadResult.bugPatterns}`);
+  if (loadResult.codePatterns > 0) lines.push(`  Code patterns: ${loadResult.codePatterns}`);
+  if (loadResult.domain > 0)       lines.push(`  Domain       : ${loadResult.domain}`);
+
+  return lines.join('\n');
+}
+
+module.exports = { loadForSession, readTechStack, generateSessionHeader, formatForContext };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/vector-hub.js

@@ -0,0 +1,170 @@
+const Database = require('better-sqlite3');
+const { Kysely, SqliteDialect, sql } = require('kysely');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * MindForge v8 VectorHub
+ * Unified Persistence Layer for Trace, Remediation, and Skill data.
+ */
+class VectorHub {
+  constructor(dbPath = null) {
+    this.dbPath = dbPath || path.join(process.cwd(), '.mindforge', 'celestial.db');
+    this._ensureDir();
+    
+    const nativeDb = new Database(this.dbPath);
+    this.db = new Kysely({
+      dialect: new SqliteDialect({
+        database: nativeDb,
+      }),
+    });
+    
+    this.initialized = false;
+  }
+
+  _ensureDir() {
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Initialize tables and FTS5 search.
+   */
+  async init() {
+    if (this.initialized) return;
+
+    // Traces Table
+    await this.db.schema
+      .createTable('traces')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('trace_id', 'text', (col) => col.notNull())
+      .addColumn('span_id', 'text')
+      .addColumn('event', 'text', (col) => col.notNull())
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .addColumn('agent', 'text')
+      .addColumn('content', 'text')
+      .addColumn('metadata', 'text') // JSON blob
+      .addColumn('drift_score', 'real')
+      .addColumn('mesh_node_id', 'text') // v8 Pillar XVI
+      .execute();
+
+    // v8 Migration: ensure mesh_node_id exists on existing table
+    try {
+      await sql`ALTER TABLE traces ADD COLUMN mesh_node_id TEXT`.execute(this.db);
+    } catch (e) {
+      // Column might already exist, ignore error.
+    }
+
+    // Remediations Table
+    await this.db.schema
+      .createTable('remediations')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('trace_id', 'text', (col) => col.notNull())
+      .addColumn('strategy', 'text', (col) => col.notNull())
+      .addColumn('status', 'text', (col) => col.notNull())
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .addColumn('outcome', 'text')
+      .execute();
+
+    // Skills Table
+    await this.db.schema
+      .createTable('skills')
+      .ifNotExists()
+      .addColumn('skill_id', 'text', (col) => col.primaryKey())
+      .addColumn('name', 'text', (col) => col.notNull())
+      .addColumn('description', 'text')
+      .addColumn('path', 'text')
+      .addColumn('success_rate', 'real', (col) => col.defaultTo(0.0))
+      .addColumn('last_verified', 'text')
+      .execute();
+
+    // Attestations Table (v8 Pillar XVIII)
+    await this.db.schema
+      .createTable('attestations')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('request_id', 'text', (col) => col.notNull())
+      .addColumn('status', 'text', (col) => col.notNull()) // APPROVED / REJECTED
+      .addColumn('attestation_payload', 'text') // Signed blob from hardware enclave
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .execute();
+
+    // Config Table
+    await this.db.schema
+      .createTable('mesh_config')
+      .ifNotExists()
+      .addColumn('key', 'text', (col) => col.primaryKey())
+      .addColumn('value', 'text')
+      .execute();
+
+    // Enable Full-Text Search for traces (FTS5)
+    await sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search 
+      USING fts5(trace_id, content, agent, tokenize='porter');
+    `.execute(this.db);
+
+    this.initialized = true;
+    console.log(`[VectorHub] Initialized SQLite persistence at ${this.dbPath}`);
+  }
+
+  async close() {
+    await this.db.destroy();
+  }
+
+  /**
+   * Record a trace event.
+   */
+  async recordTrace(data) {
+    const entry = {
+      id: data.id || Math.random().toString(36).substr(2, 9),
+      trace_id: data.trace_id,
+      span_id: data.span_id || null,
+      event: data.event,
+      timestamp: data.timestamp || new Date().toISOString(),
+      agent: data.agent || null,
+      content: data.content || null,
+      metadata: data.metadata ? JSON.stringify(data.metadata) : null,
+      drift_score: data.drift_score || 0,
+      mesh_node_id: data.mesh_node_id || null
+    };
+
+    await this.db.insertInto('traces')
+      .values(entry)
+      .onConflict(oc => oc.column('id').doUpdateSet({
+        metadata: entry.metadata,
+        mesh_node_id: entry.mesh_node_id,
+        drift_score: entry.drift_score
+      }))
+      .execute();
+    
+    // Update FTS5 index if content exists
+    if (entry.content) {
+      await sql`INSERT INTO traces_search (trace_id, content, agent) VALUES (${entry.trace_id}, ${entry.content}, ${entry.agent})`
+        .execute(this.db);
+    }
+    
+    return entry.id;
+  }
+
+  /**
+   * Semantic search for previous traces.
+   */
+  async searchTraces(query) {
+    const results = await sql`
+        SELECT t.*, ts.rank 
+        FROM traces t
+        JOIN traces_search ts ON t.trace_id = ts.trace_id
+        WHERE traces_search MATCH ${query}
+        ORDER BY ts.rank
+        LIMIT 10
+      `.execute(this.db);
+    return results.rows;
+  }
+}
+
+module.exports = new VectorHub();
+module.exports.VectorHub = VectorHub;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/0.1.0-to-0.5.0.js

@@ -0,0 +1,36 @@
+// bin/migrations/0.1.0-to-0.5.0.js
+'use strict';
+const fs = require('fs');
+module.exports = {
+  fromVersion: '0.1.0',
+  toVersion:   '0.5.0',
+  description: 'Add decisions_made, discoveries, implicit_knowledge to HANDOFF.json',
+  async run(paths) {
+    if (!fs.existsSync(paths.handoff)) return;
+    const handoff = JSON.parse(fs.readFileSync(paths.handoff, 'utf8'));
+    if (!handoff.decisions_made)     handoff.decisions_made     = [];
+    if (!handoff.discoveries)        handoff.discoveries        = [];
+    if (!handoff.implicit_knowledge) handoff.implicit_knowledge = [];
+    if (!handoff.quality_signals)    handoff.quality_signals    = [];
+    fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
+    console.log('    • HANDOFF.json: added intelligence layer fields');
+  },
+};
+
+// bin/migrations/0.5.0-to-0.6.0.js
+'use strict';
+module.exports = {
+  fromVersion: '0.5.0',
+  toVersion:   '0.6.0',
+  description: 'Add developer_id, session_id, recent_commits, recent_files to HANDOFF.json',
+  async run(paths) {
+    if (!fs.existsSync(paths.handoff)) return;
+    const handoff = JSON.parse(fs.readFileSync(paths.handoff, 'utf8'));
+    if (!handoff.developer_id)   handoff.developer_id   = null;
+    if (!handoff.session_id)     handoff.session_id     = null;
+    if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
+    if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
+    fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
+    console.log('    • HANDOFF.json: added distribution platform fields');
+  },
+};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/0.5.0-to-0.6.0.js

@@ -0,0 +1,17 @@
+'use strict';
+const fs = require('fs');
+module.exports = {
+  fromVersion: '0.5.0',
+  toVersion:   '0.6.0',
+  description: 'Add developer_id, session_id, recent_commits, recent_files to HANDOFF.json',
+  async run(paths) {
+    if (!fs.existsSync(paths.handoff)) return;
+    const handoff = JSON.parse(fs.readFileSync(paths.handoff, 'utf8'));
+    if (!handoff.developer_id)   handoff.developer_id   = null;
+    if (!handoff.session_id)     handoff.session_id     = null;
+    if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
+    if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
+    fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
+    console.log('    • HANDOFF.json: added distribution platform fields');
+  },
+};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/migrations/0.6.0-to-1.0.0.js

@@ -0,0 +1,100 @@
+/**
+ * MindForge Migration: v0.6.0 → v1.0.0
+ *
+ * Changes:
+ * 1. HANDOFF.json: add `plugin_api_version` field
+ * 2. AUDIT.jsonl: backfill `session_id` for entries missing it
+ * 3. MINDFORGE.md: convert VERIFY_PASS_RATE_WARNING_THRESHOLD if in old 0-100 format
+ * 4. STATE.md: add v1.0.0 compatibility note if it doesn't already have one
+ */
+'use strict';
+
+const fs = require('fs');
+
+module.exports = {
+  fromVersion: '0.6.0',
+  toVersion:   '1.0.0',
+  description: 'Add plugin_api_version; backfill session_id; normalise MINDFORGE.md thresholds',
+
+  async run(paths) {
+    // ── 1. HANDOFF.json ───────────────────────────────────────────────────────
+    if (fs.existsSync(paths.handoff)) {
+      const handoff = JSON.parse(fs.readFileSync(paths.handoff, 'utf8'));
+
+      if (!handoff.plugin_api_version) {
+        handoff.plugin_api_version = '1.0.0';
+      }
+      // Ensure fields added in 0.6.0 are present (for projects that skipped intermediate updates)
+      if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
+      if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
+      if (!handoff.session_id) {
+        handoff.session_id = `migrated-${Date.now()}`;
+      }
+
+      fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
+      console.log('    • HANDOFF.json: added plugin_api_version, normalised arrays');
+    }
+
+    // ── 2. AUDIT.jsonl ────────────────────────────────────────────────────────
+    if (fs.existsSync(paths.audit)) {
+      const raw   = fs.readFileSync(paths.audit, 'utf8');
+      const lines = raw.split('\n').filter(Boolean);
+      let modified = 0;
+
+      const updated = lines.map(line => {
+        try {
+          const entry = JSON.parse(line);
+          if (!entry.session_id) {
+            entry.session_id = 'migrated-from-pre-1.0';
+            modified++;
+            return JSON.stringify(entry);
+          }
+          return line;
+        } catch {
+          return line;  // Preserve unparseable lines exactly as-is (quarantine pattern)
+        }
+      });
+
+      if (modified > 0) {
+        fs.writeFileSync(paths.audit, updated.join('\n') + '\n');
+        console.log(`    • AUDIT.jsonl: backfilled session_id in ${modified} of ${lines.length} entries`);
+      } else {
+        console.log('    • AUDIT.jsonl: all entries already have session_id');
+      }
+    }
+
+    // ── 3. MINDFORGE.md ───────────────────────────────────────────────────────
+    if (fs.existsSync(paths.mindforgemd)) {
+      let content = fs.readFileSync(paths.mindforgemd, 'utf8');
+      let changed = false;
+
+      // Convert VERIFY_PASS_RATE_WARNING_THRESHOLD from percent (>1) to decimal
+      const pctPattern = /^(VERIFY_PASS_RATE_WARNING_THRESHOLD=)(\d+(?:\.\d+)?)(\s*)$/m;
+      const match = content.match(pctPattern);
+      if (match) {
+        const val = parseFloat(match[2]);
+        if (val > 1) {
+          // Old format: integer like 75 → new format: 0.75
+          const newVal = (val / 100).toFixed(2);
+          content = content.replace(pctPattern, `$1${newVal}$3`);
+          changed = true;
+          console.log(`    • MINDFORGE.md: converted VERIFY_PASS_RATE_WARNING_THRESHOLD ${val} → ${newVal}`);
+        }
+        // If val <= 1, it's already in the correct format — no change needed
+      }
+
+      if (changed) fs.writeFileSync(paths.mindforgemd, content);
+    }
+
+    // ── 4. STATE.md ───────────────────────────────────────────────────────────
+    if (fs.existsSync(paths.state)) {
+      const content = fs.readFileSync(paths.state, 'utf8');
+      if (!content.includes('v1.0.0') && !content.includes('MindForge v1')) {
+        fs.appendFileSync(paths.state,
+          `\n\n---\n*Migrated to MindForge v1.0.0 schema on ${new Date().toISOString().slice(0,10)}*\n`
+        );
+        console.log('    • STATE.md: added v1.0.0 migration note');
+      }
+    }
+  },
+};