feat: wire persistence layer and add iterations endpoint so users can review past runs

The Store was defined but never connected. Now:
- Events are persisted to ~/.ralph/ui.db during the drain loop
- GET /api/runs/{run_id}/iterations returns iteration + check data from SQLite
- Frontend auto-fetches persisted iterations when selecting a run with
  no in-memory data, rebuilding timeline and check health sparklines

This means users can close the dashboard, come back later, and still
see full iteration details for historical runs.

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

Author: 2 people

src/ralphify/ui/api/runs.py

@@ -11,6 +11,7 @@
 from ralphify.manager import ManagedRun, RunManager
 from ralphify.prompts import resolve_prompt_name
 from ralphify.ui.models import RunCreate, RunResponse, RunSettingsUpdate
+from ralphify.ui.persistence import Store
 
 def _load_agent_config(project_dir: str) -> dict:
     """Read ``[agent]`` from ralph.toml so the UI never hard-codes command/args."""
@@ -37,6 +38,14 @@ def _get_manager(request: Request) -> RunManager:
     return mgr
 
 
+def _get_store(request: Request) -> Store:
+    """Extract the Store from app state (set during lifespan startup)."""
+    store: Store | None = getattr(request.app.state, "store", None)
+    if store is None:
+        raise RuntimeError("Store not initialised")
+    return store
+
+
 def _get_run_or_404(mgr: RunManager, run_id: str) -> ManagedRun:
     managed = mgr.get_run(run_id)
     if managed is None:
@@ -156,3 +165,25 @@ async def update_settings(run_id: str, body: RunSettingsUpdate, mgr: RunManager
         managed.config.stop_on_error = body.stop_on_error
 
     return _run_response(managed)
+
+
+@router.get("/runs/{run_id}/iterations")
+async def get_iterations(run_id: str, store: Store = Depends(_get_store)) -> list[dict]:
+    """Return persisted iteration data with check results for a run."""
+    iters = await store.get_iterations(run_id)
+    result = []
+    for it in iters:
+        status_map = {"completed": "success", "failed": "failure", "timed_out": "timeout", "started": "running"}
+        checks_raw = await store.get_check_results(run_id, it["iteration"])
+        checks = [
+            {"name": c["check_name"], "passed": bool(c["passed"]), "exit_code": c["exit_code"], "timed_out": bool(c["timed_out"])}
+            for c in checks_raw
+        ]
+        result.append({
+            "iteration": it["iteration"],
+            "status": status_map.get(it["status"], it["status"]),
+            "returncode": it["returncode"],
+            "duration": f"{it['duration']:.1f}s" if it["duration"] is not None else None,
+            "checks": checks if checks else None,
+        })
+    return result

src/ralphify/ui/app.py

@@ -15,13 +15,14 @@
 from ralphify.ui.api import runs as runs_module
 from ralphify.ui.api import primitives as primitives_module
 from ralphify.ui.api.ws import ws_manager
+from ralphify.ui.persistence import Store
 
 
-async def _drain_events(manager: RunManager) -> None:
+async def _drain_events(manager: RunManager, store: Store) -> None:
     """Background task: pull events from all run queues and fan out.
 
     Bridges the synchronous engine threads (which push events into
-    ``queue.Queue``) to the async world (WebSocket broadcast).
+    ``queue.Queue``) to the async world (WebSocket broadcast + persistence).
     """
     while True:
         for managed in manager.list_runs():
@@ -30,7 +31,9 @@ async def _drain_events(manager: RunManager) -> None:
                     event: Event = managed.emitter.queue.get_nowait()
                 except Empty:
                     break
-                await ws_manager.broadcast(event.run_id, event.to_dict())
+                event_dict = event.to_dict()
+                await ws_manager.broadcast(event.run_id, event_dict)
+                await store.save_event(event_dict)
         await asyncio.sleep(0.05)
 
 
@@ -44,8 +47,12 @@ async def lifespan(app: FastAPI):
         manager = RunManager()
         app.state.manager = manager
 
+        store = Store()
+        await store.init()
+        app.state.store = store
+
         # Start event drain task
-        drain_task = asyncio.create_task(_drain_events(manager))
+        drain_task = asyncio.create_task(_drain_events(manager, store))
 
         yield
 
@@ -55,6 +62,7 @@ async def lifespan(app: FastAPI):
             await drain_task
         except asyncio.CancelledError:
             pass
+        await store.close()
 
     app = FastAPI(title="ralphify", lifespan=lifespan)
 

src/ralphify/ui/static/dashboard.js

@@ -69,6 +69,36 @@ function selectRun(run_id) {
   // Auto-select the latest iteration for the new run
   const runIters = iterations.value[run_id] || [];
   activeIteration.value = runIters.length > 0 ? runIters[runIters.length - 1].iteration : null;
+  // Load persisted iteration data if none in memory
+  if (runIters.length === 0) {
+    loadIterations(run_id);
+  }
+}
+
+async function loadIterations(run_id) {
+  try {
+    const data = await api('GET', `/runs/${run_id}/iterations`);
+    if (data && data.length > 0) {
+      iterations.value = { ...iterations.value, [run_id]: data };
+      // Also rebuild check health sparklines from the loaded data
+      const health = {};
+      for (const it of data) {
+        if (it.checks) {
+          for (const c of it.checks) {
+            if (!health[c.name]) health[c.name] = [];
+            health[c.name].push(c.passed ? 'pass' : c.timed_out ? 'timeout' : 'fail');
+          }
+        }
+      }
+      if (Object.keys(health).length > 0) {
+        checkHealth.value = { ...checkHealth.value, [run_id]: health };
+      }
+      // Auto-select the latest iteration
+      if (run_id === activeRunId.value) {
+        activeIteration.value = data[data.length - 1].iteration;
+      }
+    }
+  } catch { /* endpoint may not exist on older servers */ }
 }
 
 function showToast(text, type = 'error') {