mindforge-cc 8.2.0 → 9.0.0

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

@@ -1,74 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/**
- * 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

@@ -1,356 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 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();