mindforge-cc 8.1.1 → 9.0.0

package/bin/memory/vector-hub.js

@@ -1,24 +1,25 @@
 const Database = require('better-sqlite3');
 const { Kysely, SqliteDialect, sql } = require('kysely');
+const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs');
 
 /**
- * MindForge v8 VectorHub
- * Unified Persistence Layer for Trace, Remediation, and Skill data.
+ * MindForge v9 VectorHub
+ * Unified Persistence Layer — traces, remediations, skills, knowledge, and graph edges.
  */
 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;
   }
 
@@ -51,13 +52,6 @@ class VectorHub {
       .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')
@@ -101,12 +95,61 @@ class VectorHub {
       .addColumn('value', 'text')
       .execute();
 
-    // Enable Full-Text Search for traces (FTS5)
+    // v9 Pillar XXVI: Unified Knowledge table (migrated from JSONL stores)
+    await this.db.schema
+      .createTable('knowledge')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('type', 'text', (col) => col.notNull())
+      .addColumn('content', 'text', (col) => col.notNull())
+      .addColumn('tags', 'text')
+      .addColumn('source', 'text')
+      .addColumn('confidence', 'real', (col) => col.defaultTo(1.0))
+      .addColumn('created_at', 'text', (col) => col.notNull())
+      .addColumn('updated_at', 'text')
+      .addColumn('metadata', 'text')
+      .execute();
+
+    // v9 Pillar XXVI: Graph edges table (migrated from knowledge-graph JSONL)
+    await this.db.schema
+      .createTable('graph_edges')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('source_id', 'text', (col) => col.notNull())
+      .addColumn('target_id', 'text', (col) => col.notNull())
+      .addColumn('edge_type', 'text', (col) => col.notNull())
+      .addColumn('weight', 'real', (col) => col.defaultTo(1.0))
+      .addColumn('created_at', 'text', (col) => col.notNull())
+      .execute();
+
+    // v9 Pillar XXVII: Migration tracking table
+    await this.db.schema
+      .createTable('_migrations')
+      .ifNotExists()
+      .addColumn('id', 'integer', (col) => col.primaryKey())
+      .addColumn('name', 'text', (col) => col.notNull())
+      .addColumn('applied_at', 'text', (col) => col.notNull())
+      .execute();
+
+    // Enable Full-Text Search (FTS5) for traces and knowledge
     await sql`
-      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search 
+      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search
       USING fts5(trace_id, content, agent, tokenize='porter');
     `.execute(this.db);
 
+    await sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_search
+      USING fts5(id, content, tags, tokenize='porter');
+    `.execute(this.db);
+
+    // v9: Secondary indexes for common query patterns
+    await sql`CREATE INDEX IF NOT EXISTS idx_traces_trace_id ON traces(trace_id)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_traces_timestamp ON traces(timestamp)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_knowledge_type ON knowledge(type)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_id)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_id)`.execute(this.db);
+    await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_migrations_name ON _migrations(name)`.execute(this.db);
+
     this.initialized = true;
     console.log(`[VectorHub] Initialized SQLite persistence at ${this.dbPath}`);
   }
@@ -120,7 +163,7 @@ class VectorHub {
    */
   async recordTrace(data) {
     const entry = {
-      id: data.id || Math.random().toString(36).substr(2, 9),
+      id: data.id || crypto.randomBytes(8).toString('hex'),
       trace_id: data.trace_id,
       span_id: data.span_id || null,
       event: data.event,
@@ -143,6 +186,7 @@ class VectorHub {
     
     // Update FTS5 index if content exists
     if (entry.content) {
+      await sql`DELETE FROM traces_search WHERE trace_id = ${entry.trace_id}`.execute(this.db);
       await sql`INSERT INTO traces_search (trace_id, content, agent) VALUES (${entry.trace_id}, ${entry.content}, ${entry.agent})`
         .execute(this.db);
     }
@@ -153,9 +197,10 @@ class VectorHub {
   /**
    * Semantic search for previous traces.
    */
-  async searchTraces(query) {
+  async searchTraces(rawQuery) {
+    const query = '"' + rawQuery.replace(/"/g, '""') + '"';
     const results = await sql`
-        SELECT t.*, ts.rank 
+        SELECT t.*, ts.rank
         FROM traces t
         JOIN traces_search ts ON t.trace_id = ts.trace_id
         WHERE traces_search MATCH ${query}
@@ -164,6 +209,93 @@ class VectorHub {
       `.execute(this.db);
     return results.rows;
   }
+  // ── v9 Pillar XXVI: Unified Knowledge API ─────────────────────────────────
+
+  async saveKnowledge(entry) {
+    const now = new Date().toISOString();
+    const record = {
+      id: entry.id || `k_${crypto.randomBytes(8).toString('hex')}`,
+      type: entry.type || 'insight',
+      content: entry.content,
+      tags: Array.isArray(entry.tags) ? entry.tags.join(',') : (entry.tags || ''),
+      source: entry.source || 'unknown',
+      confidence: entry.confidence ?? 1.0,
+      created_at: entry.created_at || now,
+      updated_at: now,
+      metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
+    };
+
+    await this.db.insertInto('knowledge')
+      .values(record)
+      .onConflict(oc => oc.column('id').doUpdateSet({
+        content: record.content,
+        tags: record.tags,
+        confidence: record.confidence,
+        updated_at: record.updated_at,
+        metadata: record.metadata,
+      }))
+      .execute();
+
+    await sql`DELETE FROM knowledge_search WHERE id = ${record.id}`.execute(this.db);
+    await sql`INSERT INTO knowledge_search (id, content, tags) VALUES (${record.id}, ${record.content}, ${record.tags})`
+      .execute(this.db);
+
+    return record.id;
+  }
+
+  async searchKnowledge(rawQuery, limit = 10) {
+    const query = '"' + rawQuery.replace(/"/g, '""') + '"';
+    const results = await sql`
+      SELECT k.*, ks.rank
+      FROM knowledge k
+      JOIN knowledge_search ks ON k.id = ks.id
+      WHERE knowledge_search MATCH ${query}
+      ORDER BY ks.rank
+      LIMIT ${limit}
+    `.execute(this.db);
+    return results.rows;
+  }
+
+  async saveEdge(edge) {
+    const record = {
+      id: edge.id || `e_${crypto.randomBytes(8).toString('hex')}`,
+      source_id: edge.source_id,
+      target_id: edge.target_id,
+      edge_type: edge.edge_type,
+      weight: edge.weight ?? 1.0,
+      created_at: edge.created_at || new Date().toISOString(),
+    };
+
+    await this.db.insertInto('graph_edges')
+      .values(record)
+      .onConflict(oc => oc.column('id').doNothing())
+      .execute();
+
+    return record.id;
+  }
+
+  async getEdges(nodeId) {
+    const results = await this.db.selectFrom('graph_edges')
+      .selectAll()
+      .where((eb) => eb.or([
+        eb('source_id', '=', nodeId),
+        eb('target_id', '=', nodeId),
+      ]))
+      .execute();
+    return results;
+  }
+
+  // ── v9 Pillar XXVII: Migration tracking ──────────────────────────────────
+
+  async getAppliedMigrations() {
+    const rows = await this.db.selectFrom('_migrations').selectAll().execute();
+    return rows.map(r => r.name);
+  }
+
+  async recordMigration(name) {
+    await sql`INSERT OR IGNORE INTO _migrations (name, applied_at) VALUES (${name}, ${new Date().toISOString()})`
+      .execute(this.db);
+  }
 }
 
 module.exports = new VectorHub();

package/bin/migrations/migrate.js

@@ -44,6 +44,7 @@ async function runMigrations(fromVersion, toVersion) {
     require('./0.1.0-to-0.5.0'),
     require('./0.5.0-to-0.6.0'),
     require('./0.6.0-to-1.0.0'),
+    require('./v9-unified-memory'),
   ];
 
   // A migration should run if its DESTINATION VERSION falls within the range:

package/bin/migrations/v9-unified-memory.js

@@ -0,0 +1,98 @@
+/**
+ * MindForge v9 Migration — Unified Memory Architecture (Pillar XXVI)
+ * Migrates knowledge-store JSONL and knowledge-graph JSONL into celestial.db.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const vectorHub = require('../memory/vector-hub');
+
+const fromVersion = '8.2.1';
+const toVersion = '9.0.0';
+const description = 'Unified Memory: migrate JSONL knowledge stores into SQLite';
+
+async function run() {
+  await vectorHub.init();
+
+  const applied = await vectorHub.getAppliedMigrations();
+  if (applied.includes('v9-unified-memory')) {
+    console.log('[v9-MIGRATION] Already applied — skipping.');
+    return;
+  }
+
+  let knowledgeMigrated = 0;
+  let edgesMigrated = 0;
+  let skippedLines = 0;
+
+  await vectorHub.db.transaction().execute(async (trx) => {
+    // 1. Migrate knowledge-base.jsonl → knowledge table
+    const kbPaths = [
+      path.join(process.cwd(), '.mindforge', 'memory', 'knowledge-base.jsonl'),
+      path.join(process.cwd(), '.mindforge', 'memory', 'global-knowledge-base.jsonl'),
+    ];
+
+    for (const kbPath of kbPaths) {
+      if (!fs.existsSync(kbPath)) continue;
+      const lines = fs.readFileSync(kbPath, 'utf8').split('\n').filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.status === 'deleted') continue;
+          await vectorHub.saveKnowledge({
+            id: entry.id,
+            type: entry.type || 'insight',
+            content: entry.content || entry.insight || '',
+            tags: entry.tags || [],
+            source: entry.source || (kbPath.includes('global') ? 'global' : 'project'),
+            confidence: entry.confidence ?? 1.0,
+            created_at: entry.timestamp || entry.created_at,
+            metadata: entry,
+          });
+          knowledgeMigrated++;
+        } catch (e) {
+          skippedLines++;
+        }
+      }
+    }
+
+    // 2. Migrate knowledge-graph edges → graph_edges table
+    const graphPath = path.join(process.cwd(), '.mindforge', 'memory', 'graph-edges.jsonl');
+    if (fs.existsSync(graphPath)) {
+      const lines = fs.readFileSync(graphPath, 'utf8').split('\n').filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const edge = JSON.parse(line);
+          await vectorHub.saveEdge({
+            id: edge.id || edge.edge_id,
+            source_id: edge.source_id || edge.from,
+            target_id: edge.target_id || edge.to,
+            edge_type: edge.edge_type || edge.type || 'RELATED_TO',
+            weight: edge.weight ?? 1.0,
+            created_at: edge.timestamp || edge.created_at,
+          });
+          edgesMigrated++;
+        } catch (e) {
+          skippedLines++;
+        }
+      }
+    }
+  });
+
+  // 3. Record migration completion (outside transaction — it committed successfully)
+  await vectorHub.recordMigration('v9-unified-memory');
+
+  console.log(`[v9-MIGRATION] Knowledge entries migrated: ${knowledgeMigrated}`);
+  console.log(`[v9-MIGRATION] Graph edges migrated: ${edgesMigrated}`);
+  if (skippedLines > 0) {
+    console.warn(`[v9-MIGRATION] WARNING: ${skippedLines} malformed lines skipped`);
+  }
+}
+
+if (require.main === module) {
+  run().then(() => process.exit(0)).catch(err => { console.error(err); process.exit(1); });
+}
+
+module.exports = { fromVersion, toVersion, description, run };

package/bin/models/cloud-broker.js

@@ -118,12 +118,13 @@ class CloudBroker {
   /**
    * Retrieves provider-specific model mapping.
    */
+  // v9: Provider model mappings aligned to Claude 4.x family
   mapToProviderModel(provider, modelGroup) {
     const mappings = {
-      'anthropic': { 'sonnet': 'claude-3-5-sonnet', 'opus': 'claude-3-opus', 'haiku': 'claude-3-haiku' },
-      'google': { 'sonnet': 'gemini-1.5-pro', 'haiku': 'gemini-1.5-flash' },
-      'aws': { 'sonnet': 'anthropic.claude-3-5-sonnet-v2:0', 'haiku': 'anthropic.claude-3-haiku-v1:0' },
-      'azure': { 'sonnet': 'gpt-4o', 'haiku': 'gpt-35-turbo' }
+      'anthropic': { 'sonnet': 'claude-sonnet-4-6', 'opus': 'claude-opus-4-7', 'haiku': 'claude-haiku-4-5' },
+      'google': { 'sonnet': 'gemini-2.5-pro', 'haiku': 'gemini-2.5-flash' },
+      'aws': { 'sonnet': 'anthropic.claude-sonnet-4-6-v1:0', 'haiku': 'anthropic.claude-haiku-4-5-v1:0' },
+      'azure': { 'sonnet': 'claude-sonnet-4-6', 'haiku': 'claude-haiku-4-5' }
     };
 
     return mappings[provider]?.[modelGroup] || mappings[provider]?.['sonnet'];
@@ -151,9 +152,9 @@ class CloudBroker {
   startChaosMode() {
     console.log('[ENTERPRISE-RESILIENCE] CloudBroker Chaos Mode ACTIVE. Simulating jitter and provider dropouts...');
     setInterval(() => {
-      const providers = Object.keys(this.latencyMap);
+      const providers = Object.keys(this.state);
       const randomProvider = providers[Math.floor(Math.random() * providers.length)];
-      this.latencyMap[randomProvider] = Math.random() > 0.7 ? 5000 : 100; // Spike latency
+      this.state[randomProvider].latency = Math.random() > 0.7 ? 5000 : 100;
     }, 10000);
   }
 }

package/bin/models/model-broker.js

@@ -114,14 +114,15 @@ class ModelBroker {
   }
 
   estimateCost(modelId, input, output) {
-    // Mock cost estimation logic per 1M tokens
+    // v9: Pricing aligned to Claude 4.x family (per 1M tokens)
     const rates = {
-      'claude-3-opus': { in: 15, out: 75 },
-      'claude-3-5-sonnet': { in: 3, out: 15 },
-      'claude-3-haiku': { in: 0.25, out: 1.25 },
+      'claude-opus-4-7':   { in: 15, out: 75 },
+      'claude-sonnet-4-6': { in: 3, out: 15 },
+      'claude-haiku-4-5':  { in: 0.80, out: 4.0 },
+      'gemini-2.5-pro':    { in: 1.25, out: 10 },
     };
 
-    const rate = rates[modelId] || rates['claude-3-5-sonnet'];
+    const rate = rates[modelId] || rates['claude-sonnet-4-6'];
     return (input / 1_000_000) * rate.in + (output / 1_000_000) * rate.out;
   }
 }

package/bin/models/model-client.js

@@ -10,10 +10,11 @@ const AnthropicProvider = require('./anthropic-provider');
 const OpenAIProvider = require('./openai-provider');
 const GeminiProvider = require('./gemini-provider');
 
+// v9: Fallback chains aligned to Claude 4.x family
 const FALLBACK_CHAINS = {
-  'claude-3-opus-20240229': ['gpt-4o', 'claude-3-5-sonnet-20240620'],
-  'gpt-4o': ['claude-3-5-sonnet-20240620'],
-  'gemini-1.5-pro': ['claude-3-5-sonnet-20240620'],
+  'claude-opus-4-7': ['claude-sonnet-4-6', 'gemini-2.5-pro'],
+  'claude-sonnet-4-6': ['claude-haiku-4-5', 'gemini-2.5-pro'],
+  'gemini-2.5-pro': ['claude-sonnet-4-6'],
 };
 
 class ModelClient {
@@ -70,24 +71,27 @@ class ModelClient {
         return result;
 
       } catch (err) {
-        process.stderr.write(`[model-client] ${currentModel} failed: ${err.message}\n`);
+        const safeMsg = (err.message || '').replace(/sk-[a-zA-Z0-9_-]+/g, 'sk-***').replace(/key-[a-zA-Z0-9_-]+/g, 'key-***');
+        process.stderr.write(`[model-client] ${currentModel} failed: ${safeMsg}\n`);
         if (attempts.indexOf(currentModel) === attempts.length - 1) {
-          throw err;
+          const safeErr = new Error(safeMsg);
+          safeErr.code = err.code;
+          throw safeErr;
         }
       }
     }
   }
 
   static _getProvider(modelId) {
-    if (modelId.includes('claude')) {
+    if (modelId.startsWith('claude') || modelId.startsWith('anthropic.claude')) {
       if (!process.env.ANTHROPIC_API_KEY) return null;
       return new AnthropicProvider(process.env.ANTHROPIC_API_KEY);
     }
-    if (modelId.includes('gpt')) {
+    if (modelId.startsWith('gpt') || modelId.startsWith('o1') || modelId.startsWith('o3')) {
       if (!process.env.OPENAI_API_KEY) return null;
       return new OpenAIProvider(process.env.OPENAI_API_KEY);
     }
-    if (modelId.includes('gemini')) {
+    if (modelId.startsWith('gemini')) {
       if (!process.env.GOOGLE_API_KEY) return null;
       return new GeminiProvider(process.env.GOOGLE_API_KEY);
     }

package/bin/models/model-router.js

@@ -7,18 +7,18 @@
 const fs = require('fs');
 const path = require('path');
 
-// Default model assignments
+// v9: Model topology aligned to Claude 4.x family (2026-04)
 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',
+  PLANNER_MODEL:          'claude-opus-4-7',
+  EXECUTOR_MODEL:         'claude-sonnet-4-6',
+  REVIEWER_MODEL:         'claude-sonnet-4-6',
+  SECURITY_MODEL:         'claude-opus-4-7',
+  RESEARCH_MODEL:         'gemini-2.5-pro',
+  QA_MODEL:               'claude-sonnet-4-6',
+  DEBUG_MODEL:            'claude-opus-4-7',
+  QUICK_MODEL:            'claude-haiku-4-5',
+  CROSS_REVIEW_SECONDARY: 'claude-sonnet-4-6',
+  CROSS_REVIEW_TERTIARY:  'gemini-2.5-pro',
 };
 
 // Persona to setting key mapping
@@ -31,6 +31,8 @@ const PERSONA_MAP = {
   'research-agent':    'RESEARCH_MODEL',
   'debug-specialist':  'DEBUG_MODEL',
   'decision-architect': 'PLANNER_MODEL',
+  'sre-engineer':     'EXECUTOR_MODEL',
+  'sre-auditor':      'PLANNER_MODEL',
 };
 
 let _settingsCache = null;

package/bin/sre/adversarial-sre.js

@@ -0,0 +1,109 @@
+/**
+ * MindForge v9.0.0 — Adversarial SRE Debate (Pillar XXII)
+ * Specialized three-way consensus for high-stakes remediation.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const ModelClient = require('../models/model-client');
+const crypto = require('node:crypto');
+
+class AdversarialSRE {
+  constructor(options = {}) {
+    this.sessionId = options.sessionId || 'sre-session';
+  }
+
+  /**
+   * Runs the SRE debate loop for a specific incident.
+   * @param {Object} incident - The incident details from Sentinel
+   * @param {string} mirrorPath - Path to the Shadow Mirror environment
+   */
+  async runDebate(incident, mirrorPath) {
+    console.log(`⚖️ SRE DEBATE: Starting consensus loop for ${incident.incident_type}...`);
+
+    // 1. Proposer (SRE Engineer) - Tier 2
+    console.log('  [1/3] SRE Engineer proposing fix...');
+    const proposerResult = await ModelClient.complete({
+      persona: 'sre-engineer',
+      tier: 2,
+      systemPrompt: `You are the SRE Proposer. An incident of type ${incident.incident_type} was detected.
+Incident Details: ${JSON.stringify(incident.details)}
+Propose a surgical remediation plan that minimizes downtime and avoids regressions.
+Include an [SRE_PLAN] block with specific file mutations.`,
+      userMessage: `Environment: ${mirrorPath}\nIncident: ${incident.remediation_id}`,
+      taskName: `sre-proposal-${incident.remediation_id}`
+    });
+    const proposal = proposerResult.content;
+
+    // 2. Hunter (Chaos/Regression Agent) - Tier 2
+    console.log('  [2/3] Chaos Hunter identifying regressions...');
+    const hunterResult = await ModelClient.complete({
+      persona: 'qa-engineer',
+      tier: 2,
+      systemPrompt: `You are the SRE Chaos Hunter. Your goal is to find ways the proposed fix could break production.
+Check for resource leaks, performance hits, or new security vulnerabilities introduced by the fix.
+Include an [SRE_CRITIQUE] block with at least 2 critical concerns.`,
+      userMessage: `Proposed Fix:\n${proposal}`,
+      taskName: `sre-chaos-${incident.remediation_id}`
+    });
+    const critique = hunterResult.content;
+
+    // 3. Auditor (Specialist SRE Auditor) - Tier 3 (Opus Locked)
+    console.log('  [3/3] SRE Auditor (Opus) rendering final verdict...');
+    const auditorResult = await ModelClient.complete({
+      persona: 'sre-auditor',
+      tier: 3, // Force tier 3 for Opus binding
+      systemPrompt: `You are the High-Intelligence SRE Auditor (Opus-class). 
+You must analyze the struggle between the Proposer and the Hunter.
+Your goal is to ensure "Deterministic Reliability."
+Render a final [VERDICT]: APPROVED | REJECTED | AMENDED.
+If AMENDED, provide the final corrected logic.`,
+      userMessage: `Incident: ${incident.incident_type}\n\nPROPOSAL:\n${proposal}\n\nCRITIQUE:\n${critique}`,
+      taskName: `sre-audit-${incident.remediation_id}`
+    });
+    const finalVerdict = auditorResult.content;
+
+    // Record the decision
+    const decisionId = crypto.randomBytes(4).toString('hex');
+    const decisionPath = path.join(process.cwd(), '.planning', 'decisions', `SRE-${decisionId}.md`);
+    
+    const record = `
+# SRE Decision Trace — ${decisionId}
+- **Incident**: ${incident.incident_type}
+- **Timestamp**: ${new Date().toISOString()}
+- **Mirror**: ${mirrorPath}
+
+## Proposer Logic
+${proposal}
+
+## Chaos Critique
+${critique}
+
+## Final Auditor Verdict (Opus)
+${finalVerdict}
+`;
+
+    if (!fs.existsSync(path.dirname(decisionPath))) {
+      fs.mkdirSync(path.dirname(decisionPath), { recursive: true });
+    }
+    fs.writeFileSync(decisionPath, record);
+
+    console.log(`✅ SRE Debate Complete. Verdict: ${this.parseVerdict(finalVerdict)}`);
+    return {
+      decision_id: decisionId,
+      verdict: this.parseVerdict(finalVerdict),
+      trace_path: decisionPath,
+      final_logic: finalVerdict
+    };
+  }
+
+  parseVerdict(text) {
+    if (text.includes('[VERDICT]: APPROVED')) return 'APPROVED';
+    if (text.includes('[VERDICT]: REJECTED')) return 'REJECTED';
+    if (text.includes('[VERDICT]: AMENDED')) return 'AMENDED';
+    return 'UNKNOWN';
+  }
+}
+
+module.exports = AdversarialSRE;