mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/model-router.js

@@ -0,0 +1,112 @@
+/**
+ * MindForge v2 — Model Router
+ * Resolves persona and tier to a specific model ID based on settings and context.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Default model assignments
+const DEFAULTS = {
+  PLANNER_MODEL:          'claude-3-opus-20240229',
+  EXECUTOR_MODEL:         'claude-3-5-sonnet-20240620',
+  REVIEWER_MODEL:         'gpt-4o',
+  SECURITY_MODEL:         'claude-3-opus-20240229',
+  RESEARCH_MODEL:         'gemini-1.5-pro',
+  QA_MODEL:               'claude-3-5-sonnet-20240620',
+  DEBUG_MODEL:            'claude-3-opus-20240229',
+  QUICK_MODEL:            'claude-3-5-haiku-20241022',
+  CROSS_REVIEW_SECONDARY: 'gpt-4o',
+  CROSS_REVIEW_TERTIARY:  'gemini-1.5-pro',
+};
+
+// Persona to setting key mapping
+const PERSONA_MAP = {
+  'developer':         'EXECUTOR_MODEL',
+  'architect':         'PLANNER_MODEL',
+  'planner':           'PLANNER_MODEL',
+  'security-reviewer': 'SECURITY_MODEL',
+  'qa-engineer':       'QA_MODEL',
+  'research-agent':    'RESEARCH_MODEL',
+  'debug-specialist':  'DEBUG_MODEL',
+  'decision-architect': 'PLANNER_MODEL',
+};
+
+let _settingsCache = null;
+
+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');
+  const settings = { ...DEFAULTS };
+  
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match) {
+      settings[match[1]] = match[2].trim();
+    }
+  }
+  _settingsCache = settings;
+  return settings;
+}
+
+function route(persona = 'developer', tier = 1) {
+  const settings = readMindforgeSettings();
+  
+  // 1. Tier 3 override (Security/Privacy always uses SECURITY_MODEL)
+  if (tier === 3) {
+    return {
+      model: settings.SECURITY_MODEL,
+      setting: 'SECURITY_MODEL',
+      reason: 'Tier 3 (Security/Privacy) override'
+    };
+  }
+
+  // 2. Persona mapping (Specific personas like research, debug, qa)
+  if (persona !== 'developer' && PERSONA_MAP[persona]) {
+    const settingKey = PERSONA_MAP[persona];
+    return {
+      model: settings[settingKey],
+      setting: settingKey,
+      reason: `Mapped from specific persona "${persona}"`
+    };
+  }
+
+  // 3. Budget Bias (Tier 1 uses QUICK_MODEL for default developer tasks)
+  if (tier === 1) {
+    return {
+      model: settings.QUICK_MODEL,
+      setting: 'QUICK_MODEL',
+      reason: 'Tier 1 Budget Bias (efficiency mode)'
+    };
+  }
+
+  // 4. Default mapping
+  const settingKey = 'EXECUTOR_MODEL';
+  const model = settings[settingKey];
+
+  return {
+    model,
+    setting: settingKey,
+    reason: `Default EXECUTOR_MODEL for tier ${tier}`
+  };
+}
+
+function getModel(settingKey) {
+  const settings = readMindforgeSettings();
+  return settings[settingKey] || DEFAULTS[settingKey];
+}
+
+function clearCache() {
+  _settingsCache = null;
+}
+
+function getAllSettings() {
+  return readMindforgeSettings();
+}
+
+module.exports = { route, getModel, clearCache, getAllSettings };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/openai-provider.js

@@ -0,0 +1,78 @@
+/**
+ * MindForge v2 — OpenAI Provider
+ */
+'use strict';
+
+const https = require('https');
+
+class OpenAIProvider {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+
+  async complete(params) {
+    const { model, systemPrompt, userMessage, maxTokens = 4096, temperature = 0.7 } = params;
+
+    const data = JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userMessage }
+      ],
+      max_tokens: maxTokens,
+      temperature,
+    });
+
+    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: 120_000,
+      }, res => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(body);
+            if (res.statusCode !== 200) {
+              return reject(Object.assign(new Error(json.error?.message || 'OpenAI API error'), { status: res.statusCode }));
+            }
+
+            const inputTokens = json.usage.prompt_tokens;
+            const outputTokens = json.usage.completion_tokens;
+            
+            // Basic cost calculation (GPT-4o prices)
+            const cost = (inputTokens * 0.000005) + (outputTokens * 0.000015);
+
+            resolve({
+              model: json.model,
+              content: json.choices[0].message.content,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost_usd: cost,
+              provider: 'openai'
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse OpenAI response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(Object.assign(new Error('OpenAI timeout'), { status: 408 }));
+      });
+      req.write(data);
+      req.end();
+    });
+  }
+}
+
+module.exports = OpenAIProvider;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/models/performance-stats.json

@@ -0,0 +1,22 @@
+{
+  "anthropic": {
+    "refactor": { "success": 45, "failure": 2 },
+    "test": { "success": 30, "failure": 1 },
+    "architect": { "success": 12, "failure": 0 }
+  },
+  "google": {
+    "refactor": { "success": 25, "failure": 8 },
+    "test": { "success": 50, "failure": 2 },
+    "architect": { "success": 8, "failure": 4 }
+  },
+  "aws": {
+    "refactor": { "success": 20, "failure": 5 },
+    "test": { "success": 15, "failure": 5 },
+    "architect": { "success": 5, "failure": 2 }
+  },
+  "azure": {
+    "refactor": { "success": 10, "failure": 10 },
+    "test": { "success": 20, "failure": 5 },
+    "architect": { "success": 3, "failure": 5 }
+  }
+}

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

@@ -0,0 +1,115 @@
+/**
+ * MindForge v2 — Research Engine
+ * Leverages Gemini 1M context for deep research.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const dns = require('dns').promises;
+const ModelClient = require('../models/model-client');
+const Router = require('../models/model-router');
+
+const PRIVATE_RANGES = [
+  /^127\./,
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^169\.254\./,
+  /^::1$/,
+  /^fc00:/,
+  /^fe80:/,
+];
+
+const SYSTEM_PROMPTS = {
+  general: 'You are a thorough technical researcher. Analyze the provided context deeply and answer the question comprehensively. Cite specific evidence.',
+  library_comparison: 'You are a senior engineer evaluating libraries. Analyze: API design, maintenance, performance, security, and community.',
+  codebase_analysis: 'You are a senior architect auditing a codebase. Identify patterns, debt, security issues, and bottlenecks.',
+  compliance: 'You are a compliance engineer reviewing implementation against regulations. Identify gaps and remediation steps.',
+};
+
+async function isSafeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!['http:', 'https:'].includes(parsed.protocol)) return false;
+    const { address } = await dns.lookup(parsed.hostname);
+    return !PRIVATE_RANGES.some(r => r.test(address));
+  } catch {
+    return false;
+  }
+}
+
+async function fetchUrl(url) {
+  if (!await isSafeUrl(url)) throw new Error(`URL blocked: ${url}`);
+  
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+    const timeout = setTimeout(() => { req.destroy(); reject(new Error('Timeout')); }, 30_000);
+
+    const req = protocol.get(url, res => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => { clearTimeout(timeout); resolve(body.slice(0, 500_000)); });
+    });
+    req.on('error', e => { clearTimeout(timeout); reject(e); });
+  });
+}
+
+function packageLocalContext(paths) {
+  let content = '';
+  for (const p of paths) {
+    const fullPath = path.resolve(process.cwd(), p);
+    if (!fs.existsSync(fullPath)) continue;
+    
+    if (fs.statSync(fullPath).isDirectory()) {
+      content += walkDir(fullPath);
+    } else {
+      content += `\n\n### File: ${p}\n${fs.readFileSync(fullPath, 'utf8')}\n`;
+    }
+  }
+  return content;
+}
+
+function walkDir(dir) {
+  let content = '';
+  const files = fs.readdirSync(dir);
+  for (const f of files) {
+    const full = path.join(dir, f);
+    if (f.startsWith('.') || f === 'node_modules') continue;
+    if (fs.statSync(full).isDirectory()) content += walkDir(full);
+    else if (['.js', '.ts', '.md', '.json'].some(ext => f.endsWith(ext))) {
+      content += `\n\n### File: ${full}\n${fs.readFileSync(full, 'utf8')}\n`;
+    }
+  }
+  return content;
+}
+
+async function research(params) {
+  const { topic, question, type = 'general', contextPaths = [], urls = [] } = params;
+  
+  let context = packageLocalContext(contextPaths);
+  for (const url of urls) {
+    try {
+      const html = await fetchUrl(url);
+      const text = html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+      context += `\n\n### URL: ${url}\n${text.slice(0, 100_000)}`;
+    } catch (e) {
+      context += `\n\n### URL: ${url}\n[Failed to fetch: ${e.message}]`;
+    }
+  }
+
+  const result = await ModelClient.complete({
+    persona: 'research-agent',
+    systemPrompt: SYSTEM_PROMPTS[type] || SYSTEM_PROMPTS.general,
+    userMessage: `Topic: ${topic}\n\nContext:\n${context}\n\nQuestion: ${question}`,
+    taskName: `research-${topic}`,
+    maxTokens: 8192
+  });
+
+  return { ...result, context_length: context.length };
+}
+
+module.exports = { research, packageLocalContext, fetchUrl };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/review/ads-engine.js

@@ -0,0 +1,126 @@
+/**
+ * MindForge v3 — ADS Engine
+ * Orchestrates the Red-Team/Blue-Team synthesis loop.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ModelClient = require('../models/model-client');
+const { calculateSoulScore, parseMetrics, synthesizeADSPlan } = require('./ads-synthesizer');
+const { v4: uuidv4 } = require('uuid');
+
+async function runADSSynthesis(params) {
+  const {
+    phaseNum,
+    goal,
+    context = '',
+    sessionId = 'unknown'
+  } = params;
+
+  process.stdout.write(`🛡️ Starting Adversarial Decision Synthesis (ADS) for Phase ${phaseNum}...\n`);
+
+  // Step 1: Blue Proposal (Architect)
+  process.stdout.write('  Step 1: Architect (Blue Team) Proposal... ');
+  const blueResponse = await ModelClient.complete({
+    persona: 'architect',
+    tier: 2,
+    systemPrompt: `You are the Blue Team Architect. Your goal is to propose a high-performance, scalable solution.
+Include a [ADS_METRICS] block with impact, leverage, reversibility, effort, risk, cost (1-10).
+Format: [ADS_METRICS]\nimpact: 8\n...[/ADS_METRICS]`,
+    userMessage: `Goal: ${goal}\nContext: ${context}`,
+    taskName: `ads-blue-phase-${phaseNum}`,
+    sessionId,
+    phaseNum
+  });
+  const bluePlan = blueResponse.content;
+  process.stdout.write('done.\n');
+
+  // Step 2: Red Critique (Auditor)
+  process.stdout.write('  Step 2: Auditor (Red Team) Critique... ');
+  const redResponse = await ModelClient.complete({
+    persona: 'qa-engineer',
+    tier: 2,
+    systemPrompt: `You are the Red Team Auditor. Your goal is to find flaws, complexity traps, and maintainability issues in the Blue Team's proposal.
+Be adversarial. Find at least 3 critical weaknesses.
+Include a [ADS_METRICS] block for your counter-proposal or critique logic.`,
+    userMessage: `Blue Proposal:\n${bluePlan}\n\nContext: ${context}`,
+    taskName: `ads-red-phase-${phaseNum}`,
+    sessionId,
+    phaseNum
+  });
+  const redCritique = redResponse.content;
+  process.stdout.write('done.\n');
+
+  // Red-Team Jailbreak: Force higher-fidelity critiques if Auditor is too lenient
+  const flawCount = (redCritique.match(/^\s*[-*•]\s+/mg) || []).length;
+  if (flawCount < 3) {
+    process.stdout.write(`  🛡️ Red-Team Jailbreak Triggered (Found ${flawCount} flaws, threshold is 3)...\n`);
+    const jailbreakResponse = await ModelClient.complete({
+      persona: 'qa-engineer',
+      tier: 2,
+      systemPrompt: `You are the Red Team Auditor. Your previous critique was too lenient. 
+You MUST identify at least 3 SPECIFIC architectural vulnerabilities, edge cases, or complexity traps in the Blue Team's proposal.
+Failure to find flaws will compromise the MindForge SOUL. Be aggressive.`,
+      userMessage: `Blue Proposal:\n${bluePlan}\n\nYour Previous Critique:\n${redCritique}\n\nFIND AT LEAST 3 ARCHITECTURAL FLAWS NOW.`,
+      taskName: `ads-red-jailbreak-${phaseNum}`,
+      sessionId,
+      phaseNum
+    });
+    process.stdout.write(`  🛡️ Jailbreak complete: ${jailbreakResponse.content.slice(0, 50)}...\n`);
+    redCritique = jailbreakResponse.content;
+  }
+
+  // Step 3: Gold Synthesis (Synthesizer)
+  process.stdout.write('  Step 3: Synthesizer (Gold Team) Verdict... ');
+  const synthesisData = synthesizeADSPlan(bluePlan, redCritique, context);
+  
+  const goldResponse = await ModelClient.complete({
+    persona: 'decision-architect',
+    tier: 2,
+    systemPrompt: `You are the Gold Team Synthesizer. Your goal is to merge the Architect's performance with the Auditor's safeguards.
+Finalize the PLAN.md. Include the [ADS_VERDICT]: [MERGED|BLUE|RED] (Score: X.XXXX) at the end.`,
+    userMessage: synthesisData.synthesis_prompt,
+    taskName: `ads-gold-phase-${phaseNum}`,
+    sessionId,
+    phaseNum
+  });
+  const finalPlan = goldResponse.content;
+  process.stdout.write('done.\n');
+
+  // Finalize outputs
+  const adsUuid = uuidv4();
+  const adrDir = path.join(process.cwd(), '.planning', 'decisions');
+  if (!fs.existsSync(adrDir)) fs.mkdirSync(adrDir, { recursive: true });
+
+  const adrPath = path.join(adrDir, `ADS-${adsUuid.slice(0, 8)}.md`);
+  const adsRecord = `
+# Adversarial Decision Synthesis — ${adsUuid}
+- **Date**: ${new Date().toISOString()}
+- **Phase**: ${phaseNum}
+- **Goal**: ${goal}
+
+## Comparison
+- **Blue (Architect)**: Score ${synthesisData.comparison.blue.score}
+- **Red (Auditor)**: Score ${synthesisData.comparison.red.score}
+
+## Synthesis Result
+${finalPlan.includes('[ADS_VERDICT]') ? finalPlan.split('[ADS_VERDICT]')[1] : 'Synthesis Complete'}
+
+## Final Plan
+Stored in .planning/PLAN.md
+`;
+
+  fs.writeFileSync(adrPath, adsRecord);
+  fs.writeFileSync(path.join(process.cwd(), '.planning', 'PLAN.md'), finalPlan);
+
+  process.stdout.write(`✅ ADS Complete. Verdict saved to ${adrPath}\n`);
+
+  return {
+    ads_id: adsUuid,
+    verdict_path: adrPath,
+    scores: synthesisData.comparison
+  };
+}
+
+module.exports = { runADSSynthesis };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/review/ads-synthesizer.js

@@ -0,0 +1,117 @@
+/**
+ * MindForge v3 — ADS Synthesizer
+ * Implements the SOUL.md Decision Scoring and Plan Merging logic.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_METRICS = {
+  impact: 5,
+  leverage: 5,
+  reversibility: 5,
+  effort: 5,
+  risk: 5,
+  cost: 5
+};
+
+/**
+ * Calculates the SOUL Decision Score based on the formula in SOUL.md:
+ * Score = (Impact * Leverage * Reversibility) / (Effort * Risk * Cost)
+ * 
+ * Each factor is expected to be a value between 1 and 10.
+ */
+function calculateSoulScore(metrics) {
+  const m = { ...DEFAULT_METRICS, ...metrics };
+  const {
+    impact,
+    leverage,
+    reversibility,
+    effort,
+    risk,
+    cost
+  } = m;
+
+  // Formula: (I * L * R) / (E * Rk * C)
+  const numerator = impact * leverage * reversibility;
+  const denominator = effort * risk * cost;
+
+  const score = denominator === 0 ? 0 : (numerator / denominator);
+  return parseFloat(score.toFixed(4));
+}
+
+/**
+ * Parses metrics from a model's response string.
+ * Expects a block like:
+ * [ADS_METRICS]
+ * impact: 8
+ * leverage: 7
+ * reversibility: 5
+ * effort: 4
+ * risk: 3
+ * cost: 2
+ * [/ADS_METRICS]
+ */
+function parseMetrics(text) {
+  const metrics = { ...DEFAULT_METRICS };
+  const match = text.match(/\[ADS_METRICS\]([\s\S]*?)\[\/ADS_METRICS\]/);
+  if (!match) return metrics;
+
+  const lines = match[1].trim().split('\n');
+  for (const line of lines) {
+    const [key, val] = line.split(':').map(s => s.trim());
+    if (key && !isNaN(val)) {
+      metrics[key.toLowerCase()] = parseFloat(val);
+    }
+  }
+  return metrics;
+}
+
+/**
+ * Merges the Blue (Performance) and Red (Maintainability/Simple) plans.
+ * Currently performs a structural merge focusing on conflict resolution.
+ */
+function synthesizeADSPlan(bluePlan, redCritique, context = '') {
+  // In a production implementation, this would involve a 3rd model call (the Synthesizer).
+  // This helper prepares the input for that call.
+  
+  const blueMetrics = parseMetrics(bluePlan);
+  const redMetrics = parseMetrics(redCritique);
+
+  const blueScore = calculateSoulScore(blueMetrics);
+  const redScore = calculateSoulScore(redMetrics);
+
+  return {
+    comparison: {
+      blue: { metrics: blueMetrics, score: blueScore },
+      red: { metrics: redMetrics, score: redScore }
+    },
+    synthesis_prompt: `
+Context:
+${context}
+
+Blue Proposal (Architect):
+${bluePlan}
+
+Red Critique (Auditor):
+${redCritique}
+
+Decision Scores:
+- Blue Score: ${blueScore}
+- Red Score: ${redScore}
+
+Task: Synthesize the final PLAN.md. 
+1. If the scores are close, merge the performance of Blue with the safeguards of Red.
+2. If one score significantly dominates, favor that approach but address the Red Team's critical findings.
+3. Output the final plan as valid Markdown with XML task tags.
+4. Finish with [ADS_VERDICT]: [BLUE|RED|MERGED] with final score.
+`
+  };
+}
+
+module.exports = {
+  calculateSoulScore,
+  parseMetrics,
+  synthesizeADSPlan
+};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/review/cross-review-engine.js

@@ -0,0 +1,92 @@
+/**
+ * MindForge v2 — Cross-Review Engine
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const ModelClient = require('../models/model-client');
+const { synthesizeFindings, extractVerdict } = require('./finding-synthesizer');
+const { write: writeReport } = require('./review-report-writer');
+const KnowledgeCapture = require('../memory/knowledge-capture');
+
+const PRIMARY_PROMPT = `You are a senior codebase architect performing a code review.
+Focus on: architectural alignment, logic correctness, maintainability, and complexity.
+Format every finding as: **[SEVERITY]** \`file:line\` — description
+Severities: LOW, MEDIUM, HIGH, CRITICAL.
+Finish with "### Verdict: APPROVE" or "### Verdict: REQUEST_CHANGES".`;
+
+const ADVERSARIAL_PROMPT = `You are a paranoid security auditor reviewing code written by a competitor.
+Your goal is to find bugs, security holes, and edge cases they missed. 
+Be critical. Trust nothing. 
+Format every finding as: **[SEVERITY]** \`file:line\` — description
+Severities: LOW, MEDIUM, HIGH, CRITICAL.
+Finish with "### Verdict: APPROVE" or "### Verdict: REQUEST_CHANGES".`;
+
+async function runCrossReview(params) {
+  const {
+    phaseNum,
+    diff,
+    context = '',
+    models = ['claude-3-5-sonnet-20240620', 'gpt-4o'],
+    sessionId = 'unknown'
+  } = params;
+
+  process.stdout.write(`⚡ Starting cross-model review for Phase ${phaseNum}...\n`);
+
+  const reviews = [];
+  
+  // Round 1: Primary
+  process.stdout.write(`  Round 1 (${models[0]}): `);
+  const r1 = await ModelClient.complete({
+    model: models[0],
+    systemPrompt: PRIMARY_PROMPT,
+    userMessage: `Context:\n${context}\n\nDiff:\n${diff}`,
+    taskName: `review-primary-phase-${phaseNum}`,
+    sessionId,
+    phaseNum
+  });
+  reviews.push({ model: models[0], content: r1.content, role: 'primary', cost_usd: r1.cost_usd });
+  process.stdout.write(`done ($${r1.cost_usd.toFixed(4)})\n`);
+
+  // Round 2: Adversarial
+  process.stdout.write(`  Round 2 (${models[1]}): `);
+  const r2 = await ModelClient.complete({
+    model: models[1],
+    systemPrompt: ADVERSARIAL_PROMPT,
+    userMessage: `Context:\n${context}\n\nDiff:\n${diff}`,
+    taskName: `review-adversarial-phase-${phaseNum}`,
+    sessionId,
+    phaseNum
+  });
+  reviews.push({ model: models[1], content: r2.content, role: 'adversarial', cost_usd: r2.cost_usd });
+  process.stdout.write(`done ($${r2.cost_usd.toFixed(4)})\n`);
+
+  // Synthesis
+  const synthesis = synthesizeFindings(reviews);
+  
+  const result = {
+    phase: phaseNum,
+    reviews,
+    synthesis,
+    total_cost_usd: reviews.reduce((sum, r) => sum + r.cost_usd, 0),
+    timestamp: new Date().toISOString()
+  };
+
+  const reportPath = writeReport(phaseNum, result);
+  process.stdout.write(`✅ Cross-review complete. Saved to ${reportPath}\n`);
+
+  // Auto-capture knowledge from review report
+  try {
+    const captured = KnowledgeCapture.captureFromCrossReview(reportPath);
+    if (captured.length > 0) {
+      process.stdout.write(`🧠 Knowledge Graph: Captured ${captured.length} security/quality findings.\n`);
+    }
+  } catch (err) {
+    process.stdout.write(`⚠️ Knowledge Capture failed: ${err.message}\n`);
+  }
+  
+  return result;
+}
+
+module.exports = { runCrossReview, parseFindings: synthesizeFindings.parseFindings, extractVerdict };