fix(tests): bump TestDaemon startup timeout from 30s to 60s

The user reported intermittent failures of
`daemon_mode_two_engines_share_same_hyperd` on macOS:

  panicked at hyperdb-mcp/tests/daemon_tests.rs:818:
  TestDaemon did not start within 30 seconds

Root cause: the outer wait was the same length as `HyperProcess::new`'s
own internal 30s timeout for the hyperd-callback connection. Under
macOS load (parallel tests, hyperd subprocess churn, system resource
pressure), hyperd startup can approach or exceed that limit. When it
does, the outer assertion fires before the inner timeout can return
its actual error message — masking the real cause behind a generic
"did not start" panic.

Bumping the outer timeout to 60s ensures the inner timeout has room
to surface a real error via the existing `daemon_handle.is_finished()`
branch. If hyperd genuinely can't start, we'll see "daemon thread
errored: <real reason>" instead of the unhelpful generic message.

Also tightens the panic message to clarify the failure mode (daemon
thread still running, no discovery file written) so the next reader
knows whether to look at hyperd-startup vs. discovery-write paths.

Author: StefanSteiner

hyperdb-mcp/tests/daemon_tests.rs

@@ -796,6 +796,14 @@ impl TestDaemon {
         // Wait for daemon to become ready. CI runners (especially macOS)
         // can be significantly slower than local dev — hyperd startup
         // alone may take 10+ seconds under load.
+        //
+        // The outer timeout MUST exceed `HyperProcess::new`'s own 30s
+        // wait for the hyperd-callback connection. Otherwise, when
+        // hyperd is slow to start, the bare "TestDaemon did not start"
+        // assertion fires before the daemon thread can return its
+        // actual error — masking the real cause behind a generic
+        // timeout. 60s gives the inner timeout room to surface via the
+        // `daemon_handle.is_finished()` branch below.
         let start = Instant::now();
         loop {
             if let Some(info) = discovery::discover() {
@@ -806,7 +814,7 @@ impl TestDaemon {
                 };
             }
             // Fail fast if the daemon thread has already exited (bind error,
-            // spawn error, etc.). Avoids the unhelpful 30s-timeout panic.
+            // spawn error, etc.). Avoids the unhelpful generic-timeout panic.
             if daemon_handle.is_finished() {
                 let msg = match daemon_handle.join() {
                     Ok(Ok(())) => "daemon thread exited cleanly without writing discovery".into(),
@@ -816,8 +824,8 @@ impl TestDaemon {
                 panic!("TestDaemon failed to start: {msg}");
             }
             assert!(
-                start.elapsed() <= Duration::from_secs(30),
-                "TestDaemon did not start within 30 seconds"
+                start.elapsed() <= Duration::from_secs(60),
+                "TestDaemon did not start within 60 seconds (daemon thread still running, no discovery file written)"
             );
             std::thread::sleep(Duration::from_millis(200));
         }