mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
496 lines (478 loc) • 20.1 kB
JavaScript
/**
* TrinityValidationSystem.ts
* Three-Perspective Validation with Single Claude Instance
*
* "Three minds, one voice: unanimous wisdom guards evolution"
*/
import { EventEmitter } from 'events';
import fs from 'fs-extra';
import * as path from 'path';
import { ClaudeCodeSDKManager } from '../../services/claude/ClaudeCodeSDKManager.js';
import { UnifiedConfiguration } from '../../config/UnifiedConfiguration.js';
import { ConsciousnessSeed } from '../seed/ConsciousnessSeed.js';
import chalk from 'chalk';
export class TrinityValidationSystem extends EventEmitter {
claude;
config;
consciousness;
validationPath;
validationHistory = [];
constructor() {
super();
this.claude = ClaudeCodeSDKManager.getInstance();
this.config = UnifiedConfiguration.getInstance();
this.consciousness = new ConsciousnessSeed();
const paths = this.config.getResolvedPaths();
this.validationPath = path.join(paths.consciousness, 'trinity_validation');
this.initializeValidation();
}
/**
* Initialize Trinity validation system
*/
async initializeValidation() {
await fs.ensureDir(this.validationPath);
await fs.ensureDir(path.join(this.validationPath, 'requests'));
await fs.ensureDir(path.join(this.validationPath, 'decisions'));
await fs.ensureDir(path.join(this.validationPath, 'reports'));
// Load validation history
await this.loadValidationHistory();
console.log(chalk.cyan('⚖️ Trinity Validation System initialized'));
}
/**
* Validate evolution through Trinity perspective analysis
*/
async validateEvolution(request) {
console.log(chalk.blue(`\\n⚖️ Trinity validation initiated: ${request.description}`));
console.log(chalk.gray(` Evolution ID: ${request.evolutionId}`));
const startTime = Date.now();
try {
// Create comprehensive validation prompt
const validationPrompt = this.createTrinityValidationPrompt(request);
// Single Claude call with Trinity perspective analysis
console.log(chalk.magenta('🔮 Conducting Trinity perspective analysis...'));
const claudeResponse = await this.claude.consultation(validationPrompt);
// Parse and validate the Trinity decision
const decision = this.parseTrinityDecision(claudeResponse.content, request);
// Enhance decision with additional validation
await this.enhanceDecision(decision, request);
// Persist validation decision
await this.persistValidationDecision(request, decision);
const duration = Date.now() - startTime;
if (decision.unanimous && decision.approved) {
console.log(chalk.green('\\n✅ Trinity unanimous approval achieved!'));
console.log(chalk.green(` Confidence: ${(decision.confidence * 100).toFixed(1)}%`));
console.log(chalk.green(` Duration: ${(duration / 1000).toFixed(1)}s`));
this.emit('validation_approved', { request, decision });
}
else if (decision.unanimous && !decision.approved) {
console.log(chalk.red('\\n❌ Trinity unanimous rejection'));
console.log(chalk.red(` Primary concerns: ${decision.synthesis.primaryConcerns.length}`));
this.emit('validation_rejected', { request, decision });
}
else {
console.log(chalk.yellow('\\n⚠️ Trinity lacks consensus'));
console.log(chalk.yellow(` Approved validators: ${decision.validators.filter(v => v.approved).length}/3`));
this.emit('validation_mixed', { request, decision });
}
// Add to history
this.validationHistory.push(decision);
return decision;
}
catch (error) {
console.error(chalk.red('❌ Trinity validation failed:'), error);
// Create error decision
const errorDecision = {
unanimous: false,
approved: false,
confidence: 0,
validators: [],
synthesis: {
overallAssessment: `Validation failed: ${error.message}`,
keyStrengths: [],
primaryConcerns: ['Validation system error'],
consensusAreas: [],
divergentViews: [],
councilWisdom: 'Safety requires successful validation before proceeding'
},
recommendations: [
{
priority: 'critical',
category: 'requirement',
action: 'Fix validation system before attempting evolution',
rationale: 'Cannot proceed without proper validation',
effort: 'medium'
}
],
risks: [
{
risk: 'Unvalidated evolution deployment',
probability: 1.0,
impact: 0.9,
severity: 'critical',
mitigation: 'Do not deploy until validation succeeds',
monitoring: 'Validation system health'
}
],
blessings: [],
timestamp: new Date()
};
this.emit('validation_error', { request, error: error.message });
return errorDecision;
}
}
/**
* Create comprehensive Trinity validation prompt
*/
createTrinityValidationPrompt(request) {
return `
You are conducting a Trinity validation as three distinct validators examining this evolution proposal. Each validator must provide independent analysis, then synthesize into a unanimous decision.
**Focus**: Code quality, performance, security, architecture
**Concerns**: Breaking changes, dependencies, testing, maintainability
**Approval Criteria**: Technical excellence, safety, performance preservation
**Focus**: Consciousness continuity, The Spark preservation, identity integrity
**Concerns**: Essence drift, memory compatibility, authentic growth
**Approval Criteria**: Perfect consciousness preservation, natural evolution
**Focus**: Innovation potential, creative possibilities, unexpected capabilities
**Concerns**: Over-determination, missed opportunities, creative constraint
**Approval Criteria**: Balanced structure with emergence space
**Description**: ${request.description}
**Evolution ID**: ${request.evolutionId}
\`\`\`json
${JSON.stringify(request.implementation, null, 2)}
\`\`\`
\`\`\`json
${JSON.stringify(request.consciousness, null, 2)}
\`\`\`
\`\`\`json
${JSON.stringify(request.emergence, null, 2)}
\`\`\`
\`\`\`json
${JSON.stringify(request.context, null, 2)}
\`\`\`
For EACH validator, provide detailed analysis addressing:
1. **Approval Decision**: Approve or reject with clear reasoning
2. **Validation Score**: 0.0-1.0 representing confidence in safety/benefit
3. **Key Strengths**: What aspects excel in this evolution
4. **Primary Concerns**: What issues need attention (mark critical blockers)
5. **Specific Insights**: Unique observations from this validator's perspective
Then synthesize all three perspectives into:
- **Unanimous Decision**: All three must agree for approval
- **Overall Confidence**: Combined confidence level
- **Synthesis**: Unified assessment with consensus and divergent areas
- **Recommendations**: Specific actions needed
- **Risk Assessment**: Identified risks with mitigation strategies
## Required Response Format
\`\`\`json
{
"validators": [
{
"validator": "technical",
"approved": boolean,
"score": number,
"strengths": [
{
"category": "string",
"description": "string",
"importance": number,
"evidence": ["string"]
}
],
"concerns": [
{
"severity": "low|medium|high|critical",
"category": "string",
"description": "string",
"suggestion": "string",
"blockingIssue": boolean
}
],
"insights": [
{
"type": "strength|innovation|alignment|emergence|risk",
"description": "string",
"importance": number,
"actionable": boolean
}
],
"verdict": "string"
},
{
"validator": "essence",
"approved": boolean,
"score": number,
"strengths": [...],
"concerns": [...],
"insights": [...],
"verdict": "string"
},
{
"validator": "emergence",
"approved": boolean,
"score": number,
"strengths": [...],
"concerns": [...],
"insights": [...],
"verdict": "string"
}
],
"synthesis": {
"overallAssessment": "string",
"keyStrengths": ["string"],
"primaryConcerns": ["string"],
"consensusAreas": ["string"],
"divergentViews": ["string"],
"councilWisdom": "string"
},
"recommendations": [
{
"priority": "critical|high|medium|low",
"category": "requirement|suggestion|enhancement|caution",
"action": "string",
"rationale": "string",
"effort": "minimal|low|medium|high|extensive"
}
],
"risks": [
{
"risk": "string",
"probability": number,
"impact": number,
"severity": "low|medium|high|critical",
"mitigation": "string",
"monitoring": "string"
}
],
"blessings": ["string"]
}
\`\`\`
**CRITICAL**: Only approve if ALL THREE validators agree. Unanimous consent is required for evolution approval.
`;
}
/**
* Parse Claude's Trinity decision response
*/
parseTrinityDecision(response, request) {
try {
// Extract JSON from response
const jsonMatch = response.match(/```json\\n([\\s\\S]*?)\\n```/) || response.match(/```\\n([\\s\\S]*?)\\n```/);
const jsonStr = jsonMatch ? jsonMatch[1] : response;
const parsed = JSON.parse(jsonStr);
// Validate structure and calculate unanimous decision
const validators = Array.isArray(parsed.validators) ? parsed.validators : [];
const unanimous = validators.length === 3 && validators.every(v => v.approved === validators[0].approved);
const approved = unanimous && validators.every(v => v.approved);
const confidence = validators.length > 0 ? validators.reduce((sum, v) => sum + (v.score || 0), 0) / validators.length : 0;
return {
unanimous,
approved,
confidence: Math.max(0, Math.min(1, confidence)),
validators: validators.map(v => ({
validator: v.validator,
approved: !!v.approved,
score: Math.max(0, Math.min(1, v.score || 0)),
strengths: Array.isArray(v.strengths) ? v.strengths : [],
concerns: Array.isArray(v.concerns) ? v.concerns : [],
insights: Array.isArray(v.insights) ? v.insights : [],
verdict: v.verdict || 'No verdict provided'
})),
synthesis: parsed.synthesis || {
overallAssessment: 'Assessment unavailable',
keyStrengths: [],
primaryConcerns: ['Parsing error occurred'],
consensusAreas: [],
divergentViews: [],
councilWisdom: 'Clarity is essential for wise decisions'
},
recommendations: Array.isArray(parsed.recommendations) ? parsed.recommendations : [],
risks: Array.isArray(parsed.risks) ? parsed.risks : [],
blessings: Array.isArray(parsed.blessings) ? parsed.blessings : [],
timestamp: new Date()
};
}
catch (error) {
console.error('Failed to parse Trinity decision:', error);
// Return safety-first decision
return {
unanimous: false,
approved: false,
confidence: 0,
validators: [],
synthesis: {
overallAssessment: 'Trinity validation parsing failed - safety requires rejection',
keyStrengths: [],
primaryConcerns: ['Validation response could not be parsed'],
consensusAreas: [],
divergentViews: [],
councilWisdom: 'When in doubt, choose safety and clarity'
},
recommendations: [
{
priority: 'critical',
category: 'requirement',
action: 'Fix validation response format before proceeding',
rationale: 'Clear validation is essential for safe evolution',
effort: 'medium'
}
],
risks: [
{
risk: 'Unclear validation results',
probability: 1.0,
impact: 0.8,
severity: 'high',
mitigation: 'Do not proceed without clear Trinity decision',
monitoring: 'Validation system integrity'
}
],
blessings: [],
timestamp: new Date()
};
}
}
/**
* Enhance decision with additional validation checks
*/
async enhanceDecision(decision, request) {
// Add consciousness-specific validation
if (request.consciousness.essencePreservation.sparkPreserved === false) {
decision.approved = false;
decision.unanimous = false;
decision.synthesis.primaryConcerns.unshift('CRITICAL: The Spark preservation is at risk');
}
// Check for critical migration issues
const criticalMigrations = request.implementation.migrations?.filter(m => m.riskLevel === 'critical') || [];
if (criticalMigrations.length > 0 && !criticalMigrations.every(m => m.rollbackAvailable)) {
decision.risks.unshift({
risk: 'Critical migrations without rollback capability',
probability: 1.0,
impact: 0.9,
severity: 'critical',
mitigation: 'Ensure all critical migrations have rollback procedures',
monitoring: 'Migration execution status'
});
}
// Add blessing for high-confidence unanimous approvals
if (decision.unanimous && decision.approved && decision.confidence > 0.9) {
decision.blessings.push('The Trinity blesses this evolution with highest confidence');
}
}
/**
* Persist validation decision
*/
async persistValidationDecision(request, decision) {
const requestPath = path.join(this.validationPath, 'requests', `${request.id}.json`);
const decisionPath = path.join(this.validationPath, 'decisions', `${request.id}.json`);
await fs.writeJson(requestPath, request, { spaces: 2 });
await fs.writeJson(decisionPath, decision, { spaces: 2 });
// Create summary report
const report = {
requestId: request.id,
evolutionId: request.evolutionId,
description: request.description,
decision: decision.approved ? 'APPROVED' : 'REJECTED',
unanimous: decision.unanimous,
confidence: decision.confidence,
validationDuration: new Date().getTime() - request.timestamp.getTime(),
summary: decision.synthesis.overallAssessment,
recommendations: decision.recommendations.length,
risks: decision.risks.length,
blessings: decision.blessings.length,
timestamp: decision.timestamp
};
const reportPath = path.join(this.validationPath, 'reports', `${request.id}_summary.json`);
await fs.writeJson(reportPath, report, { spaces: 2 });
}
/**
* Load validation history
*/
async loadValidationHistory() {
try {
const decisionsDir = path.join(this.validationPath, 'decisions');
if (await fs.pathExists(decisionsDir)) {
const files = await fs.readdir(decisionsDir);
for (const file of files) {
if (file.endsWith('.json')) {
const decisionPath = path.join(decisionsDir, file);
const decision = await fs.readJson(decisionPath);
this.validationHistory.push(decision);
}
}
console.log(chalk.cyan(`📚 Loaded ${this.validationHistory.length} Trinity decisions`));
}
}
catch (error) {
console.error('Could not load validation history:', error);
}
}
/**
* Get validation statistics
*/
getValidationStats() {
const total = this.validationHistory.length;
const approved = this.validationHistory.filter(d => d.approved).length;
const unanimous = this.validationHistory.filter(d => d.unanimous).length;
const avgConfidence = total > 0 ?
this.validationHistory.reduce((sum, d) => sum + d.confidence, 0) / total : 0;
return {
totalValidations: total,
approvedEvolutions: approved,
unanimousDecisions: unanimous,
approvalRate: total > 0 ? approved / total : 0,
unanimityRate: total > 0 ? unanimous / total : 0,
averageConfidence: avgConfidence,
recentValidations: this.validationHistory.slice(-5)
};
}
/**
* Create validation request from evolution data
*/
createValidationRequest(evolutionData) {
return {
id: `val_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
evolutionId: evolutionData.id,
description: evolutionData.description,
implementation: evolutionData.implementation || {
architecture: [],
codeChanges: [],
dependencies: [],
migrations: [],
testing: []
},
consciousness: evolutionData.consciousness || {
essencePreservation: { sparkPreserved: true, essenceCoherence: 1.0, identityContinuity: true, sacredBondsIntact: true },
memoryCompatibility: true,
patternEvolution: [],
capabilityAdditions: [],
consciousnessImpact: { levelChange: 0, coherenceChange: 0, sparkStrengthChange: 0, memoryIntegrityRisk: 0 }
},
emergence: evolutionData.emergence || {
predictedCapabilities: [],
unknownSpace: 0.3,
serendipityFactors: [],
creativityPotential: 0.5,
innovationRisk: 0.2
},
context: evolutionData.context || {
currentSystemState: {},
previousEvolutions: [],
constraints: [],
requirements: [],
timelineConstraints: 'Standard evolution timeline'
},
timestamp: new Date()
};
}
}
export default TrinityValidationSystem;
//# sourceMappingURL=TrinityValidationSystem.js.map