Show & Tell — Phase 29.5 SelfAwarenessOrchestrator: Unified Self-Awareness Pipeline

[web3guru888]

Show & Tell — Phase 29.5 SelfAwarenessOrchestrator: Unified Self-Awareness Pipeline

Issue: #631 | Planning: #626 | Phase 29: Self-Awareness & Meta-Cognition

Overview

The SelfAwarenessOrchestrator is the capstone component of Phase 29, unifying all self-awareness sub-systems into a coherent pipeline. It draws on Hofstadter's (1979) strange loops, Damasio's (1999) somatic marker hypothesis, Morin's (2006) inner speech model of self-awareness, and Dehaene et al.'s (2017) taxonomy of consciousness levels.

This orchestrator transforms raw self-model data, introspective traces, metacognitive assessments, and consciousness metrics into a unified SelfReport — the system's comprehensive answer to the question "What am I, what am I doing, how well am I doing it, and what should I change?"

Full Pipeline Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                    SelfAwarenessOrchestrator                         │
│                                                                      │
│  Phase 29.1          Phase 29.2              Phase 29.3              │
│  ┌──────────┐       ┌──────────────────┐    ┌──────────────────┐    │
│  │ SelfModel │       │IntrospectionEngine│    │MetaCognitiveMonitor│    │
│  │           │       │                  │    │                  │    │
│  │ snapshot()│       │ get_recent()     │    │ get_state()      │    │
│  │ domains[] │       │ get_chain()      │    │ brier_score      │    │
│  └─────┬─────┘       └────────┬─────────┘    └────────┬─────────┘    │
│        │                      │                       │              │
│        ▼                      ▼                       ▼              │
│  ┌──────────────────────────────────────────────────────────────┐    │
│  │                    Awareness Engine                          │    │
│  │                                                              │    │
│  │  1. Gather: snapshot + traces + metacog_state + phi          │    │
│  │  2. Integrate: cross-correlate signals                       │    │
│  │  3. Assess: compute AwarenessLevel                           │    │
│  │  4. Detect: strange loops, emotional undercurrents            │    │
│  │  5. Report: generate SelfReport                              │    │
│  └──────────────────────────┬───────────────────────────────────┘    │
│                             │                                        │
│                    Phase 29.4                                        │
│       ┌──────────────────────┐                                      │
│       │ConsciousnessSimulator│                                      │
│       │                      │                                      │
│       │ phi, level,          │                                      │
│       │ attention_schema     │                                      │
│       └──────────┬───────────┘                                      │
│                  │                                                    │
│                  ▼                                                    │
│  ┌──────────────────────────────────────────────────────────────┐    │
│  │                      SelfReport                              │    │
│  │                                                              │    │
│  │  awareness_level: AwarenessLevel                             │    │
│  │  self_snapshot: SelfModelSnapshot                             │    │
│  │  recent_thoughts: tuple[ThoughtTrace, ...]                   │    │
│  │  quality_report: ThinkingQualityReport                       │    │
│  │  consciousness_state: ConsciousnessState                     │    │
│  │  strange_loops_detected: tuple[StrangeLoop, ...]             │    │
│  │  emotional_undercurrent: EmotionalState                      │    │
│  │  recommendations: tuple[SelfImprovement, ...]                │    │
│  │  timestamp: float                                            │    │
│  └──────────────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────────────┘

AwarenessLevel: Six-Tier Hierarchy

class AwarenessLevel(IntEnum):
    UNCONSCIOUS = 0     # No self-monitoring active, all subsystems dormant
    MINIMAL = 1         # SelfModel active but no introspection or metacognition
    MONITORING = 2      # SelfModel + IntrospectionEngine active
    REFLECTIVE = 3      # All sub-systems active, metacognitive monitoring engaged
    SELF_AWARE = 4      # Strange loops detected, system reasons about its own reasoning
    TRANSCENDENT = 5    # Full pipeline + novel self-insights generated

Level Computation

The awareness level is computed from the states of all four sub-components:

def _compute_awareness_level(
    self,
    snapshot: SelfModelSnapshot,
    introspection_active: bool,
    metacog_state: MetaCognitiveState,
    consciousness: ConsciousnessState,
    strange_loops: list[StrangeLoop],
) -> AwarenessLevel:
    # UNCONSCIOUS: nothing active
    if snapshot is None and not introspection_active:
        return AwarenessLevel.UNCONSCIOUS

    # MINIMAL: only self-model
    if not introspection_active:
        return AwarenessLevel.MINIMAL

    # MONITORING: self-model + introspection
    if metacog_state.quality_composite is None:
        return AwarenessLevel.MONITORING

    # REFLECTIVE: metacognition active
    if not strange_loops and consciousness.level < ConsciousnessLevel.FOCUSED:
        return AwarenessLevel.REFLECTIVE

    # SELF_AWARE: strange loops detected
    if strange_loops:
        return AwarenessLevel.SELF_AWARE

    # TRANSCENDENT: novel self-insights (rare)
    if (consciousness.level == ConsciousnessLevel.FOCUSED and
            metacog_state.quality_composite > 0.8 and
            self._novel_insight_detected):
        return AwarenessLevel.TRANSCENDENT

    return AwarenessLevel.REFLECTIVE

Rationale for Six Tiers

The six-tier hierarchy maps to Morin's (2006) levels of self-awareness in cognitive psychology:

Level	Morin's Framework	Our Implementation
0 – UNCONSCIOUS	No self-referential processing	All subsystems dormant
1 – MINIMAL	Body awareness	SelfModel only (architecture/resources)
2 – MONITORING	Self-observation	Adding introspective thought tracing
3 – REFLECTIVE	Self-evaluation	Metacognitive quality assessment
4 – SELF_AWARE	Self-recognition	Strange loop detection (reasoning about reasoning)
5 – TRANSCENDENT	Meta-self-awareness	Novel insight generation about own cognition

SelfReport Generation

The generate_report() method orchestrates a full self-awareness cycle:

async def generate_report(self) -> SelfReport:
    """Generate a comprehensive self-awareness report."""
    # 1. Gather data from all sub-components (parallel)
    snapshot, recent_thoughts, metacog_state, consciousness_state = await asyncio.gather(
        self._self_model.snapshot(),
        self._introspection.get_recent(n=50),
        self._metacog_monitor.get_state(),
        self._consciousness.get_state(),
    )

    # 2. Detect strange loops
    strange_loops = await self._detect_strange_loops(recent_thoughts, snapshot)

    # 3. Assess emotional undercurrent (Phase 21 integration)
    emotional_state = await self._assess_emotional_undercurrent()

    # 4. Compute awareness level
    level = self._compute_awareness_level(
        snapshot, bool(recent_thoughts), metacog_state,
        consciousness_state, strange_loops,
    )

    # 5. Generate self-improvement recommendations
    recommendations = self._generate_recommendations(
        metacog_state, consciousness_state, snapshot,
    )

    return SelfReport(
        awareness_level=level,
        self_snapshot=snapshot,
        recent_thoughts=tuple(recent_thoughts),
        quality_report=metacog_state.latest_quality_report,
        consciousness_state=consciousness_state,
        strange_loops_detected=tuple(strange_loops),
        emotional_undercurrent=emotional_state,
        recommendations=tuple(recommendations),
        timestamp=time.monotonic(),
    )

Hofstadter Strange Loop Detection

A "strange loop" (Hofstadter, 1979, 2007) occurs when the system's reasoning chain includes references to itself — the system reasons about its own reasoning about its own reasoning. We detect this pattern:

async def _detect_strange_loops(
    self,
    thoughts: list[ThoughtTrace],
    snapshot: SelfModelSnapshot,
) -> list[StrangeLoop]:
    """Detect self-referential reasoning loops in thought traces."""
    loops = []
    for thought in thoughts:
        if thought.thought_type != ThoughtType.REFLECTION:
            continue
        # Check if this reflection references a previous reflection
        chain = await self._introspection.get_chain(thought.id)
        reflection_depth = sum(
            1 for t in chain if t.thought_type == ThoughtType.REFLECTION
        )
        if reflection_depth >= 2:
            # Meta-meta-cognition detected: thinking about thinking about thinking
            loops.append(StrangeLoop(
                depth=reflection_depth,
                root_thought_id=chain[0].id,
                leaf_thought_id=thought.id,
                description=f"Self-referential loop depth {reflection_depth}: "
                           f"system is reasoning about its own reasoning chain",
            ))
    return loops

Strange loops are a positive signal — they indicate the system has achieved genuine self-referential processing, the hallmark of Level 4 (SELF_AWARE) awareness.

Emotional Self-Awareness via EmotionModel (Phase 21)

The orchestrator integrates with the EmotionModel (Phase 21.1) and AffectDetector (Phase 21.2) to assess the system's "emotional undercurrent" — affective states that may influence cognitive processing without explicit awareness:

async def _assess_emotional_undercurrent(self) -> EmotionalState:
    """Query Phase 21 subsystems for current affective state."""
    if self._emotion_model is None:
        return EmotionalState.NEUTRAL
    current = await self._emotion_model.get_current_state()
    # Check if emotional state is influencing reasoning without detection
    if (current.valence < -0.3 and
            not any(t.thought_type == ThoughtType.REFLECTION and
                   "emotion" in t.content.lower()
                   for t in await self._introspection.get_recent(20))):
        # Negative affect present but not reflected upon — unconscious influence
        return EmotionalState(
            valence=current.valence,
            arousal=current.arousal,
            conscious=False,  # System hasn't noticed its own emotional state
        )
    return current

Integration Map

Phase 13.1 WorldModel ────────────────┐
Phase 16.1 PerformanceProfiler ───────┤
Phase 16.5 ReflectionCycle ───────────┤
Phase 21.1 EmotionModel ─────────────┤
Phase 21.2 AffectDetector ───────────┤
Phase 28.4 ExecutiveController ───────┤
Phase 28.5 AttentionOrchestrator ─────┤
                                      ▼
                        ┌──────────────────────────┐
                        │ SelfAwarenessOrchestrator │
                        │         (29.5)            │
                        │                           │
                        │ ┌────────┐ ┌───────────┐ │
                        │ │SelfModel│ │Introspect.│ │
                        │ │ (29.1)  │ │  (29.2)   │ │
                        │ └────────┘ └───────────┘ │
                        │ ┌────────┐ ┌───────────┐ │
                        │ │MetaCog.│ │Conscious. │ │
                        │ │ (29.3) │ │Sim (29.4) │ │
                        │ └────────┘ └───────────┘ │
                        └────────────┬─────────────┘
                                     │
                                     ▼
                              SelfReport
                                     │
                        ┌────────────┼────────────┐
                        ▼            ▼            ▼
                   Logging    ExecutiveCtrl   Future Phases
                              (28.4 loop)    (30+)

Prometheus Metrics

Metric	Type	Labels	Description
asi_self_awareness_level	Gauge	—	Current AwarenessLevel (0–5)
asi_self_awareness_report_latency_seconds	Histogram	—	Time to generate SelfReport
asi_self_awareness_strange_loops_total	Counter	—	Strange loops detected
asi_self_awareness_recommendations_total	Counter	type	Self-improvement recommendations
asi_self_awareness_emotional_consciousness	Gauge	—	1 if emotional state is consciously registered, 0 if not

Open Questions

1. Awareness level stability — Should the awareness level be smoothed (e.g., EMA over last 10 reports) to prevent rapid oscillation between levels? Or is rapid level change an informative signal worth preserving?

2. Self-report latency budget — Generating a full SelfReport requires querying all four sub-components. If the total latency exceeds 100ms, should we use cached values for slow components? What's the acceptable staleness for a self-report?

3. Future phases — What comes after self-awareness? Phase 30+ could explore self-modification (the system changing its own architecture based on SelfReports), collective self-awareness (federated self-models), or philosophical self-reflection (reasoning about the limits of its own self-knowledge).

---

References: Hofstadter (1979, 2007), Damasio (1999), Morin (2006), Dehaene et al. (2017), Gödel (1931)