mindforge-cc 10.0.3 → 11.0.0

package/bin/migrations/schema-versions.js

@@ -71,6 +71,19 @@ const SCHEMA_HISTORY = [
       'Plugin API version upgraded to 2.0.0',
     ],
   },
+  {
+    version: '11.0.0',
+    date: '2026-05-28',
+    description: 'v11.0.0 - Persona Expansion: temporal config, rate limiting, wave execution, audit archival',
+    handoff_fields_added: [],
+    handoff_fields_removed: [],
+    audit_fields_added: [],
+    breaking: [
+      'config.json gains temporal, rate_limiting, session, wave_execution sections',
+      'AUDIT.jsonl auto-archived if exceeding 5000 lines',
+      'MINDFORGE.md VERSION format drops suffix (was X.Y.Z-SUFFIX, now X.Y.Z)',
+    ],
+  },
 ];
 
 module.exports = { SCHEMA_HISTORY };

package/bin/models/anthropic-provider.js

@@ -72,6 +72,51 @@ class AnthropicProvider {
       req.end();
     });
   }
+
+  async streamComplete(messages, options = {}) {
+    const model = options.model || 'claude-sonnet-4-6';
+    const maxTokens = options.maxTokens || 4096;
+
+    const data = JSON.stringify({
+      model,
+      messages,
+      max_tokens: maxTokens,
+      stream: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.anthropic.com',
+        path: '/v1/messages',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 300_000,
+      }, res => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', chunk => body += chunk);
+          res.on('end', () => {
+            reject(new Error(`Anthropic streaming failed: ${res.statusCode}`));
+          });
+          return;
+        }
+        resolve(res);
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Anthropic stream timeout'));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
 }
 
 module.exports = AnthropicProvider;

package/bin/models/cloud-broker.js

@@ -7,17 +7,37 @@
 const fs = require('fs');
 const path = require('path');
 
+// Per-provider latency ring buffer (last 10 calls)
+const latencyHistory = new Map();
+
+function recordLatency(provider, durationMs) {
+  if (!latencyHistory.has(provider)) {
+    latencyHistory.set(provider, []);
+  }
+  const history = latencyHistory.get(provider);
+  history.push(durationMs);
+  if (history.length > 10) history.shift();
+}
+
+function getP95Latency(provider) {
+  const history = latencyHistory.get(provider);
+  if (!history || history.length === 0) return 500;
+  const sorted = [...history].sort((a, b) => a - b);
+  const idx = Math.ceil(sorted.length * 0.95) - 1;
+  return sorted[Math.min(idx, sorted.length - 1)];
+}
+
 class CloudBroker {
   constructor(config = {}) {
     this.providers = config.providers || ['anthropic', 'google', 'aws', 'azure'];
     this.statsPath = config.statsPath || path.join(__dirname, 'performance-stats.json');
-    this.blacklist = new Map(); // provider -> expiry (Date)
-    this.failureWindow = new Map(); // provider:taskType -> count
+    this.blacklist = new Map();
+    this.failureWindow = new Map();
     this.state = {
-      'anthropic': { latency: 450, costMultiplier: 1.0, healthy: true },
-      'google': { latency: 600, costMultiplier: 0.85, healthy: true },
-      'aws': { latency: 550, costMultiplier: 0.95, healthy: true },
-      'azure': { latency: 650, costMultiplier: 1.1, healthy: true }
+      'anthropic': { costMultiplier: 1.0, healthy: true },
+      'google': { costMultiplier: 0.85, healthy: true },
+      'aws': { costMultiplier: 0.95, healthy: true },
+      'azure': { costMultiplier: 1.1, healthy: true }
     };
     this.reloadStats();
   }
@@ -71,21 +91,20 @@ class CloudBroker {
         return true;
       })
       .map(([id, data]) => {
-        // Calculate Success Probability for this task
         const stats = this.performanceStats[id]?.[taskType] || { success: 1, failure: 0 };
         const totalTasks = stats.success + stats.failure;
         const successProb = totalTasks > 0 ? (stats.success / totalTasks) : 0.5;
 
-        // Score Calculation (The "Affinity" Algorithm)
         const latencyWeight = 0.2;
         const costWeight = 0.3;
-        const affinityWeight = 0.5; 
+        const affinityWeight = 0.5;
 
-        const score = (data.latency * latencyWeight) + 
-                      (data.costMultiplier * 1000 * costWeight) + 
+        const providerLatency = getP95Latency(id);
+        const score = (providerLatency * latencyWeight) +
+                      (data.costMultiplier * 1000 * costWeight) +
                       ((1.0 - successProb) * 2000 * affinityWeight);
 
-        return { id, score, successProb: successProb.toFixed(2) };
+        return { id, score, successProb: successProb.toFixed(2), p95: providerLatency };
       });
 
     scored.sort((a, b) => a.score - b.score);
@@ -110,7 +129,7 @@ class CloudBroker {
 
     const fallback = Object.entries(this.state)
       .filter(([id, data]) => id !== failedProvider && data.healthy)
-      .sort((a, b) => a[1].latency - b[1].latency)[0];
+      .sort((a, b) => getP95Latency(a[0]) - getP95Latency(b[0]))[0];
 
     return fallback ? fallback[0] : 'google'; // Default fallback
   }
@@ -130,33 +149,62 @@ class CloudBroker {
     return mappings[provider]?.[modelGroup] || mappings[provider]?.['sonnet'];
   }
 
+  /**
+   * Removes failure entries whose sliding window (5 min) has expired.
+   */
+  _pruneStaleFailures() {
+    const now = Date.now();
+    const WINDOW_MS = 5 * 60 * 1000;
+
+    for (const [key, entry] of this.failureWindow.entries()) {
+      if (now - entry.firstFailureAt > WINDOW_MS) {
+        this.failureWindow.delete(key);
+      }
+    }
+  }
+
   /**
    * Records a task failure and manages the circuit breaker.
    */
   recordFailure(provider, taskType = 'default') {
-    const key = `${provider}:${taskType}`;
-    const failures = (this.failureWindow.get(key) || 0) + 1;
-    this.failureWindow.set(key, failures);
+    this._pruneStaleFailures();
 
-    if (failures >= 3) {
-      const expiry = new Date(Date.now() + 10 * 60 * 1000); // 10 min blacklist
+    const key = `${provider}:${taskType}`;
+    const existing = this.failureWindow.get(key);
+    const entry = existing
+      ? { count: existing.count + 1, firstFailureAt: existing.firstFailureAt }
+      : { count: 1, firstFailureAt: Date.now() };
+    this.failureWindow.set(key, entry);
+
+    if (entry.count >= 3) {
+      const expiry = new Date(Date.now() + 10 * 60 * 1000);
       this.blacklist.set(provider, expiry);
       console.warn(`[MCA-CIRCUIT-OPEN] Provider '${provider}' blacklisted for 10 min due to consecutive failures on '${taskType}'.`);
-      this.failureWindow.set(key, 0); // Reset window upon blacklisting
+      this.failureWindow.delete(key);
     }
   }
 
   /**
    * Hardening: Simulate provider failures to verify Fallback Protocol.
    */
+  recordLatency(provider, durationMs) {
+    recordLatency(provider, durationMs);
+  }
+
+  getP95Latency(provider) {
+    return getP95Latency(provider);
+  }
+
   startChaosMode() {
     console.log('[ENTERPRISE-RESILIENCE] CloudBroker Chaos Mode ACTIVE. Simulating jitter and provider dropouts...');
     setInterval(() => {
       const providers = Object.keys(this.state);
       const randomProvider = providers[Math.floor(Math.random() * providers.length)];
-      this.state[randomProvider].latency = Math.random() > 0.7 ? 5000 : 100;
+      recordLatency(randomProvider, Math.random() > 0.7 ? 5000 : 100);
     }, 10000);
   }
 }
 
 module.exports = CloudBroker;
+module.exports.recordLatency = recordLatency;
+module.exports.getP95Latency = getP95Latency;

package/bin/models/gemini-provider.js

@@ -74,6 +74,57 @@ class GeminiProvider {
       req.end();
     });
   }
+
+  async streamComplete(messages, options = {}) {
+    const model = options.model || 'gemini-2.5-pro';
+    const maxTokens = options.maxTokens || 8192;
+
+    const contents = messages.map(msg => ({
+      role: msg.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: msg.content }],
+    }));
+
+    const data = JSON.stringify({
+      contents,
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+      },
+    });
+
+    const modelId = model.startsWith('models/') ? model : `models/${model}`;
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'generativelanguage.googleapis.com',
+        path: `/v1beta/${modelId}:streamGenerateContent?alt=sse`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-goog-api-key': this.apiKey,
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 300_000,
+      }, res => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', chunk => body += chunk);
+          res.on('end', () => {
+            reject(new Error(`Gemini streaming failed: ${res.statusCode}`));
+          });
+          return;
+        }
+        resolve(res);
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Gemini stream timeout'));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
 }
 
 module.exports = GeminiProvider;

package/bin/models/model-client.js

@@ -82,6 +82,26 @@ class ModelClient {
     }
   }
 
+  static async streamComplete(params) {
+    const {
+      persona = 'developer',
+      tier = 1,
+      messages,
+      maxTokens,
+      taskName = 'unknown',
+    } = params;
+
+    const routing = Router.route(persona, tier);
+    const modelId = routing.model;
+    const provider = this._getProvider(modelId);
+
+    if (!provider || !provider.streamComplete) {
+      throw new Error(`Streaming not supported for model: ${modelId}`);
+    }
+
+    return provider.streamComplete(messages, { ...params, model: modelId });
+  }
+
   static _getProvider(modelId) {
     if (modelId.startsWith('claude') || modelId.startsWith('anthropic.claude')) {
       if (!process.env.ANTHROPIC_API_KEY) return null;

package/bin/models/model-router.js

@@ -36,15 +36,13 @@ const PERSONA_MAP = {
 };
 
 let _settingsCache = null;
+let _settingsMtime = 0;
+const CACHE_CHECK_INTERVAL_MS = 60000;
+let _lastCacheCheck = 0;
 
-function readMindforgeSettings() {
-  if (_settingsCache) return _settingsCache;
-  const configPath = path.join(process.cwd(), 'MINDFORGE.md');
-  if (!fs.existsSync(configPath)) return DEFAULTS;
-
-  const content = fs.readFileSync(configPath, 'utf8');
+function parseSettings(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
   const settings = { ...DEFAULTS };
-  
   const lines = content.split('\n');
   for (const line of lines) {
     const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
@@ -52,10 +50,30 @@ function readMindforgeSettings() {
       settings[match[1]] = match[2].trim();
     }
   }
-  _settingsCache = settings;
   return settings;
 }
 
+function readMindforgeSettings() {
+  const now = Date.now();
+  if (now - _lastCacheCheck < CACHE_CHECK_INTERVAL_MS && _settingsCache) {
+    return _settingsCache;
+  }
+  _lastCacheCheck = now;
+
+  const configPath = path.join(process.cwd(), 'MINDFORGE.md');
+  try {
+    const stat = fs.statSync(configPath);
+    if (stat.mtimeMs !== _settingsMtime) {
+      _settingsMtime = stat.mtimeMs;
+      _settingsCache = parseSettings(configPath);
+    }
+  } catch {
+    if (!_settingsCache) _settingsCache = { ...DEFAULTS };
+  }
+
+  return _settingsCache;
+}
+
 function route(persona = 'developer', tier = 1) {
   const settings = readMindforgeSettings();
   
@@ -105,6 +123,8 @@ function getModel(settingKey) {
 
 function clearCache() {
   _settingsCache = null;
+  _settingsMtime = 0;
+  _lastCacheCheck = 0;
 }
 
 function getAllSettings() {

package/bin/models/openai-provider.js

@@ -73,6 +73,50 @@ class OpenAIProvider {
       req.end();
     });
   }
+
+  async streamComplete(messages, options = {}) {
+    const model = options.model || 'gpt-4o';
+    const maxTokens = options.maxTokens || 4096;
+
+    const data = JSON.stringify({
+      model,
+      messages,
+      max_tokens: maxTokens,
+      stream: true,
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.openai.com',
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+          'Content-Length': Buffer.byteLength(data),
+        },
+        timeout: 300_000,
+      }, res => {
+        if (res.statusCode !== 200) {
+          let body = '';
+          res.on('data', chunk => body += chunk);
+          res.on('end', () => {
+            reject(new Error(`OpenAI streaming failed: ${res.statusCode}`));
+          });
+          return;
+        }
+        resolve(res);
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('OpenAI stream timeout'));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
 }
 
 module.exports = OpenAIProvider;

package/bin/utils/file-io.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const path = require('path');
 const crypto = require('crypto');
+const zlib = require('zlib');
 
 class AuditWriter {
   constructor(filePath) {
@@ -99,4 +100,65 @@ function readJSONSync(filePath) {
   }
 }
 
-module.exports = { AuditWriter, readJSON, writeJSON, readJSONL, readJSONSync };
+function atomicWriteJSON(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fd = fs.openSync(tmpPath, 'w');
+  fs.writeSync(fd, content);
+  fs.fsyncSync(fd);
+  fs.closeSync(fd);
+  fs.renameSync(tmpPath, filePath);
+}
+
+async function atomicWriteJSONAsync(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fh = await fsp.open(tmpPath, 'w');
+  await fh.write(content);
+  await fh.sync();
+  await fh.close();
+  await fsp.rename(tmpPath, filePath);
+}
+
+class AuditRotator {
+  constructor(options = {}) {
+    this.maxLines = options.maxLines || 5000;
+  }
+
+  shouldRotate(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lineCount = content.split('\n').filter(l => l.trim()).length;
+    return lineCount >= this.maxLines;
+  }
+
+  rotate(filePath, archiveDir) {
+    const dir = archiveDir || path.join(path.dirname(filePath), '..', 'audit-archive');
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const baseName = path.basename(filePath, path.extname(filePath));
+    const archiveName = `${baseName}-${timestamp}.jsonl.gz`;
+    const archivePath = path.join(dir, archiveName);
+
+    // Crash-safe: write archive FIRST, then truncate source
+    const content = fs.readFileSync(filePath);
+    const compressed = zlib.gzipSync(content);
+    fs.writeFileSync(archivePath, compressed);
+
+    const lines = content.toString('utf8').split('\n').filter(l => l.trim());
+    const carryover = lines.slice(-100).join('\n') + '\n';
+    const tmpPath = filePath + '.tmp.' + process.pid;
+    const fd = fs.openSync(tmpPath, 'w');
+    fs.writeSync(fd, carryover);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fs.renameSync(tmpPath, filePath);
+
+    return archivePath;
+  }
+}
+
+module.exports = { AuditWriter, AuditRotator, readJSON, writeJSON, readJSONL, readJSONSync, atomicWriteJSON, atomicWriteJSONAsync };

package/bin/utils/index.js

@@ -1,5 +1,63 @@
 'use strict';
+
+class LRUMap {
+  constructor(maxSize, options = {}) {
+    this._max = maxSize;
+    this._onEvict = options.onEvict || null;
+    this._map = new Map();
+  }
+
+  get(key) {
+    if (!this._map.has(key)) return undefined;
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+
+  set(key, value) {
+    if (this._map.has(key)) {
+      this._map.delete(key);
+    } else if (this._map.size >= this._max) {
+      const oldest = this._map.keys().next().value;
+      const oldestValue = this._map.get(oldest);
+      this._map.delete(oldest);
+      if (this._onEvict) this._onEvict(oldest, oldestValue);
+    }
+    this._map.set(key, value);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  delete(key) {
+    return this._map.delete(key);
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+  get size() {
+    return this._map.size;
+  }
+
+  keys() {
+    return this._map.keys();
+  }
+
+  values() {
+    return this._map.values();
+  }
+
+  entries() {
+    return this._map.entries();
+  }
+}
+
 module.exports = {
+  LRUMap,
   ...require('./paths'),
   ...require('./file-io'),
   ...require('./errors')

package/docs/getting-started.md

@@ -1,4 +1,4 @@
-# MindForge — Getting Started (v10.0.1)
+# MindForge — Getting Started (v11.0.0)
 
 This guide gets you from zero to a working MindForge project in under five minutes.
 

package/docs/user-guide.md

@@ -1,4 +1,4 @@
-# MindForge User Guide (v10.0.1)
+# MindForge User Guide (v11.0.0)
 
 This guide gets you from install to productive, with the minimum needed to run MindForge in a real project.
 
@@ -136,7 +136,7 @@ Observe your agent waves, token spend, and milestone progress in real-time.
 
 The dashboard provides a premium web interface at `http://localhost:7339`.
 
-> **Authentication (v10.0.1+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
+> **Authentication (v11.0.0+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mindforge-cc",
-  "version": "10.0.3",
-  "description": "MindForge — Sovereign Agentic Intelligence Framework. Bedrock Fortified: Production-Grade Architecture (v10)",
+  "version": "11.0.0",
+  "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",
     "mindforge": "bin/mindforge-cli.js"