refactor: hold registry lock for entire start_run to prevent race condition

The start_run method previously released the lock (via _get_run) before
modifying managed.thread and calling thread.start(), creating a window
where concurrent calls could race on the same run. Now the entire
operation is atomic under the registry lock, matching the class's
documented "Thread-safe registry" contract.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

src/ralphify/manager.py

@@ -85,17 +85,21 @@ def start_run(self, run_id: str) -> None:
         The thread calls :func:`engine.run_loop` with the emitter built
         by :meth:`ManagedRun.build_emitter`, which fans out to the queue
         and any extra listeners.
+
+        The entire operation runs under the registry lock so that
+        concurrent calls cannot race on the same run.
         """
-        managed = self._get_run(run_id)
-        emitter = managed.build_emitter()
-        thread = threading.Thread(
-            target=run_loop,
-            args=(managed.config, managed.state, emitter),
-            daemon=True,
-            name=f"run-{run_id}",
-        )
-        managed.thread = thread
-        thread.start()
+        with self._lock:
+            managed = self._runs[run_id]
+            emitter = managed.build_emitter()
+            thread = threading.Thread(
+                target=run_loop,
+                args=(managed.config, managed.state, emitter),
+                daemon=True,
+                name=f"run-{run_id}",
+            )
+            managed.thread = thread
+            thread.start()
 
     def stop_run(self, run_id: str) -> None:
         """Signal the run to stop after the current iteration finishes."""