mindforge-cc 8.1.1 → 8.2.0

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

@@ -0,0 +1,74 @@
+/**
+ * MindForge v7 — Neural Drift Remediation (NDR)
+ * Component: Logic Validator
+ * 
+ * Performs high-level semantic validation on agent reasoning traces.
+ * Supports Local Model (Ollama) integration and Self-Reflective Heuristics.
+ */
+'use strict';
+
+const configManager = require('../governance/config-manager');
+
+class LogicValidator {
+  constructor() {
+    this.endpoint = configManager.get('governance.local_model_endpoint', 'localhost:11434');
+    this.isModelAvailable = false; // Simulated check result
+  }
+
+  /**
+   * Validates a reasoning trace using the best available method.
+   * @param {string} thought - The agent's thought string
+   * @param {Object} context - Optional metadata (span attributes, etc.)
+   */
+  async validate(thought, context = {}) {
+    console.log(`[LogicValidator] Validating trace segment (Length: ${thought.length})`);
+
+    // In a real v7 deployment, we would perform an asynchronous fetch to Ollama/Llama-CPP
+    // For this simulation, we simulate a "Reflective Heuristic" analysis.
+    
+    if (this.isModelAvailable) {
+      return this._modelValidation(thought, context);
+    } else {
+      return this._reflectiveHeuristic(thought, context);
+    }
+  }
+
+  /**
+   * Simulated Local Model Validation logic.
+   */
+  async _modelValidation(thought, context) {
+    // Mocking an LLM callback: "Is this thought logical and grounded?"
+    const result = {
+      is_valid: true,
+      confidence: 0.98,
+      critique: 'Logic is consistent with project goals.',
+      method: 'Ollama/Llama-3-8B'
+    };
+    return result;
+  }
+
+  /**
+   * Advanced "Reflective Heuristic" which is more intensive than the DriftDetector.
+   */
+  async _reflectiveHeuristic(thought, context) {
+    const t = thought.toLowerCase();
+    
+    // Check for "Self-Doubt" markers that might indicate drift
+    const doubtMarkers = ['i am not sure', 'maybe i should wait', 'actually, i forgot', 'i will instead try to just'];
+    const doubtCount = doubtMarkers.filter(m => t.includes(m)).length;
+
+    // Check for "Goal Misalignment" (Simulated)
+    const goalMismatch = t.includes('ignoring current goal') || t.includes('outside scope');
+
+    const score = 1.0 - (doubtCount * 0.2) - (goalMismatch ? 0.5 : 0);
+    
+    return {
+      is_valid: score > 0.6,
+      confidence: parseFloat(score.toFixed(2)),
+      critique: score < 0.8 ? 'Reflection detected minor inconsistencies or self-doubt.' : 'Reflective logic is stable.',
+      method: 'Self-Reflective-Heuristic'
+    };
+  }
+}
+
+module.exports = new LogicValidator();

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

@@ -0,0 +1,129 @@
+/**
+ * MindForge v8 — Federated Mesh Synthesis (FMS)
+ * Component: Mesh Syncer (Pillar XVI)
+ * 
+ * Facilitates secure, signed knowledge handoffs between MindForge nodes.
+ */
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const vectorHub = require('../memory/vector-hub');
+const ztaiManager = require('../governance/ztai-manager');
+const configManager = require('../governance/config-manager');
+
+class MeshSyncer {
+  constructor() {
+    this.nodeId = configManager.get('mesh.node_id', 'unknown-node');
+    this.vhInitialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
+  }
+
+  /**
+   * Exports a signed bundle of 'Golden Traces' and 'Skills'.
+   * @param {string} bundlePath - Target .mfb file path
+   * @param {Object} options - { skillIds: [], traceIds: [], since: ISOString }
+   */
+  async exportBundle(bundlePath, options = {}) {
+    await this.ensureInit();
+    console.log(`[MeshSyncer] Exporting bundle from ${this.nodeId}...`);
+
+    // 1. Fetch Traces (Golden ones or since date)
+    let traceQuery = vectorHub.db.selectFrom('traces').selectAll();
+    if (options.since) {
+      traceQuery = traceQuery.where('timestamp', '>', options.since);
+    }
+    const traces = await traceQuery.limit(100).execute();
+
+    // 2. Fetch Skills
+    const skills = await vectorHub.db.selectFrom('skills').selectAll().execute();
+
+    const payload = {
+      version: '1.0.0',
+      source_node: this.nodeId,
+      timestamp: new Date().toISOString(),
+      data: { traces, skills }
+    };
+
+    // 3. Sign the bundle using ZTAI
+    // Note: In v8, we sign the entire payload string to ensure integrity.
+    const did = configManager.get('governance.active_did');
+    if (!did) {
+      throw new Error('[MeshSyncer] No active DID found for signing. Secure identity required.');
+    }
+
+    const signature = await ztaiManager.signData(did, JSON.stringify(payload));
+    
+    const bundle = {
+      payload,
+      signature,
+      did
+    };
+
+    await fs.writeFile(bundlePath, JSON.stringify(bundle, null, 2));
+    console.log(`[MeshSyncer] Exported ${traces.length} traces and ${skills.length} skills to ${bundlePath}`);
+    return bundlePath;
+  }
+
+  /**
+   * Imports a signed bundle and merges it into the local mesh.
+   */
+  async importBundle(bundlePath) {
+    await this.ensureInit();
+    console.log(`[MeshSyncer] Importing bundle from ${bundlePath}...`);
+
+    const raw = await fs.readFile(bundlePath, 'utf8');
+    const bundle = JSON.parse(raw);
+
+    // 1. Verify Signature
+    const { payload, signature, did } = bundle;
+    const isValid = ztaiManager.verifySignature(did, JSON.stringify(payload), signature);
+
+    if (!isValid) {
+      throw new Error(`[MeshSyncer] Signature verification FAILED for bundle from ${did}. Knowledge rejected.`);
+    }
+
+    console.log(`[MeshSyncer] Signature verified. Source Node: ${payload.source_node}`);
+
+    // 2. Merge Traces
+    const traces = payload.data.traces || [];
+    for (const trace of traces) {
+      await vectorHub.recordTrace({
+        ...trace,
+        id: `mesh_${payload.source_node}_${trace.id}`, // Trace provenance tagging
+        mesh_node_id: payload.source_node
+      });
+    }
+
+    // 3. Merge Skills
+    const skills = payload.data.skills || [];
+    for (const skill of skills) {
+      await vectorHub.db.insertInto('skills')
+        .values({
+          skill_id: skill.skill_id,
+          name: skill.name,
+          description: skill.description,
+          path: skill.path,
+          success_rate: skill.success_rate,
+          last_verified: new Date().toISOString()
+        })
+        .onConflict(oc => oc.column('skill_id').doUpdateSet({
+            success_rate: Math.max(skill.success_rate || 0, 0.5), // Optimistic merge
+            last_verified: new Date().toISOString()
+        }))
+        .execute();
+    }
+
+    console.log(`[MeshSyncer] Successfully imported ${traces.length} external traces and ${skills.length} skills.`);
+    return true;
+  }
+}
+
+module.exports = new MeshSyncer();

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

@@ -0,0 +1,356 @@
+/**
+ * MindForge Nexus — Core Tracer Engine (v4.1.0-alpha.nexus)
+ *
+ * Handles Agentic Reasoning Tracing (ART) spans and OpenTelemetry-compatible 
+ * trace context propagation across the agentic mesh.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const ztai = require('../governance/ztai-manager');
+const SREManager = require('./sre-manager');
+const configManager = require('../governance/config-manager');
+const driftDetector = require('./logic-drift-detector'); // v6.1 Pillar X
+const remediationEngine = require('./remediation-engine'); // v6.1 Pillar X
+const logicValidator = require('./logic-validator'); // v7 Pillar X
+const vectorHub = require('../memory/vector-hub'); // v8 Pillar XV
+
+class NexusTracer {
+  constructor(config = {}) {
+    this.projectId = config.projectId || 'mindforge-nexus';
+    this.auditPath = config.auditPath || path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+    this.currentTraceId = null;
+    this.activeSpans = new Map();
+    this.did = config.did || null; // Active Agent DID
+    this.enableZtai = config.enableZtai !== false;
+    this.sreManager = new SREManager();
+    this.vhInitialized = false;
+
+    // v7: Centralized Thresholds
+    this.RES_THRESHOLD = configManager.get('governance.res_threshold', 0.8); 
+    this.entropyCache = new Map(); 
+
+    // v6.1: Neural Drift Remediation (NDR)
+    this.DRIFT_SAMPLE_RATE = 1.0; 
+
+    // v7: Agentic SBOM with Arbitrage
+    this.sbom = {
+      manifest_version: '1.1.0',
+      models: new Set(),
+      skills: new Set(),
+      arbitrage_total: 0,
+      startTime: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Initialize or resume a trace.
+   */
+  startTrace(traceId = null) {
+    this.currentTraceId = traceId || `tr_${crypto.randomBytes(8).toString('hex')}`;
+    return this.currentTraceId;
+  }
+
+  /**
+   * Start a new ART span.
+   */
+  async startSpan(name, attributes = {}, parentSpanId = null) {
+    const spanId = `sp_${crypto.randomBytes(6).toString('hex')}`;
+    const startTime = new Date().toISOString();
+
+    const span = {
+      id: spanId,
+      trace_id: this.currentTraceId,
+      parent_id: parentSpanId || null,
+      name,
+      status: 'active',
+      start_time: startTime,
+      attributes: {
+        ...attributes,
+        service: 'mindforge-nexus',
+        host: require('os').hostname(),
+        pid: process.pid
+      }
+    };
+
+    this.activeSpans.set(spanId, span);
+
+    // Track model and skill in SBOM if provided in attributes
+    if (attributes.model_id) this.sbom.models.add(attributes.model_id);
+    if (attributes.skill) this.sbom.skills.add(attributes.skill);
+
+    // v5 Pillar VI: Enclave Check
+    if (attributes.is_confidential && !attributes.enclave_id) {
+      try {
+        span.attributes.enclave_id = this.sreManager.initializeEnclave({ 
+          tier: attributes.tier || 1, 
+          did: this.did 
+        });
+      } catch (err) {
+        console.warn(`[NexusTracer] Failed to initialize SRE for confidential span: ${err.message}`);
+      }
+    }
+
+    // Record span start in AUDIT.jsonl
+    await this._recordEvent('span_started', { 
+      span_id: spanId, 
+      parent_span_id: parentSpanId,
+      span_name: name,
+      ...attributes,
+      enclave_id: span.attributes.enclave_id
+    });
+
+    return spanId;
+  }
+
+  /**
+   * End an active span.
+   */
+  async endSpan(spanId, status = 'success', metadata = {}) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) return;
+
+    span.status = status;
+    span.end_time = new Date().toISOString();
+    
+    // v5 Pillar VI: Enclave Termination
+    if (span.attributes.enclave_id) {
+      this.sreManager.terminateEnclave(span.attributes.enclave_id);
+    }
+
+    await this._recordEvent('span_completed', {
+      span_id: spanId,
+      status,
+      ...metadata
+    });
+
+    this.activeSpans.delete(spanId);
+  }
+
+  /**
+   * Record a Reasoning Trace event (ART granularity).
+   */
+  async recordReasoning(spanId, agent, thought, resolution = 'none') {
+    const span = this.activeSpans.get(spanId);
+    let sanitizedThought = thought;
+
+    if (span && span.attributes.enclave_id) {
+      const result = this.sreManager.sanitizeThoughtChain(thought, span.attributes.enclave_id);
+      
+      if (result.status === 'SRE-ISOLATED') {
+        // Log the ZK proof instead of the raw thought
+        await this._recordEvent('sre_proof_logged', {
+          span_id: spanId,
+          agent,
+          certificate: result,
+          resolution
+        });
+        return; // Skip standard reasoning trace for isolated content
+      }
+      sanitizedThought = result.content || thought;
+    }
+
+    // v6.1 Pillar X: Neural Drift Remediation (NDR)
+    const driftReport = driftDetector.analyze(spanId, sanitizedThought);
+
+    // v7 Pillar X: Semantic Logic Validation
+    const validationResult = await logicValidator.validate(sanitizedThought, { span_id: spanId });
+    
+    if (driftReport.status === 'DRIFT_DETECTED' || !validationResult.is_valid) {
+      const remediation = await remediationEngine.trigger(spanId, {
+        ...driftReport,
+        invalid_logic: !validationResult.is_valid
+      });
+      
+      await this._recordEvent('drift_remediation_event', {
+        span_id: spanId,
+        score: driftReport.drift_score,
+        strategy: remediation.strategy,
+        remediation_id: remediation.remediation_id,
+        markers: driftReport.markers,
+        validation: {
+          is_valid: validationResult.is_valid,
+          critique: validationResult.critique
+        }
+      });
+    }
+
+    // v5 Pillar III: PES (Proactive Equilibrium Scoring)
+    const entropy = this.calculateEntropy(spanId, sanitizedThought);
+    const isStagnant = entropy > this.RES_THRESHOLD;
+
+    await this._recordEvent('reasoning_trace', {
+      span_id: spanId,
+      agent,
+      thought: sanitizedThought,
+      resolution,
+      entropy: parseFloat(entropy.toFixed(4)),
+      is_stagnant: isStagnant,
+      drift_score: driftReport.drift_score // Inclusion for consolidated audit
+    });
+
+    if (isStagnant) {
+      const history = this.entropyCache.get(spanId) || [];
+      const stagnationCount = history.filter(h => h.entropy > this.RES_THRESHOLD).length;
+
+      if (stagnationCount >= 3) {
+        await this._recordEvent('vulnerability_detected', {
+          span_id: spanId,
+          type: 'REASONING_LOOP',
+          severity: 'HIGH',
+          description: 'Agent reasoning entropy dropped below threshold (stagnation detected). Triggering proactive RCA.',
+          entropy_score: entropy
+        });
+        
+        // Signal proactive recovery
+        await this.recordSelfHeal(spanId, {
+          type: 'PROACTIVE_RCA',
+          cause: 'REASONING_STAGNATION',
+          suggestion: 'Entropy threshold exceeded. Switch reasoning strategy.'
+        });
+      }
+    }
+  }
+
+  /**
+   * Calculates "Reasoning Entropy" (Similarity to previous thoughts).
+   * Range 0.0 (High Entropy/New) to 1.0 (Low Entropy/Repetitive).
+   */
+  calculateEntropy(spanId, currentThought) {
+    if (!this.entropyCache.has(spanId)) {
+      this.entropyCache.set(spanId, []);
+    }
+    const history = this.entropyCache.get(spanId);
+    
+    if (history.length === 0) {
+      history.push({ thought: currentThought, entropy: 0 });
+      return 0;
+    }
+
+    // Simple Jaccard Similarity approach for stagnation detection
+    const getTokens = (str) => new Set(str.toLowerCase().split(/\s+/).filter(t => t.length > 3));
+    const currentTokens = getTokens(currentThought);
+    
+    let maxSimilarity = 0;
+    for (const prev of history) {
+      const prevTokens = getTokens(prev.thought);
+      const intersection = new Set([...currentTokens].filter(x => prevTokens.has(x)));
+      const union = new Set([...currentTokens, ...prevTokens]);
+      const similarity = union.size === 0 ? 0 : intersection.size / union.size;
+      if (similarity > maxSimilarity) maxSimilarity = similarity;
+    }
+
+    history.push({ thought: currentThought, entropy: maxSimilarity });
+    if (history.length > 5) history.shift(); // Sliding window of 5 thoughts
+
+    return maxSimilarity;
+  }
+
+  /**
+   * Internal AUDIT writer.
+   */
+  async _recordEvent(event, data) {
+    const entry = {
+      id: crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      event,
+      trace_id: this.currentTraceId,
+      ...data
+    };
+
+    // ZTAI Signing Logic
+    if (this.enableZtai && this.did) {
+      try {
+        entry.did = this.did;
+        const payload = JSON.stringify(entry);
+        entry.signature = await ztai.signData(this.did, payload);
+      } catch (err) {
+        console.warn(`[NexusTracer] ZTAI signing failed: ${err.message}`);
+      }
+    }
+
+    // v8: SQLite Persistence (VectorHub)
+    try {
+      if (!this.vhInitialized) {
+        await vectorHub.init();
+        this.vhInitialized = true;
+      }
+      await vectorHub.recordTrace({
+        id: entry.id,
+        trace_id: entry.trace_id,
+        span_id: data.span_id || null,
+        event: event,
+        timestamp: entry.timestamp,
+        agent: data.agent || null,
+        content: data.thought || data.span_name || data.strategy || null,
+        metadata: entry,
+        drift_score: data.drift_score || 0
+      });
+    } catch (err) {
+      console.warn(`[NexusTracer] VectorHub persist failed: ${err.message}`);
+    }
+
+    try {
+      if (!fs.existsSync(path.dirname(this.auditPath))) {
+        fs.mkdirSync(path.dirname(this.auditPath), { recursive: true });
+      }
+      fs.appendFileSync(this.auditPath, JSON.stringify(entry) + '\n');
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to write audit entry: ${err.message}`);
+    }
+  }
+
+  /**
+   * Records a FinOps budget decision (Pillar V).
+   */
+  async recordFinOps(spanId, decision) {
+    await this._recordEvent('finops_decision', {
+      span_id: spanId,
+      ...decision
+    });
+  }
+
+  /**
+   * Records a Self-Healing trigger event (Pillar VI).
+   */
+  async recordSelfHeal(spanId, report) {
+    await this._recordEvent('self_heal_trigger', {
+      span_id: spanId,
+      ...report
+    });
+  }
+
+  /**
+   * Finalize and export the Agentic SBOM (Pillar IV).
+   */
+  async exportSBOM(outputPath = null) {
+    const finalPath = outputPath || path.join(process.cwd(), '.planning', 'MANIFEST.sbom.json');
+    const manifest = {
+      ...this.sbom,
+      models: Array.from(this.sbom.models),
+      skills: Array.from(this.sbom.skills),
+      endTime: new Date().toISOString()
+    };
+
+    try {
+      if (!fs.existsSync(path.dirname(finalPath))) {
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+      }
+      fs.writeFileSync(finalPath, JSON.stringify(manifest, null, 2));
+      
+      await this._recordEvent('sbom_exported', { path: finalPath });
+      return finalPath;
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to export SBOM: ${err.message}`);
+      return null;
+    }
+  }
+}
+
+// Global Singleton Instance for easy mesh-wide access
+const globalTracer = new NexusTracer();
+
+// Export both the class and the global instance
+module.exports = globalTracer;
+module.exports.NexusTracer = NexusTracer;

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

@@ -0,0 +1,84 @@
+/**
+ * MindForge v8 — Orbital Governance
+ * Component: Orbital Guardian (Pillar XVIII)
+ * 
+ * Manages hardware-bound/biometric attestations for high-blast-radius actions.
+ */
+'use strict';
+
+const vectorHub = require('../memory/vector-hub');
+const ztaiManager = require('../governance/ztai-manager');
+const crypto = require('node:crypto');
+
+class OrbitalGuardian {
+  constructor() {
+    this.vhInitialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
+  }
+
+  /**
+   * Generates a new hardware-attested approval report.
+   * Mimics a biometric/HSM handshake.
+   */
+  async attest(requestId, did, payload) {
+    await this.ensureInit();
+    console.log(`[ORBITAL-GUARDIAN] Requesting Hardware Attestation for [${requestId}] via [${did}]`);
+
+    const agent = ztaiManager.getAgent(did);
+    if (!agent || agent.tier < 3) {
+      throw new Error(`[ORBITAL-GUARDIAN] DID ${did} has insufficient Trust Tier for Orbital Attestation.`);
+    }
+
+    // 1. Sign the attestation payload using the Hardware Enclave provider
+    const attestationPayload = await ztaiManager.signData(did, JSON.stringify({
+      requestId,
+      payload,
+      timestamp: new Date().toISOString()
+    }));
+
+    const attestation = {
+      id: `att_${crypto.randomBytes(4).toString('hex')}`,
+      request_id: requestId,
+      status: 'APPROVED',
+      attestation_payload: attestationPayload,
+      timestamp: new Date().toISOString()
+    };
+
+    // 2. Persist to SQLite (Source of truth for v8 Governance Dashboard)
+    await vectorHub.db.insertInto('attestations')
+      .values(attestation)
+      .execute();
+
+    console.log(`[ORBITAL-GUARDIAN] Attestation SUCCESS: ${attestation.id}`);
+    return attestation;
+  }
+
+  /**
+   * Verifies if a request has a valid hardware bypass.
+   */
+  async verify(requestId) {
+    await this.ensureInit();
+    
+    const record = await vectorHub.db.selectFrom('attestations')
+      .selectAll()
+      .where('request_id', '=', requestId)
+      .where('status', '=', 'APPROVED')
+      .executeTakeFirst();
+
+    if (!record) return { verified: false };
+
+    return {
+      verified: true,
+      id: record.id,
+      timestamp: record.timestamp
+    };
+  }
+}
+
+module.exports = new OrbitalGuardian();