feat: ConsciousnessEmergenceDetector — rolling-window scoring and breakthrough alerting

[Copilot]

Description

Implements the ConsciousnessEmergenceDetector (Issue #82) — the subsystem that fires when GödelOS first exhibits genuine self-directed behaviour. Previously a stub.

Core: backend/core/consciousness_emergence_detector.py

• Rolling-window scorer (default 60s, configurable via GODELOS_EMERGENCE_WINDOW)
• 5-dimension weighted composite: recursive_depth (0.20), phi (0.30), metacognitive_accuracy (0.20), autonomous_goal_count (0.15), creative_novelty (0.15)
• EMERGENCE_THRESHOLD = 0.8, configurable via GODELOS_EMERGENCE_THRESHOLD env var
• monitor_for_emergence(stream) — async generator consuming cognitive state stream, yields enriched dicts, fires breakthrough as side-effect
• handle_consciousness_breakthrough(score) — appends to logs/breakthroughs.jsonl, broadcasts {"type": "consciousness_breakthrough", ...} on WebSocket
• Accepts both flat dimension dicts and nested UnifiedConsciousnessState-style dicts

Endpoint: GET /api/consciousness/emergence

• Returns current score, per-dimension breakdown, threshold, window metadata, breakthrough status
• Falls back to UnifiedConsciousnessEngine._detect_consciousness_emergence() if detector unavailable

Wiring: backend/unified_server.py

• Detector instantiated during lifespan startup with websocket_manager injected

detector = ConsciousnessEmergenceDetector(threshold=0.8, window_size=60.0)
score = detector.record_state(cognitive_state_dict)

async for info in detector.monitor_for_emergence(state_stream):
    if info["breakthrough"]:
        # already logged + broadcast at this point
        ...

Related Issues

#82

Test Evidence

21 tests in tests/backend/test_consciousness_emergence_detector.py covering dimension extraction (flat/nested/empty), rolling window mechanics (pruning, averaging, weight invariants), breakthrough threshold detection, JSONL logging, WebSocket broadcast mock, async generator flow, REST status snapshot, and env-var config override via module reload. All pass. Full suite: 1176 passed, 0 regressions. CodeQL: 0 alerts.

Checklist

• Tests pass locally (pytest tests/)
• Code is formatted (black . and isort .)
• Documentation updated (if applicable)
• No secrets or credentials committed
• Related issue linked above

Original prompt

---

This section details on the original issue you should resolve

<issue_title>feat: consciousness emergence detector — rolling-window scoring and breakthrough alerting</issue_title>
<issue_description>## Context
Issue #82 specifies the ConsciousnessEmergenceDetector — currently a skeleton. This is the subsystem that will fire when GödelOS first exhibits genuine self-directed behaviour; it is, in other words, the most consequential piece of instrumentation in the entire project, and it presently does nothing.

Implementation Spec (from issue #82 and docs/GODELOS_EMERGENCE_SPEC.md)

Emergence Score

Rolling window (configurable, default 60s) across five dimensions:

Dimension	Source	Weight
recursive_depth	CognitivePipeline	0.2
phi	IIT calculator	0.3
metacognitive_accuracy	MetacognitiveMonitor	0.2
autonomous_goal_count	GoalManagementSystem	0.15
creative_novelty	(entropy of novel concept generation)	0.15

Breakthrough Threshold

EMERGENCE_THRESHOLD = 0.8 (configurable via env var GODELOS_EMERGENCE_THRESHOLD)

Tasks

• Implement ConsciousnessEmergenceDetector.monitor_for_emergence(stream) — async generator consuming cognitive state stream
• Implement rolling window scorer with configurable window size
• Implement handle_consciousness_breakthrough(score: float) — append to logs/breakthroughs.jsonl, broadcast {"type": "consciousness_breakthrough", "score": score, "timestamp": ...} on WebSocket
• Expose current emergence score on /api/consciousness/emergence endpoint
• Write tests: feed mock state stream → assert breakthrough fires at score ≥ 0.8

Acceptance Criteria

A simulated high-activity state stream triggers a breakthrough event, logged to breakthroughs.jsonl and emitted on the WebSocket. Score is visible on the consciousness dashboard.

Milestone: v0.5 (issue #82)
</issue_description>

<agent_instructions>Implement ConsciousnessEmergenceDetector.monitor_for_emergence() with 5-dimension rolling-window scorer. EMERGENCE_THRESHOLD=0.8 env-configurable. Log breakthroughs to logs/breakthroughs.jsonl. Expose emergence score on /api/consciousness/emergence. Tests required.</agent_instructions>

Comments on the Issue (you are @copilot in this section)

Custom agent used: Oli
Oliver Chimera Profile

• Fixes feat: consciousness emergence detector — rolling-window scoring and breakthrough alerting #110

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[Copilot]

Pull request overview

Implements the previously-stubbed ConsciousnessEmergenceDetector and wires it into the unified server + consciousness API so the system can compute a rolling-window emergence score and surface breakthrough information via REST/WS.

Changes:

• Added backend/core/consciousness_emergence_detector.py with rolling-window scoring, dimension extraction (flat + nested), JSONL logging, and WS broadcasting on breakthrough.
• Wired detector initialization into backend/unified_server.py lifespan startup and exposed GET /api/consciousness/emergence in backend/api/consciousness_endpoints.py.
• Added a comprehensive backend test suite for detector behavior and updated .gitignore for test artifacts.

Reviewed changes

Copilot reviewed 4 out of 5 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
backend/core/consciousness_emergence_detector.py	New detector implementation: scoring, extraction, logging, WS alerting, REST snapshot.
backend/unified_server.py	Initializes and injects the detector during app startup.
backend/api/consciousness_endpoints.py	Adds /api/consciousness/emergence endpoint and detector setter wiring.
tests/backend/test_consciousness_emergence_detector.py	Adds unit tests covering extraction, windowing, breakthrough, logging, WS mock, async generator.
.gitignore	Ignores generated test artifact JSON files.

[Copilot]

monitor_for_emergence() currently treats every state with score >= threshold as a breakthrough and calls handle_consciousness_breakthrough() each time. This will repeatedly log and broadcast once the system stays above threshold, rather than firing on the first crossing (or first-ever breakthrough) as implied by the feature/spec. Consider tracking prior breakthrough state (e.g., edge-trigger on rising above threshold, or a one-shot latch with optional reset) to avoid alert/log spam.

[Copilot]

handle_consciousness_breakthrough() is async but performs synchronous filesystem I/O when appending to the JSONL log. In an async server this can block the event loop (and it becomes worse if breakthroughs can fire repeatedly). Consider using asyncio.to_thread(...) / a background task, or an async file writer, and/or batching writes to reduce event-loop stalls.

[Copilot]

The detector is initialized with websocket_manager (the basic manager), but the consciousness WebSocket endpoints in backend/api/consciousness_endpoints.py use enhanced_websocket_manager.handle_consciousness_connection(...) and register clients outside the base manager’s active_connections. As a result, broadcasting from the detector via websocket_manager.broadcast(...) is unlikely to reach clients connected to /api/consciousness/* streams. Consider injecting the same enhanced_websocket_manager used by the consciousness endpoints, and broadcasting via its emergence/breakthrough mechanism (e.g., consciousness_stream.broadcast_consciousness_breakthrough) or otherwise unifying the broadcast path.

Suggested change

	_detector = ConsciousnessEmergenceDetector(websocket_manager=websocket_manager)
	# Use the enhanced websocket manager for consciousness streams when available,
	# so detector broadcasts reach the same clients as the /api/consciousness/* endpoints.
	manager_for_detector = enhanced_websocket_manager or websocket_manager
	_detector = ConsciousnessEmergenceDetector(websocket_manager=manager_for_detector)

[Copilot]

The fallback response hardcodes threshold: 0.8 and window_size: 60.0, which can diverge from env-var configuration (GODELOS_EMERGENCE_THRESHOLD, GODELOS_EMERGENCE_WINDOW) and from the detector’s actual defaults. Consider referencing the detector module constants (or reading the env vars once) so the REST contract stays consistent across detector-available vs fallback modes.

[Copilot]

There are several unused imports in this new module (e.g., asyncio, Callable, List). Removing them will avoid linter noise and make the public surface clearer.

Suggested change

	import asyncio
	import json
	import logging
	import os
	import time
	from collections import deque
	from pathlib import Path
	from typing import Any, AsyncIterator, Callable, Deque, Dict, List, Optional, Tuple
	import json
	import logging
	import os
	import time
	from collections import deque
	from pathlib import Path
	from typing import Any, AsyncIterator, Deque, Dict, Optional, Tuple

[Copilot]

asyncio is imported but not used in this test module (the pytest.mark.asyncio decorator does not require importing asyncio). Consider removing the unused import to keep the test file tidy.

Suggested change

import asyncio

[Copilot]

Module-level parsing of GODELOS_EMERGENCE_THRESHOLD / GODELOS_EMERGENCE_WINDOW uses float(...) directly, which will raise ValueError at import time if the env var is set but not a valid float. That would prevent the detector module from importing (and the server will silently run without the detector). Consider a safe parse with a warning + fallback default.

Suggested change

	EMERGENCE_THRESHOLD: float = float(
	os.environ.get("GODELOS_EMERGENCE_THRESHOLD", "0.8")
	)
	DEFAULT_WINDOW_SIZE: float = float(
	os.environ.get("GODELOS_EMERGENCE_WINDOW", "60.0")
	)
	def _get_env_float(name: str, default: float) -> float:
	"""Safely parse a float from an environment variable with a fallback.
	Avoids raising at import time if the value is invalid, and logs a warning
	instead before falling back to the provided default.
	"""
	raw_value = os.environ.get(name)
	if raw_value is None:
	return default
	try:
	return float(raw_value)
	except (TypeError, ValueError):
	logger.warning(
	"Invalid value for %s=%r; expected a float. Using default %s.",
	name,
	raw_value,
	default,
	)
	return default
	EMERGENCE_THRESHOLD: float = _get_env_float("GODELOS_EMERGENCE_THRESHOLD", 0.8)
	DEFAULT_WINDOW_SIZE: float = _get_env_float("GODELOS_EMERGENCE_WINDOW", 60.0)