fix(ui): the thought stream had no reader

Seventy-two modules emit into `ThoughtEmitter`. It broadcasts to listeners
that call `register`, and nothing in the codebase calls it. The neural feed is
fed from the event bus, which the interface bridge subscribes to with a
wildcard, so every one of those emits has been going nowhere — including a
pursuit narrating each choice as it made it.

Bridging inside the emitter rather than at the call sites makes all of them
visible at once, and anything written later reaches the interface without
having to know any of this. A bus that is missing or broken degrades and the
work continues; a thought that cannot be shown is not worth failing the work
that produced it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: codex

core/thought_stream.py

@@ -52,6 +52,40 @@ async def unregister(self, queue):
             if queue in self.listeners:
                 self.listeners.discard(queue)
 
+    @staticmethod
+    def _also_tell_the_interface(message: dict) -> None:
+        """Put the thought where the interface is actually looking.
+
+        This emitter broadcasts to listeners that register with it, and nothing
+        in the codebase registers — seventy-two modules have been emitting into
+        a channel with no reader. The neural feed is fed from the event bus,
+        which the interface bridge subscribes to with a wildcard.
+
+        Bridging here rather than at the call sites means every existing
+        emitter becomes visible at once, and anything written later reaches the
+        interface without having to know this.
+        """
+
+        try:
+            from core.event_bus import get_event_bus
+
+            bus = get_event_bus()
+            if bus is None:
+                return
+            payload = {
+                "content": str(message.get("content") or ""),
+                "phase": str(message.get("category") or "cognition"),
+                "title": str(message.get("title") or ""),
+                "urgency": "NORMAL" if message.get("level") != "warning" else "HIGH",
+            }
+            publish = getattr(bus, "publish_threadsafe", None)
+            if callable(publish):
+                publish("thoughts", payload)
+        except Exception as exc:
+            # A thought that cannot be shown is not worth failing the work that
+            # produced it.
+            record_degradation("thought_stream", exc, action="thought not bridged to the interface")
+
     def emit(self, title: str, content: str, level: str = "info", category: str = "General", **kwargs):
         """Broadcast a thought/event to all listeners.
         Thread-safe: Can be called from sync threads (Orchestrator).
@@ -65,6 +99,8 @@ def emit(self, title: str, content: str, level: str = "info", category: str = "G
         }
         message.update(kwargs)
 
+        self._also_tell_the_interface(message)
+
         with self._lock:
             loop = self._loop
             if loop is None:

tests/test_thoughts_reach_the_interface.py

@@ -0,0 +1,48 @@
+"""Seventy-two modules emitted into a channel with no reader.
+
+`ThoughtEmitter` broadcasts to listeners that call `register`, and nothing in
+the codebase calls it. The interface's neural feed is fed from the event bus
+instead, so every one of those emits was invisible — including a pursuit
+narrating its choices while it worked.
+"""
+
+from __future__ import annotations
+
+import core.thought_stream as thought_stream
+from core.thought_stream import ThoughtEmitter
+
+
+class _Bus:
+    def __init__(self):
+        self.published = []
+
+    def publish_threadsafe(self, topic, data, priority=None):
+        self.published.append((topic, data))
+
+
+def test_an_emitted_thought_is_published_where_the_interface_reads(monkeypatch):
+    bus = _Bus()
+    monkeypatch.setattr("core.event_bus.get_event_bus", lambda: bus)
+
+    ThoughtEmitter().emit("Browsing", "Question 4 -> I agree", category="ToolExecution")
+
+    assert bus.published, "the thought never reached the bus the interface subscribes to"
+    topic, payload = bus.published[-1]
+    assert topic == "thoughts", "the bridge forwards the topic the UI renders as a thought"
+    assert payload["content"] == "Question 4 -> I agree"
+    assert payload["title"] == "Browsing"
+
+
+def test_a_broken_bus_never_breaks_the_work(monkeypatch):
+    def explode():
+        raise RuntimeError("bus down")
+
+    monkeypatch.setattr("core.event_bus.get_event_bus", explode)
+    recorded = []
+    monkeypatch.setattr(
+        thought_stream, "record_degradation", lambda *a, **k: recorded.append(a)
+    )
+
+    ThoughtEmitter().emit("Browsing", "still working")
+
+    assert recorded, "a thought that cannot be shown must degrade, not vanish silently"