mindforge-cc 10.7.0 → 11.0.0

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 };

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;