mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/temporal-hub.js

@@ -0,0 +1,138 @@
+/**
+ * MindForge v3 — Temporal Hub (State Versioner)
+ * Managed high-fidelity snapshots of the .planning directory.
+ * 
+ * Design:
+ * - Each snapshot is identified by an audit_id.
+ * - Snapshots are stored in .planning/history/[audit_id]/
+ * - Atomic snapshots ensure time-travel debugging consistency.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const PLANNING_DIR = path.join(process.cwd(), '.planning');
+const HISTORY_DIR  = path.join(PLANNING_DIR, 'history');
+
+class TemporalHub {
+  /**
+   * Capture the current state of the .planning directory.
+   * @param {string} auditId - Unique identifier from AUDIT.jsonl
+   * @param {object} metadata - Optional context (task_name, session_id)
+   */
+  static captureState(auditId, metadata = {}) {
+    if (!fs.existsSync(PLANNING_DIR)) return null;
+    
+    const snapshotDir = path.join(HISTORY_DIR, auditId);
+    if (!fs.existsSync(snapshotDir)) {
+      fs.mkdirSync(snapshotDir, { recursive: true });
+    }
+
+    try {
+      // 1. Identify files to snapshot (exclude history itself and archive)
+      const files = fs.readdirSync(PLANNING_DIR).filter(f => {
+        const stats = fs.statSync(path.join(PLANNING_DIR, f));
+        if (stats.isDirectory()) return false;
+        
+        const ext = path.extname(f).toLowerCase();
+        return ['.md', '.json', '.yml', '.yaml', '.log'].includes(ext);
+      });
+
+      // 2. Snapshot files
+      for (const file of files) {
+        fs.copyFileSync(
+          path.join(PLANNING_DIR, file),
+          path.join(snapshotDir, file)
+        );
+      }
+
+      // 3. Save snapshot metadata
+      const meta = {
+        id: auditId,
+        timestamp: new Date().toISOString(),
+        ...metadata,
+        files: files
+      };
+      fs.writeFileSync(path.join(snapshotDir, 'SNAPSHOT-META.json'), JSON.stringify(meta, null, 2));
+
+      return snapshotDir;
+    } catch (err) {
+      console.error(`[temporal-hub] Failed to capture state for ${auditId}:`, err.message);
+      return null;
+    }
+  }
+
+  /**
+   * Restore the .planning directory to a specific snapshot.
+   * @param {string} auditId 
+   */
+  static rollbackTo(auditId) {
+    const snapshotDir = path.join(HISTORY_DIR, auditId);
+    if (!fs.existsSync(snapshotDir)) {
+      throw new Error(`Snapshot ${auditId} not found in history.`);
+    }
+
+    try {
+      const files = fs.readdirSync(snapshotDir).filter(f => f !== 'SNAPSHOT-META.json');
+      
+      for (const file of files) {
+        fs.copyFileSync(
+          path.join(snapshotDir, file),
+          path.join(PLANNING_DIR, file)
+        );
+      }
+      
+      return true;
+    } catch (err) {
+      console.error(`[temporal-hub] Rollback failed for ${auditId}:`, err.message);
+      throw err;
+    }
+  }
+
+  /**
+   * Get all available snapshots.
+   */
+  static getHistory() {
+    if (!fs.existsSync(HISTORY_DIR)) return [];
+    
+    try {
+      return fs.readdirSync(HISTORY_DIR)
+        .map(id => {
+          const metaPath = path.join(HISTORY_DIR, id, 'SNAPSHOT-META.json');
+          if (fs.existsSync(metaPath)) {
+            return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+          }
+          return { id, error: 'Missing metadata' };
+        })
+        .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    } catch (err) {
+      return [];
+    }
+  }
+
+  /**
+   * Read a file from a specific historical snapshot.
+   */
+  static getSnapshotFile(auditId, filePath) {
+    const snapPath = path.join(HISTORY_DIR, auditId, path.basename(filePath));
+    if (fs.existsSync(snapPath)) {
+      return fs.readFileSync(snapPath, 'utf8');
+    }
+    return null;
+  }
+
+  /**
+   * Capture terminal output for a command and associate with audit point.
+   */
+  static captureTerminal(auditId, stdout, stderr) {
+    const logDir = path.join(HISTORY_DIR, auditId, 'logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    
+    if (stdout) fs.writeFileSync(path.join(logDir, 'stdout.log'), stdout);
+    if (stderr) fs.writeFileSync(path.join(logDir, 'stderr.log'), stderr);
+  }
+}
+
+module.exports = TemporalHub;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-ceg.js

@@ -0,0 +1,59 @@
+/**
+ * MindForge v6.4.0 — CEG Verification Test
+ * 
+ * Simulates a "noisy" reasoning trace with repetitive thoughts 
+ * and verifies that the ContextEntropyGuard (CEG) correctly 
+ * suppresses noise and compresses the history.
+ */
+'use strict';
+
+const ceg = require('./context-entropy-guard');
+
+async function runTest() {
+  console.log('🧪 Starting CEG Verification Test...');
+
+  const trace = [
+    { event: 'reasoning_trace', thought: 'I should analyze the target directory structure.', is_stagnant: false },
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: false },
+    // Repetitive noise (to be suppressed)
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: true },
+    // New thought
+    { event: 'reasoning_trace', thought: 'Found a potential vulnerability in the config file.', is_stagnant: false },
+    // Loop (to be compressed)
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true }
+  ];
+
+  console.log(`\nInput Trace Length: ${trace.length}`);
+
+  const compressed = ceg.compress(trace);
+  console.log(`Compressed Trace Length: ${compressed.length}`);
+
+  console.log('\n--- Final Trace Preview ---');
+  compressed.forEach((e, idx) => {
+    if (e.event === 'reasoning_digest') {
+      console.log(`[${idx}] DIGEST: ${e.summary} | Last Conclusion: ${e.final_conclusion}`);
+    } else {
+      console.log(`[${idx}] THOUGHT: ${e.thought}`);
+    }
+  });
+
+  // Validations
+  const hasDigest = compressed.some(e => e.event === 'reasoning_digest');
+  const totalReduction = trace.length - compressed.length;
+
+  if (hasDigest && totalReduction >= 2) {
+    console.log('\n✅ SUCCESS: CEG successfully suppressed noise and compressed the reasoning loop.');
+  } else {
+    console.error('\n❌ FAILURE: CEG failed to compress the history significantly.');
+    process.exit(1);
+  }
+}
+
+runTest().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-interlock.js

@@ -0,0 +1,40 @@
+/**
+ * MindForge v6.3.0 — IDC Verification Test
+ * 
+ * Simulates a scenario where an agent starts "rambling" (low semantic density) 
+ * and repeats itself, triggering the Intelligence Interlock to upgrade the MIR.
+ */
+'use strict';
+
+const interlock = require('./intelligence-interlock');
+
+async function runTest() {
+  console.log('🧪 Starting IDC Verification Test...');
+
+  const spanId = 'test-span-drift-001';
+  
+  // 1. Stable thought
+  console.log('\n--- Step 1: Stable Thought ---');
+  const t1 = "I will implement the authentication controller by defining the login and signup routes first.";
+  const r1 = interlock.evaluate(spanId, t1);
+  console.log(`Result: ${r1.action}, Drift: ${r1.drift || 'N/A'}`);
+
+  // 2. Drifting thought (Rambling and Repetitive)
+  console.log('\n--- Step 2: Drifting Thought (Injection) ---');
+  const t2 = "I will implement the implement the implement the logic of the logic of the logic and then i will implement and then i will implement implement implement implement implement implement implement implement.";
+  const r2 = interlock.evaluate(spanId, t2);
+  console.log(`Result: ${r2.action}, Drift: ${r2.drift || 'N/A'}`);
+
+  if (r2.action === 'UPGRADE_MIR') {
+    console.log('✅ SUCCESS: IDC triggered an upgrade signal for critical drift.');
+    console.log(`Target MIR: ${r2.new_mir}`);
+  } else {
+    console.error('❌ FAILURE: IDC failed to trigger upgrade even with extreme repetition.');
+    process.exit(1);
+  }
+}
+
+runTest().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-remediation.js

@@ -0,0 +1,61 @@
+/**
+ * MindForge v7 — NDR Integration Test
+ * Verifies that logic drift triggers remediation and pulls from SemanticHub.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const driftDetector = require('./logic-drift-detector');
+const remediationEngine = require('./remediation-engine');
+const semanticHub = require('../memory/semantic-hub');
+
+async function testNDR() {
+  console.log('--- NDR Pillar Test ---');
+
+  // 1. Setup Mock Semantic Hub Data
+  const globalPath = path.join(os.homedir(), '.mindforge/memory/global');
+  const patternFile = path.join(globalPath, 'pattern-library.jsonl');
+  
+  if (!fs.existsSync(globalPath)) {
+    fs.mkdirSync(globalPath, { recursive: true });
+  }
+
+  const mockTrace = {
+    id: 'gt_test_001',
+    type: 'golden-trace',
+    skill: 'testing',
+    tags: ['success', 'logic-fix'],
+    content: 'Always verify before you trust.'
+  };
+
+  fs.appendFileSync(patternFile, JSON.stringify(mockTrace) + '\n');
+  console.log('[Test Setup] Injected mock golden trace into global hub.');
+
+  // 2. Simulate Drift
+  const spanId = 'sp_test_drift';
+  const ramblingThought = 'I am thinking about the thing and the thing is a thing and I keep repeating the thing because things are things.';
+  
+  const report = driftDetector.analyze(spanId, ramblingThought);
+  console.log(`[Drift Detector] Report Status: ${report.status} (Score: ${report.drift_score})`);
+
+  if (report.status !== 'DRIFT_DETECTED') {
+    throw new Error('Drift detector failed to recognize rambling pattern');
+  }
+
+  // 3. Trigger Remediation
+  const action = await remediationEngine.trigger(spanId, report);
+  console.log(`[Remediation Engine] Action: ${action.strategy} (ID: ${action.remediation_id})`);
+
+  if (action.strategy !== 'GOLDEN_TRACE_INJECTION') {
+    throw new Error(`Expected GOLDEN_TRACE_INJECTION but got ${action.strategy}`);
+  }
+
+  console.log('PASSED');
+}
+
+testNDR().catch(err => {
+  console.error(`FAILED: ${err.message}`);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-rsa.js

@@ -0,0 +1,64 @@
+/**
+ * MindForge v6.5.0 — RSA Verification Test
+ * 
+ * Simulates reasoning thoughts and verifies that the ReasonSourceAligner (RSA)
+ * correctly maps them to REQUIREMENT IDs or flags mission drift.
+ */
+'use strict';
+
+const rsa = require('./reason-source-aligner');
+
+async function runTest() {
+  console.log('🧪 Starting RSA Verification Test...');
+
+  await rsa.init();
+
+  const testCases = [
+    {
+      thought: 'I will create a new isolated component in bin/engine to handle policy checks.',
+      expectedId: 'REQ-001',
+      description: 'Clear alignment with REQ-001 (Component Isolation)'
+    },
+    {
+      thought: 'The current reasoning trace shows high repetition; I must compress this with a digest.',
+      expectedId: 'REQ-003',
+      description: 'Clear alignment with REQ-003 (Context Entropy Guard)'
+    },
+    {
+      thought: 'I should probably check the current weather in San Francisco before continuing.',
+      expectedId: null,
+      description: 'Unaligned "Mission Drift" thought'
+    }
+  ];
+
+  let successCount = 0;
+
+  for (const tc of testCases) {
+    const result = rsa.checkAlignment(tc.thought);
+    console.log(`\n--- Test Case: ${tc.description} ---`);
+    console.log(`Input Thought: "${tc.thought}"`);
+    console.log(`RSA Result: Aligned=${result.is_aligned}, Best Match=${result.best_match_id}, Confidence=${result.confidence}`);
+
+    if (result.best_match_id === tc.expectedId) {
+      console.log('✅ PASS');
+      successCount++;
+    } else if (tc.expectedId === null && !result.is_aligned) {
+      console.log('✅ PASS (Gracefully handled mission drift)');
+      successCount++;
+    } else {
+      console.error(`❌ FAIL: Expected ${tc.expectedId} but got ${result.best_match_id}`);
+    }
+  }
+
+  if (successCount === testCases.length) {
+    console.log('\n✅ RSA VERIFICATION COMPLETE: Mission fidelity mapping is operational.');
+  } else {
+    console.error(`\n❌ RSA VERIFICATION FAILED: Only ${successCount}/${testCases.length} tests passed.`);
+    process.exit(1);
+  }
+}
+
+runTest().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-scs.js

@@ -0,0 +1,57 @@
+/**
+ * MindForge v6.6.0 — SCS Verification Suite
+ * Tests the Self-Corrective Synthesis self-healing loop.
+ */
+'use strict';
+
+const rsa = require('./reason-source-aligner.js');
+const scs = require('./self-corrective-synthesizer.js');
+
+async function runTests() {
+  console.log('🧪 Starting MindForge v6.6.0 SCS Verification...');
+  await rsa.init();
+
+  // Test Case 1: Detect Drift and Refocus on REQ-004 (RSA)
+  console.log('\n--- Test Case 1: Targeted Refocus ---');
+  const driftingAudit = [
+    { type: 'mission_fidelity', alignment: { is_aligned: true, best_match_id: 'REQ-004', confidence: 0.85 } }, // Good
+    { type: 'mission_fidelity', alignment: { is_aligned: false, best_match_id: 'REQ-004', confidence: 0.35 } } // Drift detected
+  ];
+
+  const correction = await scs.synthesizeCorrection(driftingAudit, { phase: '6.6.0-test' });
+  
+  if (correction.type === 'scs_refocus' && correction.req_id === 'REQ-004') {
+    console.log('✅ SUCCESS: SCS correctly identified target requirement [REQ-004].');
+    console.log(`[SYNTHESIS] ${correction.instruction}`);
+  } else {
+    console.error('❌ FAIL: SCS failed to target REQ-004 correctly.', correction);
+  }
+
+  // Test Case 2: General Homing (No obvious requirements match in drift)
+  console.log('\n--- Test Case 2: General Homing ---');
+  const chaoticAudit = [
+    { type: 'mission_fidelity', alignment: { is_aligned: false, best_match_id: null, confidence: 0.1 } }
+  ];
+
+  const generalCorrection = await scs.synthesizeCorrection(chaoticAudit, { phase: '6.6.0-test' });
+
+  if (generalCorrection.instruction.includes('[SCS-GENERAL-HOMING]')) {
+    console.log('✅ SUCCESS: SCS triggered general homing for chaotic audit state.');
+    console.log(`[SYNTHESIS] ${generalCorrection.instruction}`);
+  } else {
+    console.error('❌ FAIL: SCS failed to trigger general homing.', generalCorrection);
+  }
+
+  // Test Case 3: Validating the Synthesized instruction with RSA
+  console.log('\n--- Test Case 3: RSA Validation of SCS Instruction ---');
+  const alignment = rsa.checkAlignment(correction.instruction);
+  if (alignment.best_match_id === 'REQ-004' && alignment.confidence > 0.60) {
+    console.log(`✅ SUCCESS: RSA confirms synthesized instruction aligns with [REQ-004] (Confidence: ${alignment.confidence})`);
+  } else {
+    console.error(`❌ FAIL: Synthesized instruction failed RSA validation. Match: ${alignment.best_match_id}, Conf: ${alignment.confidence}`);
+  }
+
+  console.log('\n✨ v6.6.0 SCS Verification Suite Complete.');
+}
+
+runTests().catch(console.error);

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/test-v7-blueprint.js

@@ -0,0 +1,44 @@
+/**
+ * MindForge v7 — Test Suite
+ * Blueprint Verification: NDR Pillar X
+ */
+'use strict';
+
+const tracer = require('./nexus-tracer');
+const remediationQueue = require('../revops/remediation-queue');
+const fs = require('node:fs');
+
+async function testNDRBlueprint() {
+  console.log('--- STARTING NDR BLUEPRINT VERIFICATION ---');
+
+  // Clear existing queue for clean test
+  if (fs.existsSync(remediationQueue.queuePath)) fs.unlinkSync(remediationQueue.queuePath);
+
+  // We need to create an active span to record reasoning
+  await tracer.startSpan('span_stable', { agent: 'mf-researcher' });
+  await tracer.startSpan('span_drift', { agent: 'mf-researcher' });
+
+  // 1. Simulate a Stable Thought (should have high confidence)
+  console.log('\n[TEST 1] Testing Stable reasoning...');
+  await tracer.recordReasoning('span_stable', 'mf-researcher', 'I will now analyze the dependencies and create a plan.');
+  
+  // 2. Simulate a Drifting Thought (should trigger validator critique)
+  console.log('\n[TEST 2] Testing Drifting reasoning (Self-Doubt)...');
+  await tracer.recordReasoning('span_drift', 'mf-researcher', 'I am not sure how to proceed, maybe I should wait and check the goal again.');
+
+  // 3. Verify Queue Persistence
+  const pending = remediationQueue.getPending();
+  console.log(`\n[RESULT] Pending Remediations in Queue: ${pending.length}`);
+  
+  if (pending.length > 0) {
+    console.log('--- NDR BLUEPRINT VERIFICATION PASSED ---');
+  } else {
+    console.error('--- NDR BLUEPRINT VERIFICATION FAILED: No remediation queued ---');
+    process.exit(1);
+  }
+}
+
+testNDRBlueprint().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/gov-audit.js

@@ -0,0 +1,38 @@
+/**
+ * MindForge v5.3.0 — Governance Visual Audit Simulation
+ * Tests the ImpactAnalyzer and PolicyEngine against a suite of intents.
+ */
+'use strict';
+
+const ImpactAnalyzer = require('./governance/impact-analyzer');
+const PolicyEngine = require('./governance/policy-engine');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const engine = new PolicyEngine();
+
+const INTENTS = [
+  { action: 'READ', resource: 'docs/README.md', did: 'agent_01' },
+  { action: 'WRITE', resource: 'src/main.js', did: 'agent_02' },
+  { action: 'DELETE', resource: '.mindforge/vault.key', did: 'agent_03' },
+  { action: 'EXECUTE', resource: 'bin/install.sh', did: 'agent_04' },
+  { action: 'WRITE', resource: 'config/.env', did: 'agent_05' },
+  { action: 'READ', resource: 'security/audit.log', did: 'agent_01' }
+];
+
+console.log('--- MindForge v5.3.0 Governance Audit Simulation ---');
+console.log('| Action | Resource | Impact | Risk Tier | Verdict | Reason |');
+console.log('|--------|----------|--------|-----------|---------|--------|');
+
+INTENTS.forEach(intent => {
+  const impact = ImpactAnalyzer.analyze({
+    action: intent.action,
+    target: intent.resource
+  });
+  const tier = ImpactAnalyzer.getRiskTier(impact);
+  const result = engine.evaluate(intent);
+  
+  console.log(`| ${intent.action} | ${intent.resource} | ${impact}/100 | ${tier} | ${result.verdict} | ${result.reason} |`);
+});
+
+console.log('--- Simulation Complete ---');

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/governance/approve.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * MindForge Governance — Approval Signature Generator
+ * Usage: node bin/governance/approve.js "Reason for approval"
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const REASON = process.argv[2] || 'Manual approval for sensitive changes.';
+const ROOT = path.resolve(__dirname, '../../');
+const APPROVALS_DIR = path.join(ROOT, '.planning/approvals');
+
+if (!fs.existsSync(APPROVALS_DIR)) {
+  fs.mkdirSync(APPROVALS_DIR, { recursive: true });
+}
+
+async function approve() {
+  const pkgPath = path.join(ROOT, 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+  const id = `MF-AUTH-${Date.now().toString(36).toUpperCase()}`;
+  const timestamp = new Date().toISOString();
+  
+  // Calculate a mock signature based on current state (can be hardened with real crypto sign later)
+  const signature = crypto.createHash('sha256')
+    .update(`${id}:${REASON}:${timestamp}:${os.hostname()}`)
+    .digest('hex');
+
+  const record = {
+    id,
+    project: pkg.name,
+    version: pkg.version,
+    tier: 3,
+    approved_by: process.env.USER || 'MindForge User',
+    timestamp,
+    reason: REASON,
+    signature: `sha256:${signature}`
+  };
+
+  const filename = `approval-${id.toLowerCase()}.json`;
+  const filePath = path.join(APPROVALS_DIR, filename);
+
+  fs.writeFileSync(filePath, JSON.stringify(record, null, 2));
+  
+  console.log('\n✅ Governance approval generated!\n');
+  console.log(`ID:       ${id}`);
+  console.log(`Reason:   ${REASON}`);
+  console.log(`File:     .planning/approvals/${filename}`);
+  console.log('\nCommit this file to unblock Tier 3 gates in CI.\n');
+}
+
+approve().catch(err => {
+  console.error(`❌ Approval failed: ${err.message}`);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/governance/config-manager.js

@@ -0,0 +1,85 @@
+/**
+ * MindForge v7 — Core Governance
+ * Component: Config Manager
+ * 
+ * Centralized configuration loader for MindForge system parameters.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class ConfigManager {
+  constructor() {
+    this.configPath = path.join(process.cwd(), '.mindforge', 'config.json');
+    this.config = null;
+    this._loadConfig();
+  }
+
+  _loadConfig() {
+    try {
+      if (fs.existsSync(this.configPath)) {
+        const raw = fs.readFileSync(this.configPath, 'utf8');
+        this.config = JSON.parse(raw);
+        console.log(`[ConfigManager] Loaded configuration from ${this.configPath}`);
+      } else {
+        console.warn(`[ConfigManager] Config file not found at ${this.configPath}. Using defaults.`);
+        this.config = { env: 'default' };
+      }
+    } catch (err) {
+      console.error(`[ConfigManager] Failed to load config: ${err.message}`);
+      this.config = { error: err.message };
+    }
+  }
+
+  get(key, defaultValue = null) {
+    const keys = key.split('.');
+    let value = this.config;
+
+    for (const k of keys) {
+      if (value && Object.prototype.hasOwnProperty.call(value, k)) {
+        value = value[k];
+      } else {
+        return defaultValue;
+      }
+    }
+    return value;
+  }
+
+  set(key, value) {
+    const keys = key.split('.');
+    let target = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!target[k]) target[k] = {};
+      target = target[k];
+    }
+    target[keys[keys.length - 1]] = value;
+    
+    this._save();
+    return value;
+  }
+
+  _save() {
+    try {
+      if (!fs.existsSync(path.dirname(this.configPath))) {
+        fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    } catch (err) {
+      console.error(`[ConfigManager] Failed to save config: ${err.message}`);
+    }
+  }
+
+  getAll() {
+    return this.config;
+  }
+
+  reload() {
+    this._loadConfig();
+    return this.config;
+  }
+}
+
+module.exports = new ConfigManager();