refactor: split runtime into modules, trim orchestrator prompt, cleanup

Split the monolithic atn/runtime.py (3250 lines) into focused modules:
- runtime/__init__.py: Runtime class core, init, shutdown
- runtime/agent_registry.py: agent register/unregister/activate
- runtime/execution_engine.py: pipeline + cognitive execution
- runtime/provider_manager.py: LLM provider lifecycle
- runtime/scheduler.py: cron + heartbeat scheduling
- runtime/session_manager.py: conversation + delegate session mgmt
- runtime/snapshot.py: fleet snapshot for dashboard
- runtime/execution_control.py: kill switches
- runtime/orchestrator_setup.py: orchestrator agent bootstrap
- runtime/config_helpers.py: config persistence helpers

Other changes:
- Trim orchestrator system prompt (~40% smaller, same semantics)
- Add delegation-first thinking guidance to orchestrator
- Auto-activate agents with heartbeats (not just schedules)
- Add voice announcement categories config
- Sanitize corrupted conversation history on hydration
- Add cognitive step parent-child wake-up notifications
- Bridge provider delegate lifecycle events
- Remove stale files (BACKLOG.md, rpb_presentation.md, slide_prompts.txt)
- Add architecture audit doc and orchestrator prompt reference

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Author: EightRice

BACKLOG.md

@@ -329,9 +329,9 @@ async def _load_agents(runtime: Runtime, config: ATNConfig) -> int:
     elif not errors:
         console.print(f"  [dim]No agent files in {config.agents_dir}[/]")
 
-    # Auto-activate agents that have schedules
+    # Auto-activate agents that have schedules or heartbeats
     for defn in agents:
-        if defn.schedule:
+        if defn.schedule or defn.heartbeat:
             await runtime.activate_agent(defn.id)
 
     return len(agents)

atn/cli.py

@@ -77,6 +77,9 @@ class VoiceConfig:
     tools_volume: float = 0.55
     effects_volume: float = 0.35
     narrate_tools: bool = True
+    announcements: list[str] = field(default_factory=lambda: [
+        "agent_runs", "agent_created", "agent_completed", "delegate_lifecycle"
+    ])
     output_device: str | None = None
     input_device: str | None = None
     kokoro_model_dir: str | None = None   # directory containing kokoro-v1.0.onnx
@@ -246,6 +249,9 @@ def load_config(path: Path | None = None) -> ATNConfig:
             tools_volume=voice_raw.get("tools_volume", 0.55),
             effects_volume=voice_raw.get("effects_volume", 0.35),
             narrate_tools=voice_raw.get("narrate_tools", True),
+            announcements=voice_raw.get("announcements", [
+                "agent_runs", "agent_created", "agent_completed", "delegate_lifecycle"
+            ]),
             output_device=voice_raw.get("output_device"),
             input_device=voice_raw.get("input_device"),
             kokoro_model_dir=voice_raw.get("kokoro_model_dir"),

atn/config.py

@@ -266,7 +266,72 @@ def _hydrate(self) -> None:
             return
         self._turns = self._load_jsonl(self._active_path)
         if self._turns:
-            log.info("Hydrated active conversation: %d turns", len(self._turns))
+            dirty = self._sanitize_turns()
+            log.info("Hydrated active conversation: %d turns%s",
+                     len(self._turns), " (sanitized)" if dirty else "")
+
+    def _sanitize_turns(self) -> bool:
+        """Fix user turns that were corrupted by history-prepending.
+
+        Prior to the fix, the execution engine stored the full prompt
+        (including ``System: ...``, ``User: ...``, ``Orchestrator: ...``
+        history) as a single user turn.  This strips those back to just
+        the actual user message and removes exact duplicates.
+        """
+        dirty = False
+        cleaned: list[ConversationTurn] = []
+        for turn in self._turns:
+            content = turn.content
+            # Detect history-embedded user turns: content has role prefixes
+            # like "System: ...\nUser: ...\nOrchestrator: ..." baked in.
+            if turn.role == "user" and "\nUser: " in content and (
+                content.startswith("System: ")
+                or content.startswith("User: ")
+                or "\nOrchestrator: " in content
+            ):
+                # Extract the last "User: ..." segment as the real message.
+                parts = content.split("\nUser: ")
+                raw = parts[-1].strip()
+                if raw:
+                    turn = ConversationTurn(
+                        role="user", content=raw,
+                        timestamp=turn.timestamp,
+                        execution_id=turn.execution_id,
+                    )
+                    dirty = True
+            # Strip leading "[Current time: ...]\n\n" injected by the engine
+            if turn.role == "user" and turn.content.startswith("[Current time:"):
+                newline_idx = turn.content.find("\n\n")
+                if newline_idx != -1:
+                    turn = ConversationTurn(
+                        role=turn.role,
+                        content=turn.content[newline_idx + 2:],
+                        timestamp=turn.timestamp,
+                        execution_id=turn.execution_id,
+                    )
+                    dirty = True
+            # Deduplicate consecutive identical turns
+            if cleaned and cleaned[-1].role == turn.role and cleaned[-1].content == turn.content:
+                dirty = True
+                continue
+            cleaned.append(turn)
+        if dirty:
+            self._turns = cleaned
+            self._rewrite_active()
+        return dirty
+
+    def _rewrite_active(self) -> None:
+        """Rewrite the active JSONL from the in-memory turns."""
+        tmp = self._active_path.with_suffix(".jsonl.tmp")
+        try:
+            with open(tmp, "w", encoding="utf-8") as f:
+                for turn in self._turns:
+                    f.write(json.dumps(turn.to_dict(), ensure_ascii=False) + "\n")
+            tmp.replace(self._active_path)
+        except Exception:
+            log.exception("Failed to rewrite sanitized conversation")
+            if tmp.exists():
+                tmp.unlink()
 
     @staticmethod
     def _load_jsonl(path: Path) -> list[ConversationTurn]:

atn/conversation.py

@@ -102,7 +102,7 @@ async def run_server() -> None:
         agents, errors = load_agents_dir(config.agents_dir)
         for defn in agents:
             await rt.register_agent(defn)
-            if defn.schedule:
+            if defn.schedule or defn.heartbeat:
                 await rt.activate_agent(defn.id)
         # Note: execution history is hydrated automatically in register_agent()
         if agents: