mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/reason-source-aligner.js

@@ -1,111 +0,0 @@
-/**
- * MindForge v6.5.0 — Reason-Source Alignment (RSA)
- * Component: Reason Source Aligner (Pillar XII)
- * 
- * Ensures mission fidelity by cross-referencing reasoning thoughts 
- * with the Requirements Registry ([REQ-ID]).
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-class ReasonSourceAligner {
-  constructor(reqPath = '.planning/REQUIREMENTS.md') {
-    this.requirementsPath = path.resolve(process.cwd(), reqPath);
-    this.registry = [];
-    this.ALIGNMENT_THRESHOLD = 0.60; // Mission fidelity floor
-    this.initialized = false;
-  }
-
-  /**
-   * Initializes the aligner by parsing the REQUIREMENTS.md file.
-   */
-  async init() {
-    if (this.initialized) return;
-    
-    try {
-      if (!fs.existsSync(this.requirementsPath)) {
-        console.warn(`[RSA] Requirements file not found at ${this.requirementsPath}`);
-        return;
-      }
-
-      const content = fs.readFileSync(this.requirementsPath, 'utf8');
-      this.registry = this._parseRequirements(content);
-      this.initialized = true;
-      console.log(`[RSA] Loaded ${this.registry.length} requirements into registry.`);
-    } catch (err) {
-      console.error('[RSA] Initialization failed:', err);
-    }
-  }
-
-  /**
-   * Checks if a thought aligns with any requirement.
-   * @param {string} thought - The reasoning thought to check.
-   * @returns {Object} - Alignment results.
-   */
-  checkAlignment(thought) {
-    if (!this.initialized) return { score: 1.0, reason: 'uninitialized' }; // Fail-safe stable
-
-    const alignmentScores = this.registry.map(req => {
-      const score = this._calculateSimilarity(thought, req.summary + ' ' + req.description);
-      return { id: req.id, score };
-    });
-
-    const bestMatch = alignmentScores.sort((a, b) => b.score - a.score)[0];
-
-    return {
-      is_aligned: bestMatch ? bestMatch.score > 0.25 : false, // Sparse mapping allowed
-      best_match_id: bestMatch ? bestMatch.id : null,
-      confidence: bestMatch ? parseFloat(bestMatch.score.toFixed(4)) : 0,
-    };
-  }
-
-  /**
-   * Parses Markdown requirements into JSON structure.
-   */
-  _parseRequirements(markdown) {
-    const registry = [];
-    // v6.5.0 Hardened: Handles optional blank lines between header and body
-    const regex = /## \[([\w-]+)\] (.*?)\n\n?([\s\S]*?)(?=\n+## |$)/g;
-    let match;
-
-    while ((match = regex.exec(markdown)) !== null) {
-      registry.push({
-        id: match[1],
-        summary: match[2].trim(),
-        description: match[3].trim()
-      });
-    }
-
-    return registry;
-  }
-
-  /**
-   * Similarity Heuristic (Keyword-based overlap)
-   */
-  _calculateSimilarity(a, b) {
-    const getTokens = (str) => new Set(str.toLowerCase().replace(/[^\w\s]/g, '').split(/\s+/).filter(t => t.length > 3));
-    const tokensA = getTokens(a);
-    const tokensB = getTokens(b);
-    
-    if (tokensA.size === 0 || tokensB.size === 0) return 0;
-    
-    const intersection = new Set([...tokensA].filter(x => tokensB.has(x)));
-    const union = new Set([...tokensA, ...tokensB]);
-    
-    return intersection.size / tokensA.size; // Weighted by thought coverage
-  }
-
-  /**
-   * Retrieves the full details of a specific requirement by ID.
-   * Useful for v6.6.0 SCS self-healing synthesis.
-   * @param {string} reqId 
-   */
-  getRequirementDetails(reqId) {
-    if (!this.initialized) return null;
-    return this.registry.find(req => req.id === reqId) || null;
-  }
-}
-
-module.exports = new ReasonSourceAligner();

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

@@ -1,81 +0,0 @@
-/**
- * MindForge v6.1.0-alpha — Neural Drift Remediation (NDR)
- * Component: Remediation Engine (Pillar X)
- * 
- * Triggers corrective actions when logic drift or reasoning 
- * stagnation is detected.
- */
-'use strict';
-
-const remediationQueue = require('../revops/remediation-queue');
-const logicValidator = require('./logic-validator');
-const semanticHub = require('../memory/semantic-hub');
-
-class RemediationEngine {
-  constructor() {
-    this.activeRemediations = new Set();
-  }
-
-  /**
-   * Triggers a specific remediation workflow.
-   * @param {string} spanId 
-   * @param {Object} report - From LogicDriftDetector
-   */
-  async trigger(spanId, report) {
-    const { drift_score, markers } = report;
-    let strategy = 'NOT_REQUIRED';
-
-    // Tiered Remediation Logic
-    if (drift_score > 0.9) strategy = 'REASONING_RESTART';
-    else if (drift_score > 0.8 || report.invalid_logic) strategy = 'GOLDEN_TRACE_INJECTION';
-    else if (drift_score > 0.75) strategy = 'CONTEXT_COMPRESSION';
-
-    if (strategy === 'NOT_REQUIRED') return { status: 'STABLE', strategy };
-
-    const action = {
-      span_id: spanId,
-      strategy,
-      remediation_id: `rem_${Math.random().toString(36).substr(2, 6)}`,
-      timestamp: new Date().toISOString(),
-      effectiveness_prediction: 0.85
-    };
-
-    console.log(`[Remediation] Triggered ${strategy} for ${spanId} (Score: ${drift_score})`);
-    
-    // v7: Finalize with Stateful Queueing
-    await remediationQueue.enqueue(action);
-
-    // Mock implementation of remediation execution
-    this._executeStrategy(strategy, spanId);
-
-    return action;
-  }
-
-  /**
-   * functional implementation of remediation strategies.
-   */
-  async _executeStrategy(strategy, spanId) {
-    switch(strategy) {
-      case 'REASONING_RESTART':
-        console.log(`[Remediation] Forcing reasoner reset for ${spanId}`);
-        // Logic to clear local thought window for span
-        break;
-      case 'GOLDEN_TRACE_INJECTION':
-        console.log(`[Remediation] Injecting successful trace heuristics into ${spanId}`);
-        const traces = await semanticHub.getGoldenTraces();
-        if (traces.length > 0) {
-           const bestTrace = traces[0];
-           console.log(`[Remediation] Injected Golden Trace: ${bestTrace.id} (Skill: ${bestTrace.skill})`);
-        } else {
-           console.warn(`[Remediation] No Golden Traces found in SemanticHub for injection.`);
-        }
-        break;
-    }
-  }
-
-  getActiveRemediations() {
-    return Array.from(this.activeRemediations);
-  }
-}
-
-module.exports = new RemediationEngine();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/self-corrective-synthesizer.js

@@ -1,65 +0,0 @@
-/**
- * MindForge v6.6.0 — Self-Corrective Synthesis (SCS)
- * Component: Self-Corrective Synthesizer (Pillar XII)
- * 
- * Analyzes mission drift and logic stagnation to synthesize 
- * corrective steering signals (Homing Instructions).
- */
-'use strict';
-
-const rsa = require('./reason-source-aligner.js');
-
-class SelfCorrectiveSynthesizer {
-  constructor() {
-    this.historyLimit = 10;
-    this.synthesisCount = 0;
-  }
-
-  /**
-   * Evaluates a suboptimal state and generates a corrective thought.
-   * @param {Array} auditTrail - Recent audit events.
-   * @param {Object} context - Current execution context.
-   */
-  async synthesizeCorrection(auditTrail, context) {
-    console.log('[SCS] Critical drift detected. Initiating internal alignment pass...');
-    
-    // 1. Identify failure points
-    const failureEvents = auditTrail.slice(-this.historyLimit).filter(e => 
-      e.type === 'mission_fidelity' && e.alignment.confidence < 0.50
-    );
-
-    if (failureEvents.length === 0) {
-      return this._generateGenericRefocus(context);
-    }
-
-    // 2. Map to primary target requirement
-    const targetId = failureEvents[0].alignment.best_match_id;
-    const requirement = rsa.getRequirementDetails(targetId);
-
-    if (!requirement) {
-      return this._generateGenericRefocus(context);
-    }
-
-    // 3. Synthesize the "Homing Signal"
-    this.synthesisCount++;
-    const correction = {
-      type: 'scs_refocus',
-      req_id: targetId,
-      instruction: `[SCS-REFOCUS] Targeting [${targetId}]: ${requirement.summary}. Action: Resuming strict alignment with core requirement: ${requirement.description.split('\n')[0]}`,
-      confidence: 0.98
-    };
-
-    console.log(`[SCS] Synthesis complete. Correction targeted at ${targetId}.`);
-    return correction;
-  }
-
-  _generateGenericRefocus(context) {
-    return {
-      type: 'scs_refocus',
-      instruction: '[SCS-GENERAL-HOMING] Reasoning drift detected. I am resetting my internal thought buffer and re-reading the project constitution to ensure mission fidelity.',
-      confidence: 0.85
-    };
-  }
-}
-
-module.exports = new SelfCorrectiveSynthesizer();

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

@@ -1,105 +0,0 @@
-/**
- * MindForge v8 — Autonomous Skill Evolution (ASE)
- * Component: Skill Evolver (Pillar XVII)
- * 
- * Mines successful reasoning patterns to synthesize new reusable skills.
- */
-'use strict';
-
-const vectorHub = require('../memory/vector-hub');
-const semanticHub = require('../memory/semantic-hub');
-const configManager = require('../governance/config-manager');
-const crypto = require('node:crypto');
-
-class SkillEvolver {
-  constructor() {
-    this.vhInitialized = false;
-    this.threshold = configManager.get('ase.max_drift_threshold', 0.1);
-    this.minCount = configManager.get('ase.min_success_count', 3);
-  }
-
-  async ensureInit() {
-    if (!this.vhInitialized) {
-      await vectorHub.init();
-      this.vhInitialized = true;
-    }
-  }
-
-  /**
-   * Main evolution loop.
-   */
-  async evolve() {
-    await this.ensureInit();
-    console.log('[ASE] Starting skill evolution cycle...');
-
-    // 1. Mine Golden Traces (Drift < 0.1)
-    const goldenTraces = await vectorHub.db.selectFrom('traces')
-      .selectAll()
-      .where('drift_score', '<', this.threshold)
-      .where('event', '=', 'reasoning_trace')
-      .execute();
-
-    if (goldenTraces.length < this.minCount) {
-      console.log(`[ASE] Only ${goldenTraces.length} golden traces found. Threshold is ${this.minCount}. Evolution deferred.`);
-      return [];
-    }
-
-    // 2. Identify Patterns (Group by shared agent + metadata intent)
-    const candidates = this._clusterTraces(goldenTraces);
-    const evolvedSkills = [];
-
-    for (const cluster of candidates) {
-      if (cluster.traces.length >= this.minCount) {
-        const skill = await this._synthesize(cluster);
-        await semanticHub.saveSkill(skill);
-        evolvedSkills.push(skill);
-      }
-    }
-
-    console.log(`[ASE] Evolution complete. Synthesized ${evolvedSkills.length} new skills.`);
-    return evolvedSkills;
-  }
-
-  /**
-   * Internal heuristic for clustering similar reasoning spans.
-   */
-  _clusterTraces(traces) {
-    const clusters = new Map();
-
-    for (const t of traces) {
-      const metadata = JSON.parse(t.metadata || '{}');
-      // Group by agent and the first 20 chars of thought as a simple proxy for 'intent'
-      const key = `${t.agent || 'unknown'}:${t.content.substring(0, 20)}`;
-      
-      if (!clusters.has(key)) {
-        clusters.set(key, { traces: [], agent: t.agent, intent: t.content.substring(0, 50) });
-      }
-      clusters.get(key).traces.push(t);
-    }
-
-    return Array.from(clusters.values());
-  }
-
-  /**
-   * Synthesize a skill from a cluster of successful traces.
-   */
-  async _synthesize(cluster) {
-    const id = `ev_${crypto.randomBytes(4).toString('hex')}`;
-    const timestamp = new Date().toISOString();
-    
-    // Abstract the strategy from the trace content
-    const summary = cluster.traces.map(t => `- ${t.content}`).join('\n');
-    
-    return {
-      id,
-      name: `Synthesized Skill (${cluster.agent}) - ${id}`,
-      description: `Autonomous adaptation from ${cluster.traces.length} successful golden traces.\nPatterns identified:\n${summary}`,
-      success_rate: 1.0, // Initial confidence is high due to mining golden traces
-      is_autonomous: true,
-      source_trace_id: cluster.traces[0].trace_id,
-      path: `ase/evolved/${id}.skill.md`
-    };
-  }
-}
-
-module.exports = new SkillEvolver();

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

@@ -1,117 +0,0 @@
-/**
- * MindForge — SREManager (Pillar VI: Sovereign Reason Enclaves)
- * Manages confidential reasoning sessions in simulated Trusted Execution Environments (TEE).
- */
-'use strict';
-
-const crypto = require('crypto');
-
-// Simulated System DID for Enclave Proofs (Tier 3)
-const ENCLAVE_PRIVATE_KEY = 'tier3-enclave-secret-key-sim'; // In production, this would be a TEE-bound private key
-const SYSTEM_DID = 'did:mindforge:enclave:0xenterprise';
-
-class SREManager {
-  constructor() {
-    this.activeEnclaves = new Map();
-  }
-
-  /**
-   * Initializes a Sovereign Reason Enclave for a task.
-   * @param {Object} context - Task context (requires Tier 3 identity)
-   * @returns {string} - Enclave ID
-   */
-  initializeEnclave(context) {
-    if (context.tier < 3) {
-      throw new Error(`[SRE-DENY] Tier ${context.tier} principal is not authorized for Sovereign Reason Enclaves.`);
-    }
-
-    const enclaveId = crypto.randomBytes(12).toString('hex');
-    this.activeEnclaves.set(enclaveId, {
-      startedAt: new Date().toISOString(),
-      principal: context.did,
-      hasIP: true,
-      isolationLevel: 'Hardware-Enclave (Simulated)',
-      cumulativeHash: null // Root of the proof chain
-    });
-
-    console.log(`[SRE-INIT] Initialized Sovereign Reason Enclave: ${enclaveId} for ${context.did}`);
-    return enclaveId;
-  }
-
-  /**
-   * Sanitizes a thought chain and generates a ZK-Proof Compliance Certificate.
-   * Ensures that sensitive IP or "zero-visibility" thoughts are isolated while proving audit-eligibility.
-   * @param {string} thoughtChain - The raw agentic thought chain.
-   * @param {string} enclaveId - The active enclave ID.
-   * @param {Object} policyResult - Whether the content passed internal policy checks.
-   * @returns {Object} - ZK-Proof compliance certificate.
-   */
-  sanitizeThoughtChain(thoughtChain, enclaveId, policyResult = { passed: true }) {
-    if (!this.activeEnclaves.has(enclaveId)) {
-      return { status: 'PLAINTEXT', content: thoughtChain };
-    }
-
-    // v5 Pillar VI: Merkle-style Cumulative Hash Chain
-    const enclaveData = this.activeEnclaves.get(enclaveId);
-    const prevHash = enclaveData.cumulativeHash;
-    const digest = crypto.createHash('sha256').update(thoughtChain).digest('hex');
-    
-    // Generate a simulated ZK-Proof Compliance Certificate
-    const proofPayload = {
-      enclaveId: enclaveId,
-      digest: digest,
-      prevHash: prevHash, // Links the chain
-      policyPassed: policyResult.passed,
-      timestamp: new Date().toISOString(),
-      principal: enclaveData.principal
-    };
-
-    // Sign the proof with the Enclave Private Key
-    const signature = crypto.createHmac('sha256', ENCLAVE_PRIVATE_KEY)
-      .update(JSON.stringify(proofPayload))
-      .digest('hex');
-
-    // Update the cumulative hash for the next block
-    const proofHash = crypto.createHash('sha256').update(signature).digest('hex');
-    enclaveData.cumulativeHash = proofHash;
-
-    const certificate = {
-      status: 'SRE-ISOLATED',
-      proof: proofPayload,
-      signature: signature,
-      proofHash: proofHash,
-      verificationDid: SYSTEM_DID,
-      message: `[SRE-ZK-PROOF] Confidential reasoning (sha256:${digest.substring(0, 8)}...) verified by Enclave Auditor.`
-    };
-
-    return certificate;
-  }
-
-  /**
-   * Verifies an SRE Compliance Certificate without seeing the original content.
-   */
-  verifyZKProof(certificate) {
-    if (certificate.status !== 'SRE-ISOLATED') return false;
-
-    const expectedSignature = crypto.createHmac('sha256', ENCLAVE_PRIVATE_KEY)
-      .update(JSON.stringify(certificate.proof))
-      .digest('hex');
-
-    const isValid = (expectedSignature === certificate.signature);
-    const policyPassed = certificate.proof.policyPassed;
-
-    return isValid && policyPassed;
-  }
-
-  /**
-   * Finalizes and purges the enclave.
-   */
-  terminateEnclave(enclaveId) {
-    if (this.activeEnclaves.has(enclaveId)) {
-      this.activeEnclaves.delete(enclaveId);
-      console.log(`[SRE-PURGE] Sovereign Reason Enclave ${enclaveId} has been securely purged.`);
-    }
-  }
-}
-
-module.exports = SREManager;

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

@@ -1,52 +0,0 @@
-/**
- * MindForge v3 — Temporal CLI
- * Command-line interface for managing history and hindsight.
- */
-'use strict';
-
-const TemporalHub = require('./temporal-hub');
-const HindsightInjector = require('../hindsight-injector');
-
-const ARGS = process.argv.slice(2);
-const SUBCOMMAND = ARGS[0];
-
-async function main() {
-  switch (SUBCOMMAND) {
-    case 'status':
-      const history = TemporalHub.getHistory();
-      console.log('\n⏳  MindForge Temporal Status');
-      console.log(`    Snapshots:  ${history.length}`);
-      if (history.length > 0) {
-        console.log(`    Latest:     ${history[0].id} (${history[0].timestamp})`);
-      }
-      break;
-
-    case 'cleanup':
-      console.log('🧹 Cleaning up old temporal snapshots...');
-      // Logic for cleanup (e.g., keep last 100)
-      console.log('✅ Cleanup complete.');
-      break;
-
-    case 'inject':
-      const auditId = ARGS[1];
-      const fix = ARGS.slice(2).join(' ');
-      if (!auditId || !fix) {
-        console.error('Usage: /mindforge:temporal inject <auditId> <fix description>');
-        process.exit(1);
-      }
-      const result = await HindsightInjector.inject(auditId, fix);
-      if (result.success) {
-        console.log(`✅ Hindsight injected. Event ID: ${result.event.id}`);
-      } else {
-        console.error(`❌ Injection failed: ${result.error}`);
-        process.exit(1);
-      }
-      break;
-
-    default:
-      console.log('Usage: /mindforge:temporal <status|cleanup|inject>');
-      break;
-  }
-}
-
-main();

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

@@ -1,115 +0,0 @@
-/**
- * MindForge — TemporalHindsight (Pillar VI: Proactive Equilibrium)
- * Performs automated RCA and generates repair plans for diverging waves.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class TemporalHindsight {
-  constructor(config = {}) {
-    this.projectRoot = config.projectRoot || process.cwd();
-    this.historyLimit = config.historyLimit || 10; // Analyze last 10 failed tasks
-  }
-
-  /**
-   * Performs Root Cause Analysis (RCA) on a failed wave.
-   * @param {Object} waveReport - Current wave results (failed tasks, logs)
-   * @returns {Object} - Diagnosis and Repair Plan
-   */
-  async analyze(waveReport) {
-    const { failedTasks, divergence, phase } = waveReport;
-    const diagnosis = this.diagnoseFailures(failedTasks);
-    
-    return {
-      timestamp: new Date().toISOString(),
-      phase,
-      divergence,
-      diagnosis,
-      repairPlan: this.generateRepairPlan(diagnosis, phase),
-    };
-  }
-
-  /**
-   * Diagnoses common failure patterns in agentic workloads.
-   */
-  diagnoseFailures(tasks) {
-    const errorMessages = tasks.map(t => t.error || '').join(' ').toLowerCase();
-    
-    if (errorMessages.includes('permission denied') || errorMessages.includes('eacces')) {
-      return { type: 'ENVIRONMENTAL', cause: 'File system permission issues detected in multiple tasks.', severity: 'CRITICAL' };
-    }
-    
-    if (errorMessages.includes('timeout') || errorMessages.includes('deadline exceeded')) {
-      return { type: 'RESOURCE', cause: 'Wave execution timeout. Tasks are too large or the model response is slow.', severity: 'HIGH' };
-    }
-    
-    if (errorMessages.includes('lint') || errorMessages.includes('syntax error')) {
-      return { type: 'LOGIC', cause: 'Cumulative coding errors. The existing plan is producing invalid syntax consistently.', severity: 'STRICT' };
-    }
-
-    return { type: 'UNKNOWN', cause: 'Generic wave divergence. Multiple unrelated failures detected.', severity: 'MEDIUM' };
-  }
-
-  /**
-   * Generates a "Self-Healing" Plan.md entry.
-   */
-  generateRepairPlan(diagnosis, phase) {
-    const steps = [];
-    
-    switch (diagnosis.type) {
-      case 'ENVIRONMENTAL':
-        steps.push('PAUSE execution immediately.');
-        steps.push('Run `chmod -R u+w .` (simulated) on the affected directories.');
-        steps.push('Re-verify task 0.1 before resuming the wave.');
-        break;
-      case 'RESOURCE':
-        steps.push('PAUSE execution and increase `taskTimeoutMs` by 50%.');
-        steps.push('Request `EXECUTOR_MODEL` upgrade to `claude-3-opus` for complex tasks.');
-        steps.push('Serialise the next wave (concurrency = 1) to reduce resource contention.');
-        break;
-      case 'LOGIC':
-        steps.push('STOP active wave.');
-        steps.push('Rewrite Sub-tasks in PLAN.md for Phase ' + phase + ' with stricter TDD requirements.');
-        steps.push('Inject `Quality-Auditor` persona into the review loop.');
-        break;
-      default:
-        steps.push('PAUSE and request human review for divergence RCA.');
-    }
-    
-    return {
-      title: `AUTONOMOUS REPAIR PLAN: PHASE ${phase}`,
-      steps,
-      autoApplyStatus: 'PENDING_SIGNATURE',
-    };
-  }
-
-  /**
-   * v5 Pillar III: Proactive Loop Recovery
-   * Generates a "Steering Vector" to break agentic Reasoning Stagnation.
-   */
-  handleProactiveRecovery(traceId, entropyScore) {
-    console.log(`[TemporalHindsight] Proactive Recovery triggered for trace ${traceId} (Entropy: ${entropyScore})`);
-    
-    const steeringVectors = [
-      'CRITICAL: Stagnation detected. You have repeated similar reasoning steps 3 times. STOP your current approach and decompose the problem into smaller, independent sub-tasks.',
-      'STATIONARY LOOP: Your recent thoughts show high similarity. Change your technical layer—if you were editing code, try running a diagnostic command instead.',
-      'REASONING DEADLOCK: Entropy too low. Request human intervention or switch to the \'Architect\' persona to re-evaluate the plan.',
-      'DIVERGENCE ALERT: Proactive reset. Clear your context window of the last 3 reasoning steps and start fresh from the last successful checkpoint.'
-    ];
-
-    // Pick a vector based on entropy severity
-    const index = Math.min(Math.floor(entropyScore * steeringVectors.length), steeringVectors.length - 1);
-    
-    return {
-      timestamp: new Date().toISOString(),
-      trace_id: traceId,
-      event: 'STEERING_VECTOR_GENERATED',
-      entropy: entropyScore,
-      instruction: steeringVectors[index],
-      action: 'INJECT_SYSTEM_PROMPT'
-    };
-  }
-}
-
-module.exports = TemporalHindsight;