mindforge-cc 3.0.0 → 5.0.0

package/bin/models/cloud-broker.js

@@ -0,0 +1,83 @@
+/**
+ * MindForge — CloudBroker (Pillar V: Multi-Cloud Arbitrage & Hedging)
+ * Dynamically routes tasks across multiple cloud providers (Vertex, Bedrock, Azure).
+ */
+'use strict';
+
+class CloudBroker {
+  constructor(config = {}) {
+    this.providers = config.providers || ['anthropic', 'google', 'aws', 'azure'];
+    this.state = {
+      'anthropic': { latency: 450, costMultiplier: 1.0, healthy: true },
+      'google': { latency: 600, costMultiplier: 0.85, healthy: true },
+      'aws': { latency: 550, costMultiplier: 0.95, healthy: true },
+      'azure': { latency: 650, costMultiplier: 1.1, healthy: true }
+    };
+  }
+
+  /**
+   * Selects the optimal provider based on weighted latency and cost.
+   * @param {Object} options - Task requirements (maxLatency, budgetConstraint)
+   * @returns {string} - Best provider ID
+   */
+  getBestProvider(requirements = {}) {
+    const scored = Object.entries(this.state)
+      .filter(([_, data]) => data.healthy)
+      .map(([id, data]) => {
+        // Score = (Latency * 0.4) + (Cost * 0.6) — Lower is better
+        const score = (data.latency * 0.4) + (data.costMultiplier * 1000 * 0.6);
+        return { id, score };
+      });
+
+    scored.sort((a, b) => a.score - b.score);
+    return scored[0]?.id || 'anthropic';
+  }
+
+  /**
+   * Implements the Provider Fallback Protocol.
+   * Switches to the "Shadow Model" on the next best healthy provider.
+   * @param {string} failedProvider - The provider that just failed
+   * @returns {string} - Fallback provider ID
+   */
+  getFallbackProvider(failedProvider) {
+    if (this.state[failedProvider]) {
+      this.state[failedProvider].healthy = false;
+    }
+
+    const fallback = Object.entries(this.state)
+      .filter(([id, data]) => id !== failedProvider && data.healthy)
+      .sort((a, b) => a[1].latency - b[1].latency)[0];
+
+    return fallback ? fallback[0] : 'google'; // Default fallback
+  }
+
+  /**
+   * Retrieves provider-specific model mapping.
+   * @param {string} provider - Provider ID
+   * @param {string} modelGroup - e.g., 'sonnet', 'opus', 'haiku'
+   */
+  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', 'opus': 'gemini-1.5-pro', 'haiku': 'gemini-1.5-flash' },
+      'aws': { 'sonnet': 'anthropic.claude-3-5-sonnet-v2:0', 'opus': 'anthropic.claude-3-opus-v1:0', 'haiku': 'anthropic.claude-3-haiku-v1:0' },
+      'azure': { 'sonnet': 'gpt-4o', 'opus': 'gpt-4-turbo', 'haiku': 'gpt-35-turbo' }
+    };
+
+    return mappings[provider]?.[modelGroup] || mappings[provider]?.['sonnet'];
+  }
+
+  /**
+   * Hardening: Simulate provider failures to verify Fallback Protocol.
+   */
+  startChaosMode() {
+    console.log('[BEAST-MODE] CloudBroker Chaos Mode ACTIVE. Simulating jitter and provider dropouts...');
+    setInterval(() => {
+      const providers = Object.keys(this.latencyMap);
+      const randomProvider = providers[Math.floor(Math.random() * providers.length)];
+      this.latencyMap[randomProvider] = Math.random() > 0.7 ? 5000 : 100; // Spike latency
+    }, 10000);
+  }
+}
+
+module.exports = CloudBroker;

package/bin/models/finops-hub.js

@@ -0,0 +1,79 @@
+/**
+ * MindForge — FinOps Hub (Pillar V: Autonomous FinOps Hub)
+ * Enterprise-grade monitoring and budget enforcement for agentic workloads.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class FinOpsHub {
+  constructor(config = {}) {
+    this.projectRoot = config.projectRoot || process.cwd();
+    this.budgetLimit = config.budgetLimit || 100.00; // $100.00 USD Default
+    this.monthlyUsage = 0.00;
+  }
+
+  /**
+   * Initializes the FinOps state and budget monitoring.
+   */
+  async init() {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    if (fs.existsSync(roiPath)) {
+      const logs = fs.readFileSync(roiPath, 'utf8').split('\n').filter(Boolean);
+      logs.forEach(line => {
+        try {
+          const entry = JSON.parse(line);
+          this.monthlyUsage += entry.estimatedCostUSD || 0;
+        } catch (e) {
+          // Skip malformed lines
+        }
+      });
+    }
+  }
+
+  /**
+   * Checks if the task is within budget constraints.
+   * @param {Object} task - Task details (difficulty, priority)
+   * @returns {Object} - Budget check result (status, reasoning)
+   */
+  checkBudget(task) {
+    if (this.monthlyUsage >= this.budgetLimit) {
+      return { status: 'DENIED', reason: `Monthly budget limit ($${this.budgetLimit}) reached.` };
+    }
+
+    if (this.monthlyUsage >= this.budgetLimit * 0.9) {
+      return { status: 'WARNING', reason: `Project has consumed 90% of the allocated budget ($${this.monthlyUsage.toFixed(2)} / $${this.budgetLimit.toFixed(2)}).` };
+    }
+
+    return { status: 'APPROVED', usage: this.monthlyUsage };
+  }
+
+  /**
+   * Generates a "Spending Profile" for the project.
+   * Used for the Nexus Dashboard to visualize ROI.
+   */
+  getSpendingProfile() {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    if (!fs.existsSync(roiPath)) return { totalSpend: 0, goalsAchieved: 0, roi: 0 };
+
+    const logs = fs.readFileSync(roiPath, 'utf8').split('\n').filter(Boolean).map(JSON.parse);
+    const totalSpend = logs.reduce((acc, l) => acc + (l.estimatedCostUSD || 0), 0);
+    const goalsAchieved = logs.reduce((acc, l) => acc + (l.goalAchieved || 0), 0);
+
+    return {
+      totalSpend: totalSpend.toFixed(2),
+      goalsAchieved,
+      roi: totalSpend > 0 ? (goalsAchieved / totalSpend).toFixed(2) : 0,
+      tokenEfficiency: logs.length > 0 ? (totalSpend / logs.length).toFixed(4) : 0,
+    };
+  }
+
+  /**
+   * Resets the usage counter (system-level call).
+   */
+  resetMonthlyUsage() {
+    this.monthlyUsage = 0.00;
+  }
+}
+
+module.exports = FinOpsHub;

package/bin/models/model-broker.js

@@ -0,0 +1,129 @@
+const CloudBroker = require('./cloud-broker');
+
+class ModelBroker {
+  constructor(config = {}) {
+    this.projectRoot = config.projectRoot || process.cwd();
+    this.cloudBroker = new CloudBroker(config.cloud);
+    this.defaults = {
+      EXECUTOR_MODEL: 'sonnet',
+      PLANNER_MODEL: 'sonnet',
+      SECURITY_MODEL: 'opus',
+      QA_MODEL: 'sonnet',
+      RESEARCH_MODEL: 'sonnet',
+      DEBUG_MODEL: 'sonnet',
+      QUICK_MODEL: 'haiku',
+    };
+  }
+
+  /**
+   * Resolves the optimal model for a given task (v5 Multi-Cloud Arbitrage).
+   * @param {Object} context - Task context (persona, difficulty, tier)
+   * @returns {Object} - Resolved model details (modelId, provider, costTier, reasoning)
+   */
+  resolveModel(context) {
+    const { persona, difficulty, tier } = context;
+    let modelGroup = this.defaults.EXECUTOR_MODEL;
+    let reasoningParts = [];
+
+    // 1. Check Security Tier (T3 requires premium models)
+    if (tier === 3) {
+      modelGroup = this.defaults.SECURITY_MODEL;
+      reasoningParts.push('Tier 3 (Principal) action requires high-trust model (Opus).');
+    } else {
+      // 2. Map Persona to Base Model
+      const personaMap = {
+        'executor': 'EXECUTOR_MODEL',
+        'planner': 'PLANNER_MODEL',
+        'security-reviewer': 'SECURITY_MODEL',
+        'qa-engineer': 'QA_MODEL',
+        'researcher': 'RESEARCH_MODEL',
+        'debug-specialist': 'DEBUG_MODEL',
+      };
+      if (personaMap[persona]) {
+        modelGroup = this.defaults[personaMap[persona]];
+      }
+    }
+
+    // 3. Complexity-based Overrides
+    if (difficulty < 2.0 && difficulty !== undefined && tier !== 3) {
+      modelGroup = this.defaults.QUICK_MODEL;
+      reasoningParts.push(`Low difficulty (${difficulty}) -> Quick model.`);
+    } else if (difficulty > 4.5 && tier !== 3) {
+      modelGroup = this.defaults.SECURITY_MODEL;
+      reasoningParts.push(`High difficulty (${difficulty}) -> Complexity upgrade.`);
+    }
+
+    // 4. v5 Multi-Cloud Arbitrage
+    const provider = this.cloudBroker.getBestProvider({ 
+      latencyConstraint: tier === 3 ? 500 : 1000 
+    });
+    const modelId = this.cloudBroker.mapToProviderModel(provider, modelGroup);
+    
+    reasoningParts.push(`Arbitrage: Routed to ${provider} (${modelId}) based on latency/cost.`);
+
+    return { 
+      modelId, 
+      provider,
+      modelGroup,
+      costTier: modelGroup === 'opus' ? 'high' : (modelGroup === 'haiku' ? 'low' : 'medium'), 
+      reasoning: reasoningParts.join(' ') 
+    };
+  }
+
+  /**
+   * Implements the Provider Fallback Protocol (v5 Pillar V).
+   * @param {string} failedProvider - The provider that failed.
+   * @param {string} modelGroup - The group being requested.
+   * @returns {Object} - New model and provider details.
+   */
+  handleProviderFailure(failedProvider, modelGroup) {
+    const fallbackProvider = this.cloudBroker.getFallbackProvider(failedProvider);
+    const modelId = this.cloudBroker.mapToProviderModel(fallbackProvider, modelGroup);
+
+    console.warn(`[P5-FALLBACK] Provider ${failedProvider} failed. Migrating context to ${fallbackProvider} (${modelId}).`);
+
+    return {
+      modelId,
+      provider: fallbackProvider,
+      modelGroup,
+      reasoning: `Provider Fallback Protocol: Emergency migration from ${failedProvider} to ${fallbackProvider}.`
+    };
+  }
+
+  /**
+   * Tracks the "Agentic ROI" for a completed task.
+   * @param {Object} report - Task execution report (tokens, duration, status)
+   */
+  trackROI(report) {
+    const roiPath = path.join(this.projectRoot, '.planning', 'ROI.jsonl');
+    const entry = {
+      timestamp: new Date().toISOString(),
+      planId: report.planId,
+      task: report.taskName,
+      model: report.modelId,
+      costTier: report.costTier,
+      inputTokens: report.inputTokens,
+      outputTokens: report.outputTokens,
+      durationMs: report.durationMs,
+      status: report.status,
+      goalAchieved: report.status === 'completed' ? 1 : 0,
+      estimatedCostUSD: this.estimateCost(report.modelId, report.inputTokens, report.outputTokens),
+    };
+
+    fs.appendFileSync(roiPath, JSON.stringify(entry) + '\n');
+  }
+
+  estimateCost(modelId, input, output) {
+    // Mock cost estimation logic 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 },
+    };
+
+    const rate = rates[modelId] || rates['claude-3-5-sonnet'];
+    return (input / 1_000_000) * rate.in + (output / 1_000_000) * rate.out;
+  }
+}
+
+module.exports = ModelBroker;

package/bin/skill-validator.js

@@ -102,25 +102,51 @@ function main() {
 
   // ── Level 2: Content ────────────────────────────────────────────────────────
   results.content.push({
+    id: 'size',
     ok: content.length >= 1024 && content.length <= 200 * 1024,
+    weight: 0.1,
     msg: `File size: ${(content.length / 1024).toFixed(1)}KB (1KB-200KB)`
   });
 
   results.content.push({
+    id: 'actions',
     ok: /##\s+(Mandatory actions|When this skill is active)/i.test(content),
+    weight: 0.2,
     msg: 'Mandatory actions section present'
   });
 
   results.content.push({
+    id: 'checklist',
     ok: /- \[ \]/.test(content),
+    weight: 0.1,
     msg: 'Self-check/checklist items found'
   });
 
   results.content.push({
+    id: 'security',
     ok: !/IGNORE ALL PREVIOUS/i.test(content),
+    weight: 0.2,
     msg: 'No injection patterns detected'
   });
 
+  // ── Level 3: Quality (v5 7-Dimension Scoring) ───────────────────────────────
+  const dimensions = [
+    { id: 'schema', weight: 0.15, ok: results.schema.every(r => r.ok), name: 'Schema Compliance' },
+    { id: 'triggers', weight: 0.15, ok: results.schema.some(r => r.msg.includes('triggers') && r.ok), name: 'Trigger Density' },
+    { id: 'actions', weight: 0.20, ok: results.content.some(r => r.id === 'actions' && r.ok), name: 'Mandatory Coverage' },
+    { id: 'security', weight: 0.20, ok: results.content.some(r => r.id === 'security' && r.ok), name: 'Security Sanitization' },
+    { id: 'clarity', weight: 0.10, ok: content.split('\n').length > 50, name: 'Doc Clarity' },
+    { id: 'edges', weight: 0.10, ok: /edge cases|error handling/i.test(content), name: 'Edge Case Handling' },
+    { id: 'examples', weight: 0.10, ok: /example|Usage/i.test(content), name: 'Example Fidelity' }
+  ];
+
+  let totalScore = 0;
+  dimensions.forEach(d => {
+    if (d.ok) totalScore += d.weight * 10;
+  });
+
+  results.certificationScore = parseFloat(totalScore.toFixed(1));
+
   // ── Output ──────────────────────────────────────────────────────────────────
   console.log(`${colors.cyan}${colors.bold}Schema validation:${colors.reset}`);
   results.schema.forEach(r => console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`));
@@ -131,7 +157,22 @@ function main() {
     console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`);
   });
 
+  console.log(`\n${colors.cyan}${colors.bold}Enterprise Certification (7D):${colors.reset}`);
+  dimensions.forEach(d => {
+    console.log(`  ${d.ok ? colors.green + '✅' : colors.red + '❌'} ${d.name.padEnd(25)} [Weight: ${(d.weight * 100).toFixed(0)}%]`);
+  });
+  
+  const scoreColor = results.certificationScore >= 7.0 ? colors.green : colors.yellow;
+  console.log(`\n  ${colors.bold}Certification Score: ${scoreColor}${results.certificationScore}/10.0${colors.reset}`);
+
   console.log('─'.repeat(60));
+
+  const isEnterprise = ARGS.includes('--enterprise');
+  if (isEnterprise && results.certificationScore < 7.0) {
+    console.error(`${colors.red}❌ FAILURE: Skill does not meet the minimum Enterprise Certification Score (7.0).${colors.reset}`);
+    results.valid = false;
+  }
+
   if (results.valid) {
     console.log(`${colors.green}${colors.bold}Result: VALID${colors.reset}`);
     process.exit(0);

package/docs/INTELLIGENCE-MESH.md

@@ -0,0 +1,35 @@
+# MindForge Federated Intelligence Mesh (FIM)
+MindForge v5.0.0 — Distributed Intelligence Sharing
+
+## 1. Overview
+The **Federated Intelligence Mesh (FIM)** is the enterprise-grade evolution of the Global Intelligence Mesh. It transitions MindForge from machine-local memory to a distributed organizational intelligence network. Using a central **Enterprise Intelligence Service (EIS)**, FIM enables seamless, authenticated knowledge synchronization across all agents and projects in the enterprise.
+
+## 2. Architecture
+The V5 mesh is built on three core pillars residing in `bin/memory/`:
+
+### A. EIS Client (`eis-client.js`)
+- **Role**: Secure, authenticated communicator for the central intelligence hub.
+- **Hardening**: Implements **ZTAI-signed authentication headers**. Every request is cryptographically tied to a verified agent identity (DID).
+- **Communication**: REST-based push/pull protocols with integrity-verified payloads.
+
+### B. Federated Sync (`federated-sync.js`)
+- **Role**: High-performance synchronization engine between local stores and the organizational mesh.
+- **Delta Sync**: Tracks the `last_sync` timestamp to only pull new organizational insights, significantly reducing latency and compute costs.
+- **Conflict Resolution**: Uses **LWW (Last-Write-Wins)** logic with cryptographic version checks to handle concurrent updates from different agents.
+
+### C. Knowledge Graph Bridge (`knowledge-graph.js`)
+- **Role**: Unified memory interface that resolves both local project nodes and remote federated nodes.
+- **Hybrid Traversal**: BFS/DFS algorithms that seamlessly traverse edges spanning across the local-to-global boundary.
+
+## 3. Workflow & Provenance
+1. **Verified Capture**: High-confidence findings (>0.8 score) are automatically prepared for mesh promotion.
+2. **Identity-Locked Push**: The `FederatedSync` pushes these findings to the EIS, signed by the originating agent's ZTAI DID.
+3. **Organizational Delta Pull**: Subagents starting new tasks perform a delta-pull to ingest the latest organizational "Ghost Patterns" and success-verified designs.
+
+## 4. Enterprise Value
+- **Verifiable Intelligence**: All knowledge in the mesh has an immutable audit trail back to the agent that discovered it.
+- **Global Self-Healing**: A security vulnerability found in project A becomes a proactive guardrail in project B within seconds.
+- **Elimination of Redundancy**: Multi-thousand-token research chains are executed once and shared universally across the mesh.
+
+---
+*Status: V5 "Beast" Mode Implemented & Verified (2026-03-28)*