Integration Plan — Migrating to the Unified Agent OS

   mkdir -p [home-path] [home-path]

   # Create state.db with full schema from SHARED_STATE_SCHEMA.md
   sqlite3 [home-path] < schema.sql

   [home-path]
   ├── uaos/
   │   ├── __init__.py
   │   ├── db.py           # SQLite wrapper
   │   ├── events.py       # EventBus
   │   ├── config.py       # Config loader
   │   ├── context.py      # SharedContext + ContextBuilder
   │   └── adapters/
   │       ├── __init__.py
   │       ├── pulse.py     # PulseSessionAdapter
   │       ├── dream.py     # DreamAdapter
   │       └── heartbeat.py # HeartbeatAdapter
   └── schema.sql

   python3 -c "import sqlite3; db = sqlite3.connect('[home-path]); print(db.execute('SELECT name FROM sqlite_master WHERE type=\"table\"').fetchall())"
   # Should list: entities, events, handoffs, tags, sessions, iterations, ...

   # scripts/import_pulse.py
   from pathlib import Path
   from uaos.adapters.pulse import PulseSessionAdapter
   from uaos.db import StateDB

   db = StateDB()
   sessions_dir = Path.home() / ".pulse" / "sessions"

   for session_file in sessions_dir.glob("*.json"):
       rows = PulseSessionAdapter.from_legacy(session_file)
       db.upsert_entity(rows['entity'])
       db.upsert_session(rows['session'])
       print(f"  Imported: {rows['session']['project_name']}")

   print(f"Total sessions imported: {db.count('sessions')}")

   # scripts/import_dreams.py
   from uaos.adapters.dream import DreamAdapter
   from uaos.db import StateDB
   import json

   db = StateDB()
   dreams_file = Path.home() / ".claude" / "noosphere" / "dreams.json"

   if dreams_file.exists():
       data = json.loads(dreams_file.read_text())
       for dream in data.get('dreams', []):
           rows = DreamAdapter.from_noosphere(dream)
           db.upsert_entity(rows['entity'])
           db.upsert_dream(rows['dream'])
           for tag in rows['tags']:
               db.upsert_tag(tag)
           print(f"  Imported dream: {dream['seed_idea'][:50]}")

   # Also import completed dreams from daemon
   dreams_dir = Path.home() / ".claude" / "dream-weaver" / "dreams"
   for dream_file in dreams_dir.glob("dream_*.json"):
       # ... similar import logic

   # scripts/import_heartbeat.py
   from uaos.adapters.heartbeat import HeartbeatAdapter
   from uaos.db import StateDB
   import json

   db = StateDB()
   state_file = Path.home() / "memory" / "heartbeat-state.json"

   if state_file.exists():
       state = json.loads(state_file.read_text())
       domains = HeartbeatAdapter.from_legacy(state)
       for domain in domains:
           db.upsert_check_domain(domain)

   # Copy noosphere graph to UAOS location
   cp [home-path] [home-path] 2>/dev/null || true

   SELECT type, COUNT(*) FROM entities GROUP BY type;
   -- Should show sessions, dreams, checks

   SELECT COUNT(*) FROM tags;
   -- Should show keywords from dreams

   SELECT domain, last_checked_at FROM check_domains;
   -- Should show heartbeat domains

   # uaos/events.py
   class EventBus:
       def __init__(self, db: StateDB):
           self.db = db
           self._subscribers = defaultdict(list)

       def publish(self, topic, source, payload, entity_id=None, trace_id=None):
           event = {...}
           self.db.insert_event(event)
           self._dispatch(topic, event)

       def subscribe(self, pattern, handler):
           self._subscribers[pattern].append(handler)

       def _dispatch(self, topic, event):
           for pattern, handlers in self._subscribers.items():
               if self._matches(pattern, topic):
                   for handler in handlers:
                       try:
                           handler(event)
                       except Exception as e:
                           log(f"Handler error for {topic}: {e}")

   # uaos/listeners.py

   def setup_listeners(bus: EventBus, db: StateDB):
       """Register all cross-system event handlers."""

       # Dream emergence → Heartbeat alert
       @bus.subscribe('dream.emerged')
       def on_dream_emerged(event):
           db.insert_check_result({
               'domain': 'dreamWeaver',
               'status': 'ok',
               'alert_level': 8,
               'details': json.dumps({
                   'type': 'dream_emerged',
                   'dream_id': event['entity_id'],
                   'message': f"Dream emerged: {event['payload'].get('seed_idea', '')[:50]}"
               })
           })

       # Dream metamorphosis ready → Log for Cadence review
       @bus.subscribe('dream.metamorphosis.ready')
       def on_metamorphosis_ready(event):
           db.insert_handoff({
               'id': generate_id('ho'),
               'from_system': 'dream_weaver',
               'to_system': 'pulse',
               'from_entity_id': event['entity_id'],
               'handoff_type': 'metamorphosis',
               'payload': event['payload'],
               'status': 'pending',
               'priority': 7,
           })

       # Pulse iteration complete → Feed to Mycelium
       @bus.subscribe('pulse.iteration.completed')
       def on_iteration_completed(event):
           summary = event['payload'].get('summary', '')
           keywords = extract_keywords(summary)
           for kw in keywords:
               db.update_sensing_pattern(kw, {
                   'source': 'pulse',
                   'timestamp': event['timestamp'],
                   'snippet': summary[:200]
               })

       # Heartbeat alert (critical) → Cadence escalation
       @bus.subscribe('heartbeat.alert')
       def on_critical_alert(event):
           level = event['payload'].get('alert_level', 0)
           if level >= 9:
               db.insert_agent_message({
                   'id': generate_id('msg'),
                   'agent_id': 'higher_level',
                   'direction': 'inbox',
                   'msg_type': 'REQUEST',
                   'subject': f"Critical alert: {event['payload'].get('domain', 'unknown')}",
                   'body': json.dumps(event['payload']),
                   'priority': 'High',
                   'status': 'PENDING',
               })

   # Test: publish a dream.emerged event and verify heartbeat alert is created
   bus.publish('dream.emerged', 'dream_weaver', {
       'seed_idea': 'test dream',
       'connection_strength': 0.75
   }, entity_id='dream_test_123')

   alerts = db.query_check_results(domain='dreamWeaver', limit=1)
   assert alerts[0]['alert_level'] == 8

   # At the top of dual_runner.py, add:
   try:
       from uaos.events import EventBus
       from uaos.db import StateDB
       uaos_db = StateDB()
       uaos_bus = EventBus(uaos_db)
       UAOS_ENABLED = True
   except ImportError:
       UAOS_ENABLED = False

   # In run_iteration(), after updating session:
   if UAOS_ENABLED:
       uaos_bus.publish('pulse.iteration.completed', 'pulse', {
           'session_id': session.id,
           'iteration': session.current_iteration,
           'signal': signal,
           'summary': output[:500]
       }, entity_id=session.id)

   # In daemon.py main loop, after each iteration:
   if UAOS_ENABLED:
       uaos_bus.publish('dream.evolved', 'dream_weaver', {
           'dream_id': incubation_id,
           'iteration': result.get('current_iteration'),
           'status': result.get('status')
       }, entity_id=incubation_id)

       if status == 'complete':
           uaos_bus.publish('dream.emerged', 'dream_weaver', {
               'dream_id': incubation_id,
               'seed_idea': result.get('idea', '')
           }, entity_id=incubation_id)

   # In the main agent's heartbeat handler, after each check:
   if UAOS_ENABLED:
       uaos_bus.publish('heartbeat.check.completed', 'heartbeat', {
           'domain': domain,
           'status': check_status,
           'alert_level': alert_level
       })

   # scripts/verify_sync.py
   # Compare every legacy file against state.db rows
   # Report any discrepancies

   #!/usr/bin/env python3
   """
   Unified Agent OS Daemon

   Replaces:
   - Dream Weaver daemon.py (evolution loop)
   - Noosphere bridge sync
   - Heartbeat state management

   Adds:
   - Event processing loop
   - Handoff monitoring
   - Account usage tracking
   """

   import asyncio
   import signal
   from uaos.db import StateDB
   from uaos.events import EventBus
   from uaos.config import load_config
   from uaos.loops import (
       dream_evolution_loop,
       heartbeat_check_loop,
       event_processing_loop,
       handoff_monitor_loop,
       account_reset_loop,
   )

   async def main():
       config = load_config()
       db = StateDB(config.database.path)
       bus = EventBus(db)
       setup_listeners(bus, db)

       # Start all loops
       tasks = [
           asyncio.create_task(dream_evolution_loop(db, bus, config)),
           asyncio.create_task(heartbeat_check_loop(db, bus, config)),
           asyncio.create_task(event_processing_loop(db, bus, config)),
           asyncio.create_task(handoff_monitor_loop(db, bus, config)),
           asyncio.create_task(account_reset_loop(db, config)),
       ]

       bus.publish('system.startup', 'uaos', {'loops': len(tasks)})

       await asyncio.gather(*tasks)

   if __name__ == '__main__':
       asyncio.run(main())

   # Stop old daemon
   python3 [home-path] stop

   # Start unified daemon
   python3 [home-path] start

   # Check PID
   cat [home-path]

   # Check logs
   tail -20 [home-path]

   # Check events
   sqlite3 [home-path] "SELECT topic, COUNT(*) FROM events GROUP BY topic ORDER BY COUNT(*) DESC"

   // In claude_desktop_config.json
   {
     "mcpServers": {
       "uaos": {
         "command": "python3",
         "args": ["[home-path]
         "env": {}
       }
     }
   }

   # Test each tool category:
   uaos.pulse.start → creates session in state.db
   uaos.pulse.status → reads from state.db
   uaos.dream.incubate → creates dream in state.db
   uaos.dream.evolve → advances dream, publishes event
   uaos.context → returns SharedContext
   uaos.handoff.create → creates handoff record
   uaos.events.query → queries event log

   # Pulse sessions: generate JSON files from state.db on read
   # (implement a FUSE mount or a simpler file-watcher approach)

   mkdir -p [home-path]
   cp -r [home-path] [home-path]
   cp [home-path] [home-path]
   cp [home-path] [home-path]

   # daemon.py, daemon.pid, daemon.log from [home-path]
   # These are superseded by [home-path]

   # In enriched_spawn.py, add after project context:

   def get_uaos_context_block() -> str:
       """Get cross-system context for enriched prompts."""
       try:
           from uaos.context import ContextBuilder
           from uaos.db import StateDB
           ctx = ContextBuilder(StateDB()).build()
           return f"""
   ## UAOS Context
   {ctx.brief()}

   Active Dreams: {len(ctx.gestating_dreams)} gestating, {len(ctx.metamorphosis_ready)} ready
   Active Sessions: {len(ctx.active_sessions)}
   Hot Keywords: {', '.join(ctx.hot_keywords[:5])}
   """
       except Exception:
           return ""

   python3 [home-path] dashboard
   # Shows the ASCII dashboard from ARCHITECTURE.md

Phase 0 ──▶ Phase 1 ──▶ Phase 3 ──▶ Phase 4 ──▶ Phase 5 ──▶ Phase 6
                    └──▶ Phase 2 ──┘         └──▶ Phase 7
                                              └──▶ Phase 8 ──▶ Phase 9