daemon: event.* fan-out (D5) + category.list/queue.list (D3) — GUI-ready

The two items aimed at pointing GUI at a real veloxd instead of mockd.

rpc/event_hub — per-subscription fan-out shared by both transports.
subscribe() registers a connection with no interest; set_filter()
(session.subscribe, replaces not adds) turns on event kinds and an
optional per-task id filter; publish() delivers a pre-built
notification to every matching subscriber. session.subscribe on both
UdsServer and WsServer now does the real thing — registers/updates a
subscription, tears it down in close_conn.

sched/scheduler — the on_engine_state hook now actually publishes:
- transition() is the one place a task's row changes state; it reads
  the store's own prior row for previousState (authoritative
  regardless of engine/scheduler timing), writes the error columns,
  and — when a hub is supplied — publishes event.task.state with
  {taskId, state, previousState, summary, error}. Wired into every
  transition: scheduler-driven (admission -> probing, resume ->
  connecting, pause) and engine-reported (on_engine_state).
- progress_snapshot(): one row per task the engine is tracking
  (EnginePort::progress(), a new interface method backed by
  DownloadHandle::progress()), plus a store side-effect
  (Tasks::update_progress) so download.list/get stay current between
  state transitions. Returns rows; does NOT publish itself — batching
  into one array message is the caller's job, per the schema's
  x-maxRateHz: 4 and AGENT-DAEMON.md item 5 ("one message per task per
  tick burns a core"). main.cpp's 250 ms timerfd is that caller: one
  event.task.progress per tick, only when there's something to say.

dispatcher::on_download_add now publishes event.task.added (schema:
"summary is always present so a client can insert the row without a
follow-up download.get").

store/categories, store/queues — the two D3 handlers GUI's panels
call. category.list projects the six seeded built-ins; queue.list
derives taskIds from tasks.queue_id/queue_position (Queue's own schema
note: a queue's stored row never carries membership, download.update
/ queue.reorder do).

Verified live end to end against tools/testserver: a subscribed client
sees event.task.added on add, then the full event.task.state sequence
(queued -> probing -> connecting -> downloading -> assembling ->
verifying -> complete) with correct previousState at every step, and
real category.list / queue.list results.

Tests: event_hub (filter-by-kind, filter-by-task-id, replace-not-add,
unsubscribe), store_categories_queues, plus new sched_scheduler cases
for event.task.state publishing and progress_snapshot's store
side-effect. 38 daemon/cli tests green; sched_scheduler / event_hub /
ws_server / uds_roundtrip TSan-clean.

deferrals.md: D5 mostly closed (event.task.removed and the
still-unpublished events wait on their owning D3 handlers); D3 down to
the remaining download.* verbs, rules/settings/limiter/schedule,
queue mutation, category mutation, grabber, media.

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

daemon/src/rpc/ws_server.cpp

@@ -60,11 +60,12 @@ json rpc_error(const json& id, proto::ErrorCode code, std::string_view msg, json
 }  // namespace
 
 WsServer::WsServer(EventLoop& loop, proto::Dispatcher& dispatcher, store::Db& db,
-                   PairingApprover& approver, RuntimeDir runtime)
+                   PairingApprover& approver, EventHub& hub, RuntimeDir runtime)
     : loop_(loop),
       dispatcher_(dispatcher),
       db_(db),
       approver_(approver),
+      hub_(hub),
       runtime_(std::move(runtime)) {}
 
 WsServer::~WsServer() {
@@ -364,9 +365,21 @@ bool WsServer::handle_session_ws(Conn& c, const std::string& method, const json&
                               json{{"path", p.error().path}});
             return true;
         }
+        if (!c.sub_id) {
+            const int fd = c.fd;
+            c.sub_id = hub_.subscribe([this, fd](const json& n) {
+                if (const auto it = conns_.find(fd); it != conns_.end()) send_text(*it->second, n);
+            });
+        }
+        std::vector<proto::Event> events;
         proto::SessionSubscribeResult r;
         r.ok = true;
-        for (const auto& ev : p->events) r.events.emplace_back(proto::to_string(ev));
+        for (const auto& ev : p->events) {
+            const auto name = proto::to_string(ev);
+            r.events.emplace_back(name);
+            if (auto e = proto::event_from_string(name)) events.push_back(*e);
+        }
+        hub_.set_filter(*c.sub_id, std::move(events), p->taskIds);
         reply = proto::make_result(id, r);
         return true;
     }
@@ -423,6 +436,7 @@ void WsServer::flush(Conn& c) {
 
 void WsServer::close_conn(int fd) {
     if (const auto it = conns_.find(fd); it != conns_.end()) {
+        if (it->second->sub_id) hub_.unsubscribe(*it->second->sub_id);
         loop_.del_fd(fd);
         ::close(fd);
         conns_.erase(it);