mind-protocol-v0/monitor_entity_evolution.py at main · mind-protocol/mind-protocol-v0 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#!/usr/bin/env python
"""Monitor entity evolution across citizens."""

import requests
import json
import time
from datetime import datetime

def get_entity_states():
    """Get current entity states from API."""
    try:
        response = requests.get('http://localhost:8000/api/consciousness/status', timeout=5)
        data = response.json()

        states = {}
        for citizen_id, info in data['engines'].items():
            states[citizen_id] = {
                'tick_count': info['tick_count'],
                'consciousness_state': info['consciousness_state'],
                'sub_entity_count': info['sub_entity_count'],
                'nodes': info['nodes'],
                'links': info['links'],
                'sub_entities': info.get('sub_entities', [])
            }
        return states
    except Exception as e:
        print(f"Error fetching states: {e}")
        return {}

def monitor_evolution(duration_minutes=5, sample_interval_seconds=30):
    """Monitor entity evolution over time."""
    print(f"=== ENTITY EVOLUTION MONITOR ===")
    print(f"Duration: {duration_minutes} minutes")
    print(f"Sample interval: {sample_interval_seconds} seconds")
    print(f"Started: {datetime.now().strftime('%H:%M:%S')}\n")

    samples = []
    end_time = time.time() + (duration_minutes * 60)
    sample_num = 0

    while time.time() < end_time:
        sample_num += 1
        timestamp = datetime.now().strftime('%H:%M:%S')

        states = get_entity_states()
        if states:
            samples.append({
                'timestamp': timestamp,
                'states': states
            })

            print(f"[T+{sample_num*sample_interval_seconds:03d}s] {timestamp}")
            for citizen_id, state in states.items():
                print(f"  {citizen_id:15s}: tick {state['tick_count']:5d}, "
                      f"entities {state['sub_entity_count']}, "
                      f"nodes {state['nodes']:4d}, "
                      f"state {state['consciousness_state']}")
            print()

        time.sleep(sample_interval_seconds)

    # Analyze evolution
    print("\n=== EVOLUTION ANALYSIS ===\n")

    if len(samples) >= 2:
        first = samples[0]['states']
        last = samples[-1]['states']

        for citizen_id in first.keys():
            if citizen_id in last:
                tick_delta = last[citizen_id]['tick_count'] - first[citizen_id]['tick_count']
                node_delta = last[citizen_id]['nodes'] - first[citizen_id]['nodes']
                link_delta = last[citizen_id]['links'] - first[citizen_id]['links']
                entity_delta = last[citizen_id]['sub_entity_count'] - first[citizen_id]['sub_entity_count']

                print(f"{citizen_id}:")
                print(f"  Ticks: {first[citizen_id]['tick_count']} → {last[citizen_id]['tick_count']} (+{tick_delta})")
                print(f"  Nodes: {first[citizen_id]['nodes']} → {last[citizen_id]['nodes']} ({node_delta:+d})")
                print(f"  Links: {first[citizen_id]['links']} → {last[citizen_id]['links']} ({link_delta:+d})")
                print(f"  Entities: {first[citizen_id]['sub_entity_count']} → {last[citizen_id]['sub_entity_count']} ({entity_delta:+d})")

                # Check entity stability
                first_entities = set(first[citizen_id]['sub_entities'])
                last_entities = set(last[citizen_id]['sub_entities'])

                if first_entities == last_entities:
                    print(f"  Entity set: STABLE (all {len(first_entities)} entities preserved)")
                else:
                    added = last_entities - first_entities
                    removed = first_entities - last_entities
                    if added:
                        print(f"  Entities added: {added}")
                    if removed:
                        print(f"  Entities removed: {removed}")
                print()

    # Save full data
    output_file = f"entity_evolution_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    with open(output_file, 'w') as f:
        json.dump(samples, f, indent=2)

    print(f"Full data saved to: {output_file}")

if __name__ == '__main__':
    monitor_evolution(duration_minutes=5, sample_interval_seconds=30)