fix(daemon): restart legacy (no-version-stamp) daemons too

Anchor the stale check on the INSTALLED version, not on both sides being
present. A running daemon with no recorded version is a legacy process from
before the stamp existed — exactly the already-running daemon a user has when
they first adopt this feature — so it must restart, not be left alone. Still
fail-safe on the installed side: an unreadable installed version (thin/uvx env)
never triggers a restart.

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

Author: nickroci

tests/test_daemon_restart.py

@@ -64,13 +64,19 @@ def test_no_restart_when_installed_version_unknown(
     assert stopped == []
 
 
-def test_no_restart_when_running_version_missing(
+def test_restart_legacy_daemon_with_no_version_stamp(
     home: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    # A legacy daemon (pre-this-feature) wrote no version — never restart blindly.
+    # A legacy daemon (pre-this-feature) wrote no version. Anchored on a KNOWN
+    # installed version, that's unambiguously old code → restart. This is the
+    # migration case: the daemon a user already has running when they first adopt
+    # the feature has no stamp, and must still be replaced.
     _write_state(home, pid=os.getpid(), version=None)
     monkeypatch.setattr(_daemon, "_installed_daemon_version", lambda: "0.3.0")
-    assert _daemon.restart_if_stale() is False
+    stopped: list[int] = []
+    monkeypatch.setattr(_daemon, "_stop_daemon", lambda pid, **k: stopped.append(pid))
+    assert _daemon.restart_if_stale() is True
+    assert stopped == [os.getpid()]
 
 
 def test_restart_when_stale_stops_and_clears_backoff(

ultan/_daemon.py

@@ -153,18 +153,27 @@ def restart_if_stale() -> bool:
     metadata (cold-cheap, hot-needless). The running version is what the daemon
     stamped into ``daemon.state`` at ITS startup; the installed version is read
     live, so an ``uv tool install`` update is detected even though the old
-    process keeps serving the previous code. Fail-safe: any uncertainty (no
-    daemon, dead pid, unknown version on either side) leaves the daemon alone."""
+    process keeps serving the previous code.
+
+    Anchored on the INSTALLED version: if we can't read it (a thin/uvx env with
+    no daemon dist, or unreadable metadata) we never restart — there's nothing to
+    compare against. Given a readable installed version, a daemon whose recorded
+    version differs is stale; so is one with NO recorded version, because that is
+    a legacy daemon from before this stamp existed (a current daemon always
+    stamps a version when the metadata it reads is itself readable). Restarting
+    that legacy daemon is the whole point — it's exactly the process left on old
+    code that this feature exists to replace."""
     state = _read_daemon_state()
     if not state:
         return False
     pid = state.get("pid")
     if not _pid_alive(pid):
         return False
-    running = state.get("version")
     installed = _installed_daemon_version()
-    if not running or not installed or running == installed:
-        return False
+    if not installed:
+        return False  # can't tell what's installed — never restart blindly
+    if state.get("version") == installed:
+        return False  # up to date
     _stop_daemon(cast("int", pid))
     # Clear the spawn backoff so ensure_running() respawns immediately rather
     # than throttling this intentional restart as if it were a crash loop.