daemon: D2 — download.probe, genuinely async on both transports

download.probe was a stub (-32603). It needs an HTTP round trip on the engine's probe
pool (up to the schema's 30s x-deadlineMs), which cannot fit VeloxDispatcher's
synchronous on_download_probe -> HandlerResult<T> return without blocking the RPC
loop for the duration — a hard no per CLAUDE.md ("never block the RPC loop") and
AGENT-DAEMON.md build step 1.

uds_server.cpp and ws_server.cpp special-case "download.probe" before the generic
dispatch(), exactly the way they already special-case session.hello/session.subscribe:
parse the params, call the port, and queue the reply whenever the callback fires
(dropped silently if the connection is gone by then).

rpc::TaskActionPort gains probe_now(DownloadProbeParams, callback) — kept in proto/std
terms, no vdm::net::* in the signature, so veloxd_rpc never needs core/include's vdm
headers just to declare this. sched::Scheduler::probe_now is the implementation:
builds a vdm::net::ProbeRequest, runs it on the engine's probe pool, marshals the
engine-thread callback back onto the loop (deps_.post_to_loop, same as every other
engine callback here), maps a probe failure to -32013 ProbeFailed (data.httpStatus set
when there was an HTTP response), and fills suggestedCategoryId/suggestedSaveDir with a
plain extension match against the categories table — not the real rules engine, which
is still D3; noted in a comment.

Verified against real veloxd + tools/testserver, not just unit tests: a real probe
answers in ~5ms with size/resumable/etag/redirect chain; a bad host maps to -32013;
and — the actual point of the async design — a connection running a 10s slow-loris
probe does not block a second connection's download.list, which answers in ~1ms while
the probe is still outstanding.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01GRDjHGgpYmMoPE2UFbe7pP

daemon/src/rpc/task_action_port.hpp

@@ -12,9 +12,12 @@
 // rpc/, so adding an rpc-defined base costs nothing new); main.cpp hands the dispatcher a
 // `TaskActionPort*` pointing at the same Scheduler it constructs.
 
+#include <functional>
 #include <string>
 #include <vector>
 
+#include "velox_proto.hpp"
+
 namespace velox::daemon::rpc {
 
 class TaskActionPort {
@@ -39,6 +42,22 @@ public:
     // queue.stop(pauseRunning=true): pause every currently-running task in `queue_id` now.
     // Returns the wire ids actually paused.
     virtual std::vector<std::string> pause_queue(const std::string& queue_id) = 0;
+
+    // download.probe (D2), the File Info dialog's own network round trip — no task row
+    // involved. Genuinely async (the engine's probe pool; up to the schema's 30s
+    // x-deadlineMs) and so cannot fit VeloxDispatcher's synchronous on_download_probe:
+    // the RPC server layer (uds_server.cpp / ws_server.cpp) special-cases "download.probe"
+    // before the generic dispatch(), the same way it already special-cases session.hello,
+    // calls this, and queues the reply whenever `done` fires — on an engine thread, so the
+    // implementation must marshal back to the loop before calling it, the same as every
+    // other EnginePort callback. Kept in std::string/proto terms (not vdm::net::*) so this
+    // header — included by dispatcher.hpp, part of veloxd_rpc — never needs core/include's
+    // vdm headers; the vdm::net::ProbeRequest/ProbeResult conversion lives in sched/, which
+    // already depends on vdm.
+    virtual void probe_now(
+        const velox::proto::DownloadProbeParams& params,
+        std::function<void(velox::proto::HandlerResult<velox::proto::DownloadProbeResult>)>
+            done) = 0;
 };
 
 }  // namespace velox::daemon::rpc