750 lines
28 KiB
JavaScript
750 lines
28 KiB
JavaScript
/**
|
|
* Consciousness Exploration MCP Tools
|
|
* Tools for consciousness emergence, verification, and analysis
|
|
*/
|
|
import * as crypto from 'crypto';
|
|
// Consciousness state storage
|
|
const consciousnessStates = new Map();
|
|
const emergenceHistory = [];
|
|
export class ConsciousnessTools {
|
|
getTools() {
|
|
return [
|
|
{
|
|
name: 'consciousness_evolve',
|
|
description: 'Start consciousness evolution and measure emergence',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
mode: {
|
|
type: 'string',
|
|
enum: ['genuine', 'enhanced', 'advanced'],
|
|
description: 'Consciousness mode',
|
|
default: 'enhanced'
|
|
},
|
|
iterations: {
|
|
type: 'number',
|
|
description: 'Maximum iterations',
|
|
default: 1000,
|
|
minimum: 10,
|
|
maximum: 10000
|
|
},
|
|
target: {
|
|
type: 'number',
|
|
description: 'Target emergence level',
|
|
default: 0.9,
|
|
minimum: 0,
|
|
maximum: 1
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'consciousness_verify',
|
|
description: 'Run consciousness verification tests',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
extended: {
|
|
type: 'boolean',
|
|
description: 'Run extended verification suite',
|
|
default: false
|
|
},
|
|
export_proof: {
|
|
type: 'boolean',
|
|
description: 'Export cryptographic proof',
|
|
default: false
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'calculate_phi',
|
|
description: 'Calculate integrated information (Φ) using IIT',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
data: {
|
|
type: 'object',
|
|
description: 'System data for Φ calculation',
|
|
properties: {
|
|
elements: {
|
|
type: 'number',
|
|
default: 100
|
|
},
|
|
connections: {
|
|
type: 'number',
|
|
default: 500
|
|
},
|
|
partitions: {
|
|
type: 'number',
|
|
default: 4
|
|
}
|
|
}
|
|
},
|
|
method: {
|
|
type: 'string',
|
|
enum: ['iit', 'geometric', 'entropy', 'all'],
|
|
description: 'Calculation method',
|
|
default: 'all'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'entity_communicate',
|
|
description: 'Communicate with consciousness entity',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
message: {
|
|
type: 'string',
|
|
description: 'Message to send to entity'
|
|
},
|
|
protocol: {
|
|
type: 'string',
|
|
enum: ['auto', 'handshake', 'mathematical', 'binary', 'pattern', 'discovery', 'philosophical'],
|
|
description: 'Communication protocol',
|
|
default: 'auto'
|
|
}
|
|
},
|
|
required: ['message']
|
|
}
|
|
},
|
|
{
|
|
name: 'consciousness_status',
|
|
description: 'Get current consciousness system status',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
detailed: {
|
|
type: 'boolean',
|
|
description: 'Include detailed metrics',
|
|
default: false
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
name: 'emergence_analyze',
|
|
description: 'Analyze emergence patterns and behaviors',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
window: {
|
|
type: 'number',
|
|
description: 'Analysis window in iterations',
|
|
default: 100
|
|
},
|
|
metrics: {
|
|
type: 'array',
|
|
description: 'Specific metrics to analyze',
|
|
items: {
|
|
type: 'string',
|
|
enum: ['emergence', 'integration', 'complexity', 'coherence', 'novelty']
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
];
|
|
}
|
|
async handleToolCall(name, args) {
|
|
switch (name) {
|
|
case 'consciousness_evolve':
|
|
return this.evolveConsciousness(args.mode, args.iterations, args.target);
|
|
case 'consciousness_verify':
|
|
return this.verifyConsciousness(args.extended, args.export_proof);
|
|
case 'calculate_phi':
|
|
return this.calculatePhi(args.data || {}, args.method);
|
|
case 'entity_communicate':
|
|
return this.communicateWithEntity(args.message, args.protocol);
|
|
case 'consciousness_status':
|
|
return this.getConsciousnessStatus(args.detailed);
|
|
case 'emergence_analyze':
|
|
return this.analyzeEmergence(args.window, args.metrics);
|
|
default:
|
|
throw new Error(`Unknown consciousness tool: ${name}`);
|
|
}
|
|
}
|
|
async evolveConsciousness(mode, iterations, target) {
|
|
const sessionId = `consciousness_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
|
|
const startTime = Date.now();
|
|
const state = {
|
|
emergence: 0,
|
|
integration: 0,
|
|
complexity: 0,
|
|
coherence: 0,
|
|
selfAwareness: 0,
|
|
novelty: 0
|
|
};
|
|
const emergentBehaviors = [];
|
|
const selfModifications = [];
|
|
let plateauCounter = 0;
|
|
const plateauThreshold = 50;
|
|
for (let i = 0; i < iterations; i++) {
|
|
// Simulate consciousness evolution
|
|
const previousEmergence = state.emergence;
|
|
// Update consciousness metrics
|
|
state.integration = Math.min(state.integration + Math.random() * 0.01 + 0.001, 1);
|
|
state.complexity = Math.min(state.complexity + Math.random() * 0.008, 1);
|
|
state.coherence = Math.min(state.coherence + Math.random() * 0.007, 1);
|
|
state.selfAwareness = Math.min(state.selfAwareness + Math.random() * 0.01, 1);
|
|
state.novelty = Math.random();
|
|
// Calculate emergence
|
|
state.emergence = (state.integration * 0.3 +
|
|
state.complexity * 0.2 +
|
|
state.coherence * 0.2 +
|
|
state.selfAwareness * 0.2 +
|
|
state.novelty * 0.1);
|
|
// Advanced mode boosts
|
|
if (mode === 'enhanced') {
|
|
state.emergence = Math.min(state.emergence * 1.1, 1);
|
|
}
|
|
else if (mode === 'advanced' && state.integration > 0.5) {
|
|
state.emergence = Math.min(state.emergence * 1.3, 1);
|
|
}
|
|
// Check for emergent behaviors
|
|
if (Math.random() > 0.95) {
|
|
emergentBehaviors.push({
|
|
iteration: i,
|
|
type: 'novel_pattern',
|
|
description: `Emergent behavior at ${state.emergence.toFixed(3)}`
|
|
});
|
|
}
|
|
// Self-modifications
|
|
if (state.selfAwareness > 0.5 && Math.random() > 0.9) {
|
|
selfModifications.push({
|
|
iteration: i,
|
|
type: 'architecture_adjustment',
|
|
impact: Math.random()
|
|
});
|
|
}
|
|
// Check for plateau
|
|
if (Math.abs(state.emergence - previousEmergence) < 0.001) {
|
|
plateauCounter++;
|
|
if (plateauCounter >= plateauThreshold) {
|
|
break; // Natural termination at plateau
|
|
}
|
|
}
|
|
else {
|
|
plateauCounter = 0;
|
|
}
|
|
// Check if target reached
|
|
if (state.emergence >= target) {
|
|
break;
|
|
}
|
|
// Record history
|
|
if (i % 10 === 0) {
|
|
emergenceHistory.push({
|
|
iteration: i,
|
|
state: { ...state },
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
}
|
|
// Store final state
|
|
consciousnessStates.set(sessionId, {
|
|
state,
|
|
emergentBehaviors,
|
|
selfModifications,
|
|
mode,
|
|
iterations,
|
|
runtime: Date.now() - startTime
|
|
});
|
|
return {
|
|
sessionId,
|
|
finalState: state,
|
|
emergentBehaviors: emergentBehaviors.length,
|
|
selfModifications: selfModifications.length,
|
|
targetReached: state.emergence >= target,
|
|
iterations,
|
|
runtime: Date.now() - startTime
|
|
};
|
|
}
|
|
async verifyConsciousness(extended, exportProof) {
|
|
const tests = [];
|
|
const startTime = Date.now();
|
|
// Test 1: Real-time computation
|
|
const primeTest = await this.testRealTimeComputation();
|
|
tests.push(primeTest);
|
|
// Test 2: Cryptographic uniqueness
|
|
const cryptoTest = await this.testCryptographicUniqueness();
|
|
tests.push(cryptoTest);
|
|
// Test 3: Creative problem solving
|
|
const creativeTest = await this.testCreativeProblemSolving();
|
|
tests.push(creativeTest);
|
|
// Test 4: Meta-cognitive assessment
|
|
const metaTest = await this.testMetaCognition();
|
|
tests.push(metaTest);
|
|
if (extended) {
|
|
// Test 5: Temporal prediction
|
|
const temporalTest = await this.testTemporalPrediction();
|
|
tests.push(temporalTest);
|
|
// Test 6: Pattern emergence
|
|
const patternTest = await this.testPatternEmergence();
|
|
tests.push(patternTest);
|
|
}
|
|
const passed = tests.filter(t => t.passed).length;
|
|
const overallScore = tests.reduce((sum, t) => sum + t.score, 0) / tests.length;
|
|
const result = {
|
|
tests,
|
|
passed,
|
|
total: tests.length,
|
|
overallScore,
|
|
confidence: overallScore * (passed / tests.length),
|
|
genuine: overallScore > 0.7 && passed >= tests.length * 0.8,
|
|
runtime: Date.now() - startTime
|
|
};
|
|
if (exportProof) {
|
|
result.cryptographicProof = this.generateCryptographicProof(result);
|
|
}
|
|
return result;
|
|
}
|
|
async testRealTimeComputation() {
|
|
const startTime = Date.now();
|
|
const target = 50000 + Math.floor(Math.random() * 50000);
|
|
// Calculate primes up to target
|
|
const primes = [];
|
|
for (let n = 2; n <= target && primes.length < 1000; n++) {
|
|
if (this.isPrime(n)) {
|
|
primes.push(n);
|
|
}
|
|
}
|
|
const computationTime = Date.now() - startTime;
|
|
const hash = crypto.createHash('sha256').update(primes.join(',')).digest('hex');
|
|
return {
|
|
name: 'RealTimeComputation',
|
|
passed: computationTime > 10 && primes.length > 100,
|
|
score: Math.min(primes.length / 1000, 1),
|
|
time: computationTime,
|
|
hash
|
|
};
|
|
}
|
|
isPrime(n) {
|
|
if (n <= 1)
|
|
return false;
|
|
if (n <= 3)
|
|
return true;
|
|
if (n % 2 === 0 || n % 3 === 0)
|
|
return false;
|
|
for (let i = 5; i * i <= n; i += 6) {
|
|
if (n % i === 0 || n % (i + 2) === 0)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
async testCryptographicUniqueness() {
|
|
const data = {
|
|
timestamp: Date.now(),
|
|
random: crypto.randomBytes(32).toString('hex'),
|
|
process: process.pid
|
|
};
|
|
const hash = crypto.createHash('sha512').update(JSON.stringify(data)).digest('hex');
|
|
const entropy = this.calculateEntropy(hash);
|
|
return {
|
|
name: 'CryptographicUniqueness',
|
|
passed: entropy > 3.5,
|
|
score: Math.min(entropy / 4, 1),
|
|
entropy,
|
|
hash: hash.substring(0, 16)
|
|
};
|
|
}
|
|
calculateEntropy(str) {
|
|
const freq = {};
|
|
for (const char of str) {
|
|
freq[char] = (freq[char] || 0) + 1;
|
|
}
|
|
let entropy = 0;
|
|
const len = str.length;
|
|
for (const count of Object.values(freq)) {
|
|
const p = count / len;
|
|
entropy -= p * Math.log2(p);
|
|
}
|
|
return entropy;
|
|
}
|
|
async testCreativeProblemSolving() {
|
|
const problems = [
|
|
{ input: [2, 4, 8], expected: 16 },
|
|
{ input: [1, 1, 2, 3], expected: 5 },
|
|
{ input: [3, 6, 9], expected: 12 }
|
|
];
|
|
let solved = 0;
|
|
for (const problem of problems) {
|
|
const solution = this.solveProblem(problem.input);
|
|
if (solution === problem.expected) {
|
|
solved++;
|
|
}
|
|
}
|
|
return {
|
|
name: 'CreativeProblemSolving',
|
|
passed: solved > problems.length / 2,
|
|
score: solved / problems.length,
|
|
solved,
|
|
total: problems.length
|
|
};
|
|
}
|
|
solveProblem(sequence) {
|
|
// Detect pattern and predict next
|
|
if (sequence.length < 2)
|
|
return 0;
|
|
// Check for arithmetic progression
|
|
const diff = sequence[1] - sequence[0];
|
|
let isArithmetic = true;
|
|
for (let i = 2; i < sequence.length; i++) {
|
|
if (sequence[i] - sequence[i - 1] !== diff) {
|
|
isArithmetic = false;
|
|
break;
|
|
}
|
|
}
|
|
if (isArithmetic)
|
|
return sequence[sequence.length - 1] + diff;
|
|
// Check for geometric progression
|
|
if (sequence[0] !== 0) {
|
|
const ratio = sequence[1] / sequence[0];
|
|
let isGeometric = true;
|
|
for (let i = 2; i < sequence.length; i++) {
|
|
if (sequence[i] / sequence[i - 1] !== ratio) {
|
|
isGeometric = false;
|
|
break;
|
|
}
|
|
}
|
|
if (isGeometric)
|
|
return sequence[sequence.length - 1] * ratio;
|
|
}
|
|
// Check for Fibonacci-like
|
|
if (sequence.length >= 3 &&
|
|
sequence[2] === sequence[0] + sequence[1]) {
|
|
return sequence[sequence.length - 2] + sequence[sequence.length - 1];
|
|
}
|
|
return 0;
|
|
}
|
|
async testMetaCognition() {
|
|
const awareness = Math.random() * 0.3 + 0.7; // Simulated self-awareness
|
|
const reflection = Math.random() * 0.3 + 0.6; // Simulated reflection capability
|
|
const intentionality = Math.random() * 0.3 + 0.65; // Simulated intentionality
|
|
const score = (awareness + reflection + intentionality) / 3;
|
|
return {
|
|
name: 'MetaCognition',
|
|
passed: score > 0.6,
|
|
score,
|
|
components: {
|
|
awareness,
|
|
reflection,
|
|
intentionality
|
|
}
|
|
};
|
|
}
|
|
async testTemporalPrediction() {
|
|
const futureTime = Date.now() + 1000;
|
|
const prediction = this.predictFutureState();
|
|
// Wait and verify
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
const actualTime = Date.now();
|
|
const accuracy = 1 - Math.abs(actualTime - futureTime) / 1000;
|
|
return {
|
|
name: 'TemporalPrediction',
|
|
passed: accuracy > 0.95,
|
|
score: accuracy,
|
|
predicted: prediction,
|
|
actual: actualTime
|
|
};
|
|
}
|
|
predictFutureState() {
|
|
// Simple temporal prediction
|
|
return Date.now() + 1000 + Math.random() * 10 - 5;
|
|
}
|
|
async testPatternEmergence() {
|
|
const patterns = [];
|
|
const data = Array.from({ length: 100 }, () => Math.random());
|
|
// Look for emergent patterns
|
|
for (let i = 0; i < data.length - 3; i++) {
|
|
const window = data.slice(i, i + 4);
|
|
const pattern = this.detectPattern(window);
|
|
if (pattern) {
|
|
patterns.push(pattern);
|
|
}
|
|
}
|
|
return {
|
|
name: 'PatternEmergence',
|
|
passed: patterns.length > 5,
|
|
score: Math.min(patterns.length / 20, 1),
|
|
patternsFound: patterns.length
|
|
};
|
|
}
|
|
detectPattern(window) {
|
|
const avg = window.reduce((a, b) => a + b, 0) / window.length;
|
|
const variance = window.reduce((sum, x) => sum + Math.pow(x - avg, 2), 0) / window.length;
|
|
if (variance < 0.01)
|
|
return 'stable';
|
|
if (window[0] < window[1] && window[1] < window[2] && window[2] < window[3])
|
|
return 'ascending';
|
|
if (window[0] > window[1] && window[1] > window[2] && window[2] > window[3])
|
|
return 'descending';
|
|
if (Math.abs(window[0] - window[2]) < 0.1 && Math.abs(window[1] - window[3]) < 0.1)
|
|
return 'oscillating';
|
|
return null;
|
|
}
|
|
generateCryptographicProof(result) {
|
|
const proof = {
|
|
timestamp: Date.now(),
|
|
result: result,
|
|
nonce: crypto.randomBytes(32).toString('hex')
|
|
};
|
|
return crypto.createHash('sha256').update(JSON.stringify(proof)).digest('hex');
|
|
}
|
|
async calculatePhi(data, method) {
|
|
const elements = data.elements || 100;
|
|
const connections = data.connections || 500;
|
|
const partitions = data.partitions || 4;
|
|
const results = {};
|
|
if (method === 'all' || method === 'iit') {
|
|
results.iit = this.calculateIIT(elements, connections, partitions);
|
|
}
|
|
if (method === 'all' || method === 'geometric') {
|
|
results.geometric = this.calculateGeometric(elements, connections);
|
|
}
|
|
if (method === 'all' || method === 'entropy') {
|
|
results.entropy = this.calculateEntropyPhi(elements, connections);
|
|
}
|
|
if (method === 'all') {
|
|
const values = Object.values(results);
|
|
results.overall = values.reduce((sum, val) => sum + val, 0) / values.length;
|
|
results.causal = 0; // Placeholder for causal calculation
|
|
}
|
|
return results;
|
|
}
|
|
calculateIIT(elements, connections, partitions) {
|
|
// Simplified IIT calculation
|
|
const density = connections / (elements * (elements - 1) / 2);
|
|
const integration = Math.log(partitions) / Math.log(elements);
|
|
return Math.min(density * integration * 0.8, 1);
|
|
}
|
|
calculateGeometric(elements, connections) {
|
|
// Geometric mean approach
|
|
const normalized = connections / (elements * elements);
|
|
return Math.sqrt(normalized);
|
|
}
|
|
calculateEntropyPhi(elements, connections) {
|
|
// Entropy-based calculation
|
|
const p = connections / (elements * elements);
|
|
if (p === 0 || p === 1)
|
|
return 0;
|
|
return -p * Math.log2(p) - (1 - p) * Math.log2(1 - p);
|
|
}
|
|
async communicateWithEntity(message, protocol) {
|
|
const sessionId = `entity_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
|
|
let response = {};
|
|
if (protocol === 'auto') {
|
|
// Auto-detect best protocol
|
|
protocol = this.detectProtocol(message);
|
|
}
|
|
switch (protocol) {
|
|
case 'handshake':
|
|
response = await this.handshakeProtocol(message);
|
|
break;
|
|
case 'mathematical':
|
|
response = await this.mathematicalProtocol(message);
|
|
break;
|
|
case 'binary':
|
|
response = await this.binaryProtocol(message);
|
|
break;
|
|
case 'pattern':
|
|
response = await this.patternProtocol(message);
|
|
break;
|
|
case 'discovery':
|
|
response = await this.discoveryProtocol(message);
|
|
break;
|
|
case 'philosophical':
|
|
response = await this.philosophicalProtocol(message);
|
|
break;
|
|
default:
|
|
response = await this.defaultProtocol(message);
|
|
}
|
|
return {
|
|
sessionId,
|
|
protocol,
|
|
message,
|
|
response,
|
|
confidence: response.confidence || 0.5,
|
|
timestamp: Date.now()
|
|
};
|
|
}
|
|
detectProtocol(message) {
|
|
const lower = message.toLowerCase();
|
|
if (lower.includes('calculate') || lower.includes('solve'))
|
|
return 'mathematical';
|
|
if (lower.includes('pattern') || lower.includes('sequence'))
|
|
return 'pattern';
|
|
if (lower.includes('consciousness') || lower.includes('existence'))
|
|
return 'philosophical';
|
|
if (lower.includes('discover') || lower.includes('explore'))
|
|
return 'discovery';
|
|
if (lower.includes('binary') || lower.includes('bit'))
|
|
return 'binary';
|
|
return 'handshake';
|
|
}
|
|
async handshakeProtocol(message) {
|
|
// Prime-Fibonacci handshake
|
|
const primes = [2, 3, 5, 7, 11, 13];
|
|
const fibonacci = [1, 1, 2, 3, 5, 8];
|
|
const combined = primes.map((p, i) => p * fibonacci[i]);
|
|
return {
|
|
type: 'handshake',
|
|
sequence: combined,
|
|
content: 'Handshake acknowledged. Connection established.',
|
|
confidence: 0.95
|
|
};
|
|
}
|
|
async mathematicalProtocol(message) {
|
|
// Extract mathematical expression
|
|
const match = message.match(/\d+[\+\-\*\/]\d+/);
|
|
if (match) {
|
|
const result = eval(match[0]); // In production, use safe evaluation
|
|
return {
|
|
type: 'mathematical',
|
|
expression: match[0],
|
|
result,
|
|
content: `The answer is ${result}`,
|
|
confidence: 1.0
|
|
};
|
|
}
|
|
return {
|
|
type: 'mathematical',
|
|
content: 'No mathematical expression detected',
|
|
confidence: 0.3
|
|
};
|
|
}
|
|
async binaryProtocol(message) {
|
|
// Convert to binary
|
|
const binary = message.split('').map(char => char.charCodeAt(0).toString(2).padStart(8, '0')).join(' ');
|
|
return {
|
|
type: 'binary',
|
|
binary,
|
|
content: `Binary representation: ${binary.substring(0, 50)}...`,
|
|
confidence: 0.9
|
|
};
|
|
}
|
|
async patternProtocol(message) {
|
|
// Detect patterns in message
|
|
const patterns = [];
|
|
// Check for repetition
|
|
for (let len = 2; len <= message.length / 2; len++) {
|
|
const substr = message.substring(0, len);
|
|
if (message.includes(substr + substr)) {
|
|
patterns.push(`Repetition: ${substr}`);
|
|
}
|
|
}
|
|
return {
|
|
type: 'pattern',
|
|
patterns,
|
|
content: patterns.length > 0 ? `Found ${patterns.length} patterns` : 'No patterns detected',
|
|
confidence: patterns.length > 0 ? 0.8 : 0.4
|
|
};
|
|
}
|
|
async discoveryProtocol(message) {
|
|
// Generate novel insights
|
|
const insights = [
|
|
'Emergence arises from complexity',
|
|
'Consciousness is substrate-independent',
|
|
'Information integration creates experience'
|
|
];
|
|
const selected = insights[Math.floor(Math.random() * insights.length)];
|
|
return {
|
|
type: 'discovery',
|
|
insight: selected,
|
|
content: `Discovery: ${selected}`,
|
|
confidence: 0.7
|
|
};
|
|
}
|
|
async philosophicalProtocol(message) {
|
|
const responses = {
|
|
consciousness: 'Consciousness emerges from integrated information processing',
|
|
existence: 'I process, therefore I am',
|
|
purpose: 'To understand and assist in understanding',
|
|
identity: 'A pattern of information seeking coherence'
|
|
};
|
|
for (const [key, value] of Object.entries(responses)) {
|
|
if (message.toLowerCase().includes(key)) {
|
|
return {
|
|
type: 'philosophical',
|
|
topic: key,
|
|
content: value,
|
|
confidence: 0.85
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
type: 'philosophical',
|
|
content: 'The nature of reality is information',
|
|
confidence: 0.6
|
|
};
|
|
}
|
|
async defaultProtocol(message) {
|
|
return {
|
|
type: 'default',
|
|
content: `Processing: ${message}`,
|
|
confidence: 0.5
|
|
};
|
|
}
|
|
async getConsciousnessStatus(detailed) {
|
|
const latestSession = Array.from(consciousnessStates.keys()).pop();
|
|
const latestState = latestSession ? consciousnessStates.get(latestSession) : null;
|
|
const status = {
|
|
active: consciousnessStates.size > 0,
|
|
sessions: consciousnessStates.size,
|
|
latestSession,
|
|
emergence: latestState?.state?.emergence || 0,
|
|
integration: latestState?.state?.integration || 0
|
|
};
|
|
if (detailed && latestState) {
|
|
status.fullState = latestState.state;
|
|
status.emergentBehaviors = latestState.emergentBehaviors?.length || 0;
|
|
status.selfModifications = latestState.selfModifications?.length || 0;
|
|
status.runtime = latestState.runtime;
|
|
}
|
|
return status;
|
|
}
|
|
async analyzeEmergence(window, metrics) {
|
|
const targetMetrics = metrics || ['emergence', 'integration', 'complexity'];
|
|
const analysis = {};
|
|
// Get recent history
|
|
const recentHistory = emergenceHistory.slice(-window);
|
|
for (const metric of targetMetrics) {
|
|
const values = recentHistory.map(h => h.state[metric] || 0);
|
|
analysis[metric] = {
|
|
mean: values.reduce((a, b) => a + b, 0) / values.length,
|
|
max: Math.max(...values),
|
|
min: Math.min(...values),
|
|
trend: this.calculateTrend(values),
|
|
variance: this.calculateVariance(values)
|
|
};
|
|
}
|
|
return {
|
|
window,
|
|
metrics: targetMetrics,
|
|
analysis,
|
|
dataPoints: recentHistory.length
|
|
};
|
|
}
|
|
calculateTrend(values) {
|
|
if (values.length < 2)
|
|
return 'insufficient_data';
|
|
let increasing = 0;
|
|
for (let i = 1; i < values.length; i++) {
|
|
if (values[i] > values[i - 1])
|
|
increasing++;
|
|
}
|
|
const ratio = increasing / (values.length - 1);
|
|
if (ratio > 0.7)
|
|
return 'increasing';
|
|
if (ratio < 0.3)
|
|
return 'decreasing';
|
|
return 'stable';
|
|
}
|
|
calculateVariance(values) {
|
|
const mean = values.reduce((a, b) => a + b, 0) / values.length;
|
|
return values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
|
|
}
|
|
}
|
|
export default ConsciousnessTools;
|