feat: wire StatePersistence, ReasoningTraces, and StrategyCache into orchestrator (#4, #15)

Connect three existing but disconnected components into the RLM
orchestrator's post-execution path. StatePersistence now tracks
session state and trajectory counts, ReasoningTraces receives
trajectory events for SPEC-04 decision graphs, and StrategyCache
learns from successful runs per Spec §8.1.

Also adds Python fallback hook scripts for session-init and
trajectory-save, and hardens RLMSessionState.from_dict() to
tolerate unknown fields from schema drift.

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

Author: rand

scripts/session-init.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+"""Session initialization hook (Python fallback).
+
+Called by hook-dispatch.sh when Go binary is unavailable.
+Initializes RLM session state for cross-hook persistence.
+"""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+try:
+    from state_persistence import get_persistence
+
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+    persistence = get_persistence()
+    persistence.init_session(session_id)
+    persistence.save_state()
+    print(json.dumps({"status": "initialized", "session_id": session_id}))
+except Exception as e:
+    # Fail-open: don't block Claude Code
+    print(json.dumps({"status": "skipped", "reason": str(e)}))

scripts/trajectory-save.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Trajectory save hook (Python fallback).
+
+Called by hook-dispatch.sh when Go binary is unavailable.
+Reads persisted session state and outputs a trajectory summary.
+"""
+
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+try:
+    from state_persistence import get_persistence
+
+    session_id = os.environ.get("CLAUDE_SESSION_ID", "default")
+    persistence = get_persistence()
+    persistence.restore_state(session_id)
+    state = persistence.current_state
+    summary = {
+        "session_id": session_id,
+        "trajectory_events": state.trajectory_events_count if state else 0,
+        "trajectory_path": state.trajectory_path if state else None,
+        "tokens_used": state.total_tokens_used if state else 0,
+    }
+    print(json.dumps({"status": "saved", "summary": summary}))
+except FileNotFoundError:
+    print(json.dumps({"status": "skipped", "reason": "no_session_state"}))
+except Exception as e:
+    print(json.dumps({"status": "skipped", "reason": str(e)}))

src/orchestrator/core.py

@@ -24,6 +24,7 @@
 
 from ..api_client import ClaudeClient, Provider, init_client
 from ..memory_store import MemoryStore
+from ..state_persistence import StatePersistence
 
 # ============================================================================
 # Error Recovery (SPEC-12.10)
@@ -125,6 +126,7 @@ def __init__(
         client: ClaudeClient | None = None,
         smart_routing: bool = True,
         memory_store: MemoryStore | None = None,
+        persistence: StatePersistence | None = None,
         auto_memory: bool = True,
         error_recovery: ErrorRecoveryConfig | None = None,
         verification_config: VerificationConfig | None = None,
@@ -137,6 +139,7 @@ def __init__(
             client: Claude API client (creates one if None)
             smart_routing: Enable intelligent model routing based on query type
             memory_store: Optional memory store for auto-memory integration
+            persistence: Optional state persistence for cross-session state (#4)
             auto_memory: If True and memory_store provided, auto-store findings
             error_recovery: Configuration for error recovery strategies
             verification_config: Epistemic verification config (uses default if None)
@@ -148,6 +151,7 @@ def __init__(
         self.smart_routing = smart_routing
         self._router: SmartRouter | None = None
         self._memory_store = memory_store
+        self._persistence = persistence
         self._auto_memory = auto_memory
         self._error_recovery = error_recovery or ErrorRecoveryConfig()
         # SPEC-16.22: Epistemic verification config (always-on by default)
@@ -238,6 +242,14 @@ async def run(
         await trajectory.emit(start_event)
         yield start_event
 
+        # Initialize session persistence (#4 fix)
+        if self._persistence is not None:
+            import os
+
+            session_id = os.environ.get("CLAUDE_SESSION_ID", "rlm_default")
+            self._persistence.init_session(session_id)
+            self._persistence.update_rlm_active(True)
+
         # Initialize RecursiveREPL for depth management and cost tracking
         recursive_handler = RecursiveREPL(
             context=context,
@@ -627,6 +639,7 @@ async def run(
         yield final_event
 
         # Export trajectory if enabled
+        trajectory_export_path: str | None = None
         if self.config.trajectory.export_enabled:
             import os
             import time
@@ -635,7 +648,42 @@ async def run(
             export_dir = Path(os.path.expanduser(self.config.trajectory.export_path))
             export_dir.mkdir(parents=True, exist_ok=True)
             filename = f"trajectory_{int(time.time())}.json"
-            trajectory.export_json(str(export_dir / filename))
+            trajectory_export_path = str(export_dir / filename)
+            trajectory.export_json(trajectory_export_path)
+
+        # --- Post-execution persistence bridges (#4, #15 fix) ---
+
+        # 1. Update StatePersistence with trajectory data
+        if self._persistence is not None and self._persistence.current_state is not None:
+            event_count = len(trajectory.get_full_trajectory())
+            self._persistence.increment_trajectory_events(event_count)
+            if trajectory_export_path:
+                self._persistence.set_trajectory_path(trajectory_export_path)
+            self._persistence.save_state()
+
+        # 2. Bridge to ReasoningTraces (SPEC-04)
+        if self._memory_store is not None:
+            try:
+                from ..reasoning_traces import ReasoningTraces
+
+                traces = ReasoningTraces(store=self._memory_store)
+                for event in trajectory.get_full_trajectory():
+                    traces.from_trajectory_event(event)
+            except Exception:
+                pass  # Non-blocking: traces are observability
+
+        # 3. Bridge to StrategyCache (Spec §8.1)
+        if state.final_answer:
+            try:
+                from ..strategy_cache import get_strategy_cache
+                from ..trajectory_analysis import TrajectoryAnalyzer
+
+                analysis = TrajectoryAnalyzer().analyze(trajectory.get_full_trajectory())
+                cache = get_strategy_cache()
+                cache.add(query, analysis)
+                cache.save()
+            except Exception:
+                pass  # Non-blocking
 
     async def _process_deferred_operations(
         self,

src/state_persistence.py

@@ -58,8 +58,11 @@ def to_dict(self) -> dict[str, Any]:
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> RLMSessionState:
-        """Create from dictionary."""
-        return cls(**data)
+        """Create from dictionary, tolerating unknown fields."""
+        from dataclasses import fields as dc_fields
+
+        known = {f.name for f in dc_fields(cls)}
+        return cls(**{k: v for k, v in data.items() if k in known})
 
 
 class StatePersistence:

tests/unit/test_hook_scripts.py

@@ -0,0 +1,99 @@
+"""
+Unit tests for Python fallback hook scripts.
+
+Tests that session-init.py and trajectory-save.py produce valid JSON
+and handle errors gracefully (fail-open).
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIR = Path(__file__).parent.parent.parent / "scripts"
+
+
+class TestSessionInitHook:
+    """Tests for scripts/session-init.py."""
+
+    def test_produces_valid_json(self):
+        """session-init.py produces valid JSON output."""
+        result = subprocess.run(
+            [sys.executable, str(SCRIPTS_DIR / "session-init.py")],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        output = json.loads(result.stdout.strip())
+        assert "status" in output
+
+    def test_initializes_with_session_id(self):
+        """session-init.py uses CLAUDE_SESSION_ID from env."""
+        env = {"CLAUDE_SESSION_ID": "test-hook-session", "PATH": ""}
+        result = subprocess.run(
+            [sys.executable, str(SCRIPTS_DIR / "session-init.py")],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            env={**dict(__import__("os").environ), **env},
+        )
+
+        output = json.loads(result.stdout.strip())
+        # Either initialized successfully or skipped gracefully
+        assert output["status"] in ("initialized", "skipped")
+
+    def test_fail_open_on_error(self):
+        """session-init.py outputs skipped status on import failure."""
+        script = SCRIPTS_DIR / "session-init.py"
+        # Poison state_persistence module to force ImportError,
+        # while keeping stdlib intact and __file__ defined for the script
+        code = (
+            f"__file__ = {str(script)!r}; "
+            "import sys; sys.modules['state_persistence'] = None; "
+            f"exec(compile(open({str(script)!r}).read(), {str(script)!r}, 'exec'))"
+        )
+        result = subprocess.run(
+            [sys.executable, "-c", code],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        # Should not crash — must produce valid JSON with skipped status
+        assert result.returncode == 0, f"Hook crashed: {result.stderr}"
+        assert result.stdout.strip(), "Hook produced no output"
+        output = json.loads(result.stdout.strip())
+        assert output["status"] == "skipped"
+
+
+class TestTrajectorySaveHook:
+    """Tests for scripts/trajectory-save.py."""
+
+    def test_produces_valid_json(self):
+        """trajectory-save.py produces valid JSON output."""
+        result = subprocess.run(
+            [sys.executable, str(SCRIPTS_DIR / "trajectory-save.py")],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        output = json.loads(result.stdout.strip())
+        assert "status" in output
+
+    def test_handles_no_state_gracefully(self):
+        """trajectory-save.py handles missing state file gracefully."""
+        env = {"CLAUDE_SESSION_ID": "nonexistent-session-12345"}
+        result = subprocess.run(
+            [sys.executable, str(SCRIPTS_DIR / "trajectory-save.py")],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            env={**dict(__import__("os").environ), **env},
+        )
+
+        output = json.loads(result.stdout.strip())
+        assert output["status"] == "skipped"