@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/scripts/mcp-bridge.js

@@ -0,0 +1,220 @@
+/**
+ * MindMeld MCP Bridge - Stdio-to-HTTP proxy for MCP clients
+ *
+ * Bridges stdio MCP transport to the remote MindMeld MCP server.
+ * For clients that don't support URL transport natively
+ * (Cline, Cursor, Windsurf, etc.)
+ *
+ * Usage:
+ *   MINDMELD_TOKEN=mm_live_xxx mindmeld mcp
+ *   mindmeld mcp --token mm_live_xxx
+ */
+
+const https = require('https');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const MCP_HOST = 'api.mindmeld.dev';
+const MCP_PATH = '/api/mcp/mindmeld';
+const REQUEST_TIMEOUT = 30000;
+
+/**
+ * Resolve API token from env var, CLI arg, or stored file
+ */
+function resolveToken(cliToken) {
+    if (process.env.MINDMELD_TOKEN) {
+        return process.env.MINDMELD_TOKEN;
+    }
+    if (cliToken) {
+        return cliToken;
+    }
+    try {
+        const tokenPath = path.join(os.homedir(), '.mindmeld', 'api-token');
+        return fs.readFileSync(tokenPath, 'utf-8').trim();
+    } catch (err) {
+        return null;
+    }
+}
+
+/**
+ * Forward a JSON-RPC message to the remote MCP server
+ */
+function forwardToServer(message, token) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify(message);
+        const req = https.request({
+            method: 'POST',
+            hostname: MCP_HOST,
+            path: MCP_PATH,
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'X-MindMeld-Token': token
+            },
+            timeout: REQUEST_TIMEOUT
+        }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode === 202 || !data.trim()) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(data));
+                } catch (e) {
+                    reject(new Error(`Invalid JSON from server: ${data.substring(0, 200)}`));
+                }
+            });
+        });
+
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Request timed out'));
+        });
+
+        req.on('error', (e) => {
+            reject(new Error(`Connection failed: ${e.message}`));
+        });
+
+        req.write(body);
+        req.end();
+    });
+}
+
+/**
+ * Process a single JSON-RPC message from stdin
+ */
+async function processMessage(line, token) {
+    let message;
+    try {
+        message = JSON.parse(line);
+    } catch (e) {
+        process.stdout.write(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32700, message: 'Parse error: invalid JSON' },
+            id: null
+        }) + '\n');
+        return;
+    }
+
+    const isNotification = !('id' in message);
+
+    try {
+        const response = await forwardToServer(message, token);
+
+        if (response === null || isNotification) {
+            return;
+        }
+
+        process.stdout.write(JSON.stringify(response) + '\n');
+    } catch (error) {
+        process.stderr.write(`[MindMeld] ${error.message}\n`);
+
+        if (!isNotification && message.id !== undefined) {
+            process.stdout.write(JSON.stringify({
+                jsonrpc: '2.0',
+                error: { code: -32603, message: error.message },
+                id: message.id
+            }) + '\n');
+        }
+    }
+}
+
+/**
+ * Start the stdio bridge — long-lived, runs until stdin closes
+ */
+function startBridge(token) {
+    process.stderr.write(`[MindMeld] MCP bridge started (pid ${process.pid})\n`);
+    process.stderr.write(`[MindMeld] Proxying to https://${MCP_HOST}${MCP_PATH}\n`);
+
+    let buffer = '';
+    let pending = 0;
+    let stdinClosed = false;
+
+    function maybeExit() {
+        if (stdinClosed && pending === 0) {
+            process.stderr.write('[MindMeld] All requests complete, shutting down\n');
+            process.exit(0);
+        }
+    }
+
+    function trackMessage(line) {
+        pending++;
+        processMessage(line, token).finally(() => {
+            pending--;
+            maybeExit();
+        });
+    }
+
+    process.stdin.setEncoding('utf-8');
+
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            trackMessage(trimmed);
+        }
+    });
+
+    process.stdin.on('end', () => {
+        process.stderr.write('[MindMeld] stdin closed\n');
+        stdinClosed = true;
+        maybeExit();
+    });
+
+    process.stdin.on('error', (err) => {
+        process.stderr.write(`[MindMeld] stdin error: ${err.message}\n`);
+        process.exit(1);
+    });
+}
+
+function showMcpHelp() {
+    console.log(`
+MindMeld MCP Bridge - Stdio-to-HTTP proxy for MCP clients
+
+Usage:
+  mindmeld mcp [options]
+
+Options:
+  --token <token>  MindMeld API token (or set MINDMELD_TOKEN env var)
+  --help, -h       Show this help
+
+Token Resolution (in priority order):
+  1. MINDMELD_TOKEN environment variable
+  2. --token CLI argument
+  3. ~/.mindmeld/api-token file
+
+Create a token at: https://app.mindmeld.dev/api-tokens
+
+Client Configuration:
+  Cline / Cursor / Windsurf:
+    {
+      "mcpServers": {
+        "mindmeld": {
+          "command": "mindmeld",
+          "args": ["mcp"],
+          "env": { "MINDMELD_TOKEN": "mm_live_xxx" }
+        }
+      }
+    }
+
+  Claude Code (use URL transport instead — no bridge needed):
+    {
+      "mcpServers": {
+        "mindmeld": {
+          "type": "url",
+          "url": "https://api.mindmeld.dev/api/mcp/mindmeld",
+          "headers": { "X-MindMeld-Token": "mm_live_xxx" }
+        }
+      }
+    }
+`);
+}
+
+module.exports = { startBridge, resolveToken, showMcpHelp };

package/src/core/CorrelationAnalyzer.js

@@ -144,6 +144,18 @@ class CorrelationAnalyzer {
             // Calculate aggregate metrics
             await this.calculateAggregateMetrics(projectId, companyId);
 
+            // Update standards_patterns.correlation with observed effectiveness
+            try {
+                const updated = await this.updateStandardsCorrelation();
+                summary.standardsCorrelationUpdated = updated;
+                if (updated > 0) {
+                    console.log(`[CorrelationAnalyzer] Updated correlation scores for ${updated} standards`);
+                }
+            } catch (error) {
+                console.error('[CorrelationAnalyzer] Could not update standards correlations:', error.message);
+                summary.errors.push({ step: 'updateStandardsCorrelation', error: error.message });
+            }
+
             summary.completedAt = new Date().toISOString();
             console.log(`[CorrelationAnalyzer] Analysis complete: ${summary.correlationsCreated} correlations, ${summary.uncorrelatedSessions} uncorrelated`);
 
@@ -763,6 +775,151 @@ class CorrelationAnalyzer {
         };
     }
 
+    /**
+     * Update standards_patterns.correlation with observed effectiveness
+     *
+     * Computes per-standard effectiveness by joining session_standards
+     * (which standards were shown) with session_correlations (which
+     * sessions produced commits). Standards shown in sessions that
+     * produce commits get higher correlation scores.
+     *
+     * This directly influences relevance scoring since
+     * standardsRelevantPost.js uses correlation * 40 as the base score.
+     *
+     * @returns {Promise<number>} Number of standards updated
+     */
+    async updateStandardsCorrelation() {
+        const query = `
+            UPDATE rapport.standards_patterns sp SET
+                correlation = LEAST(sub.effectiveness, 1.00),
+                last_updated = NOW()
+            FROM (
+                SELECT ss.standard_id,
+                    COUNT(*) FILTER (WHERE sc.has_commits = true)::decimal / COUNT(*) as effectiveness
+                FROM rapport.session_standards ss
+                JOIN rapport.session_correlations sc ON sc.session_id = ss.session_id
+                WHERE sc.analyzed_at > NOW() - INTERVAL '30 days'
+                GROUP BY ss.standard_id
+                HAVING COUNT(*) >= 5
+            ) sub
+            WHERE sp.pattern_id = sub.standard_id
+        `;
+
+        const result = await executeQuery(query);
+        return result.rowCount || 0;
+    }
+
+    // ─── Agent Execution Correlation ──────────────────────────────
+
+    /**
+     * Analyze correlations for agent execution patterns.
+     * Instead of session → git commit, this correlates:
+     * - Agent decision → task outcome success rate
+     * - Recovery effectiveness (did failover agents succeed?)
+     * - Tier accuracy (tier matches actual consequence?)
+     * - Cross-workflow pattern reuse
+     *
+     * @param {Object} options - Analysis options
+     * @param {string} options.projectId - Project filter
+     * @param {number} options.lookbackDays - Days to analyze (default: 30)
+     * @returns {Promise<Object>} Agent execution correlation summary
+     */
+    async analyzeAgentExecutionCorrelations(options = {}) {
+        const lookbackDays = options.lookbackDays || 30;
+
+        const summary = {
+            startedAt: new Date().toISOString(),
+            agentsAnalyzed: 0,
+            correlationsCreated: 0,
+            patterns: [],
+            errors: []
+        };
+
+        try {
+            // Get agent execution patterns from pattern_usage
+            const agentPatterns = await executeQuery(`
+                SELECT
+                    p.element,
+                    p.category,
+                    COUNT(pu.*) AS total_uses,
+                    COUNT(pu.*) FILTER (WHERE pu.success = true) AS successful_uses,
+                    COUNT(DISTINCT pu.email_address) AS unique_agents,
+                    AVG(CASE WHEN pu.success THEN 1.0 ELSE 0.0 END) AS success_rate,
+                    MAX(pu.used_at) AS last_used
+                FROM rapport.patterns p
+                JOIN rapport.pattern_usage pu ON pu.pattern_id = p.pattern_id
+                WHERE p.pattern_data->>'source' = 'agent_execution'
+                  AND pu.used_at > NOW() - INTERVAL '${lookbackDays} days'
+                  ${options.projectId ? `AND p.project_id = '${options.projectId}'` : ''}
+                GROUP BY p.element, p.category
+                HAVING COUNT(pu.*) >= 3
+                ORDER BY success_rate ASC
+            `);
+
+            if (agentPatterns?.rows) {
+                for (const pattern of agentPatterns.rows) {
+                    summary.agentsAnalyzed++;
+                    summary.patterns.push({
+                        element: pattern.element,
+                        category: pattern.category,
+                        totalUses: parseInt(pattern.total_uses),
+                        successRate: parseFloat(pattern.success_rate),
+                        uniqueAgents: parseInt(pattern.unique_agents),
+                        lastUsed: pattern.last_used
+                    });
+                }
+            }
+
+            // Update pattern correlations based on agent execution data
+            const updated = await this.updateAgentPatternCorrelations();
+            summary.correlationsCreated = updated;
+
+        } catch (error) {
+            summary.errors.push(error.message);
+        }
+
+        summary.completedAt = new Date().toISOString();
+        return summary;
+    }
+
+    /**
+     * Update pattern correlations for agent execution patterns.
+     * Uses agent task success as the "proof" (instead of git commits for code sessions).
+     *
+     * @returns {Promise<number>} Number of patterns updated
+     */
+    async updateAgentPatternCorrelations() {
+        const query = `
+            UPDATE rapport.patterns p SET
+                handoff_count = sub.total_uses,
+                successful_handoffs = sub.successful_uses,
+                failed_handoffs = sub.failed_uses,
+                last_used = sub.last_used
+            FROM (
+                SELECT
+                    pu.pattern_id,
+                    COUNT(*) AS total_uses,
+                    COUNT(*) FILTER (WHERE pu.success = true) AS successful_uses,
+                    COUNT(*) FILTER (WHERE pu.success = false) AS failed_uses,
+                    MAX(pu.used_at) AS last_used
+                FROM rapport.pattern_usage pu
+                JOIN rapport.patterns pat ON pat.pattern_id = pu.pattern_id
+                WHERE pat.pattern_data->>'source' = 'agent_execution'
+                  AND pu.used_at > NOW() - INTERVAL '30 days'
+                GROUP BY pu.pattern_id
+            ) sub
+            WHERE p.pattern_id = sub.pattern_id
+        `;
+
+        try {
+            const result = await executeQuery(query);
+            return result.rowCount || 0;
+        } catch (error) {
+            console.error('[CorrelationAnalyzer] Agent correlation update failed:', error.message);
+            return 0;
+        }
+    }
+
     /**
      * Get configuration (for debugging/admin)
      */

package/src/core/LLMPatternDetector.js

@@ -103,6 +103,204 @@ class LLMPatternDetector {
         }
     }
 
+    /**
+     * Analyze agent execution logs for patterns in decision-making,
+     * routing, failure recovery, and consequence tier accuracy.
+     *
+     * This is the agent-execution counterpart to analyzeSessionTranscript().
+     * Called by AgentExecutionHarvester after workflow completion.
+     *
+     * @param {Object} executionLog - Structured execution data from EA
+     * @param {Object} executionLog.workflowName - Workflow that was executed
+     * @param {Object[]} executionLog.steps - Array of step results
+     * @param {number} executionLog.duration - Total workflow duration
+     * @param {string[]} executionLog.agentsUsed - List of agents involved
+     * @param {Object} context - Additional context
+     * @returns {Promise<Object>} Detected patterns and analysis
+     */
+    async analyzeAgentExecution(executionLog, context = {}) {
+        if (!this.isAvailable()) {
+            return this.fallbackAgentAnalysis(executionLog);
+        }
+
+        // Build execution-specific prompts
+        const systemPrompt = this.buildAgentExecutionSystemPrompt(context);
+        const userPrompt = this.buildAgentExecutionUserPrompt(executionLog, context);
+
+        try {
+            const requestBody = {
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: this.config.maxTokens,
+                system: systemPrompt,
+                messages: [
+                    { role: 'user', content: userPrompt }
+                ]
+            };
+
+            const command = new InvokeModelCommand({
+                modelId: this.config.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(requestBody)
+            });
+
+            const response = await this.client.send(command);
+            const responseBody = JSON.parse(new TextDecoder().decode(response.body));
+            const content = responseBody.content?.[0]?.text || '';
+
+            return this.parseResponse(content);
+        } catch (error) {
+            console.error('[LLMPatternDetector] Agent execution analysis error:', error.message);
+            return this.fallbackAgentAnalysis(executionLog);
+        }
+    }
+
+    /**
+     * Build system prompt for agent execution analysis
+     */
+    buildAgentExecutionSystemPrompt(context) {
+        return `You are an expert multi-agent governance analyst for the Equilateral platform.
+
+Your task is to analyze agent execution logs and extract:
+1. **Agent Selection Strategies**: Which agents were chosen for which tasks and why
+2. **Failure Recovery Patterns**: Which fallbacks worked, which didn't, and why
+3. **Consequence Tier Accuracy**: Was the assigned tier appropriate for what actually happened?
+4. **Standards Compliance Patterns**: Which standards consistently apply to which workflows
+5. **Routing Efficiency**: Could different agent selections have improved outcomes?
+
+Key governance concepts:
+- Consequence Tiers: T1 (read-only), T2 (reversible write), T3 (irreversible mutation), T4 (external side effect)
+- Agent Classifications: REWARD (high performer), REMEDIATE (needs improvement), REPLACE (should be swapped)
+- Agent Maturity: provisional (new) → validated (confirmed) → reinforced (proven)
+- DecisionFrame: Carries selection reasoning, confidence, fallbacks, violations
+
+Respond ONLY with valid JSON in this exact format:
+{
+  "patterns": [
+    {
+      "element": "Pattern name",
+      "type": "agent_selection|failure_recovery|tier_accuracy|compliance|routing",
+      "intent": "What this pattern means for governance",
+      "evidence": "Data from the execution log",
+      "confidence": 0.85,
+      "severity": "info|warning|critical",
+      "category": "multi-agent-orchestration"
+    }
+  ],
+  "summary": "Brief summary of execution patterns detected",
+  "recommendations": ["Governance improvements"],
+  "violations": [
+    {
+      "standard": "Which governance principle was violated",
+      "description": "What happened",
+      "fix": "How to improve"
+    }
+  ]
+}`;
+    }
+
+    /**
+     * Build user prompt for agent execution analysis
+     */
+    buildAgentExecutionUserPrompt(executionLog, context) {
+        const maxLength = 40000;
+        const logStr = JSON.stringify(executionLog, null, 2);
+        const truncated = logStr.length > maxLength
+            ? logStr.substring(0, maxLength) + '\n\n[... execution log truncated ...]'
+            : logStr;
+
+        const workflowName = executionLog.workflowName || 'Unknown';
+        const agentCount = executionLog.agentsUsed?.length || 0;
+
+        return `Analyze this multi-agent workflow execution for governance patterns:
+
+---
+WORKFLOW: ${workflowName}
+AGENTS USED: ${agentCount}
+DURATION: ${executionLog.duration || 'Unknown'}ms
+---
+
+EXECUTION LOG:
+${truncated}
+
+---
+
+Extract all agent selection strategies, failure recovery patterns, consequence tier accuracy issues, and governance improvements. Focus on:
+1. Were agents selected optimally for each step?
+2. Did failovers work correctly when needed?
+3. Were consequence tiers accurate for the actual operations performed?
+4. Were any governance constraints violated?
+5. Are there patterns that should become standards?
+
+Respond with JSON only.`;
+    }
+
+    /**
+     * Fallback analysis for agent execution when LLM unavailable
+     */
+    fallbackAgentAnalysis(executionLog) {
+        const patterns = [];
+        const steps = executionLog.steps || [];
+
+        // Detect basic patterns from step data
+        const failedSteps = steps.filter(s => !s.success);
+        const failoverSteps = steps.filter(s => s.failoverUsed);
+
+        if (failedSteps.length > 0) {
+            patterns.push({
+                element: `Workflow failure rate: ${failedSteps.length}/${steps.length}`,
+                type: 'failure_recovery',
+                intent: 'Track workflow reliability',
+                confidence: 1.0,
+                severity: failedSteps.length > steps.length / 2 ? 'critical' : 'warning',
+                category: 'multi-agent-orchestration'
+            });
+        }
+
+        if (failoverSteps.length > 0) {
+            patterns.push({
+                element: `Failover usage: ${failoverSteps.length} steps required failover`,
+                type: 'failure_recovery',
+                intent: 'Track agent reliability requiring fallback',
+                confidence: 1.0,
+                severity: 'info',
+                category: 'multi-agent-orchestration'
+            });
+        }
+
+        // Detect repeated agent usage (specialization pattern)
+        const agentCounts = {};
+        for (const step of steps) {
+            const agent = step.agent || step.event?.agent;
+            if (agent) {
+                agentCounts[agent] = (agentCounts[agent] || 0) + 1;
+            }
+        }
+
+        for (const [agent, count] of Object.entries(agentCounts)) {
+            if (count >= 3) {
+                patterns.push({
+                    element: `Agent specialization: ${agent} used ${count} times`,
+                    type: 'agent_selection',
+                    intent: 'Detect heavily-used agents for optimization',
+                    confidence: 0.8,
+                    severity: 'info',
+                    category: 'multi-agent-orchestration'
+                });
+            }
+        }
+
+        return {
+            success: true,
+            source: 'fallback',
+            timestamp: new Date().toISOString(),
+            patterns,
+            summary: `Fallback analysis: ${steps.length} steps, ${failedSteps.length} failures, ${failoverSteps.length} failovers`,
+            recommendations: [],
+            violations: []
+        };
+    }
+
     /**
      * Call AWS Bedrock (Claude) for pattern analysis
      */