refactor(sock): one socket client, retry as a policy value

Six places in the tree hand-rolled the same connect / write one JSON
line / read one JSON line back. Two of them — the harness serve loop's
client and the MCP server's — were byte-identical apart from a six-line
wrapper, ~145 lines of literal copy-paste. The other four each
reimplemented a subset, and the subsets had drifted: some named the
socket path in their errors and some did not, one classified transient
against fatal failures and the rest retried nothing at all, two drained
the response and two decoded it.

That duplication was defended when the daemons were split out, on the
grounds that a daemon's socket etiquette should stay visible in the
crate that depends on it. The etiquette genuinely does differ. The code
does not, and five copies is where "each daemon documents its own
etiquette" stops paying for itself.

`hive-sock-client` now owns the transport once, generic over the
request and response types so it is protocol-agnostic: the host-served
control socket and the harness's in-agent socket both use it with their
own wire-type crates. The two real differences become values instead of
forks. Retry is `Retry::RideOutRestart` (2/4/8/16/30s, sized to ride out
a service restart) for callers with no natural retry of their own, or
`Retry::None` for callers already inside a poll loop where the poll
interval is the retry — and the reason each caller picked one is a
comment at the call site rather than a reimplementation. The response is
either decoded (`request`) or half-closed and drained (`notify`, where
the drain exists so the server's write-back doesn't land on a closed
socket). Whether a failure propagates or is logged and swallowed stays
at the call site, because that is the caller's choice and not a property
of the transport.

Errors always name the socket path now, everywhere. That detail is
load-bearing: a permission problem on a socket that reads as "is the
daemon running?" sends the operator to fix the wrong thing.

The transient-against-fatal enum is gone rather than moved. Serialising
happens before the retry loop and deserialising after it, so only
connect, I/O and short-read failures can reach the loop at all — a
deterministic failure is now unretryable by construction instead of by
classification.

It is deliberately a new crate and not part of `hive-agent-sock`. The
`*-sock` crates are pure wire types by convention — `hive-agent-sock`
depends on serde and nothing else — and the two largest copies talk to
the host socket, whose types live in a different crate entirely. A
transport in either wire-type crate would drag tokio into it and point
the wrong way besides.

No wire-format change: same JSON line in, same line out.

hive-matrix-mcp/src/wake.rs

@@ -10,11 +10,14 @@
 //! agent then reads the unmarked event via the `read_room` MCP tool.
 //! Truncation to ~100 chars keeps the summary focused.
 
-use std::path::Path;
+use anyhow::Result;
+use hive_sock_client::{Retry, notify};
 
-use anyhow::{Context, Result};
-use tokio::io::AsyncWriteExt;
-use tokio::net::UnixStream;
+/// Retry policy for the in-agent socket. Fail-fast: every caller here is
+/// inside the sync loop, which re-derives the whole todo set on its next
+/// pass — that pass *is* the retry, and it carries fresher state than a
+/// backoff replaying a stale summary would.
+const TODO_SOCKET_RETRY: Retry = Retry::None;
 
 /// The harness-served in-agent socket (`HIVE_AGENT_SOCKET`) where todo ops
 /// go — distinct from the host-served control socket used by [`send_wake`].
@@ -46,7 +49,7 @@ pub async fn send_todo_upsert(key: &str, summary: impl AsRef<str>) -> Result<()>
         "key": key,
         "summary": summary.as_ref(),
     });
-    send_line(&socket, &payload).await
+    notify(&socket, &payload, TODO_SOCKET_RETRY).await
 }
 
 /// Clear matrix-subsystem todos on the harness's in-agent socket. `key =
@@ -68,38 +71,7 @@ pub async fn send_todo_clear(key: Option<&str>, all: bool) -> Result<()> {
         "key": key,
         "all": all,
     });
-    send_line(&socket, &payload).await
-}
-
-/// Write one JSON request line to the hyperhive control socket and drain
-/// the response line (best-effort — the reply is not acted on, we just
-/// read it so the server doesn't get ECONNRESET on its write-back).
-/// Shared by [`send_wake`] and the todo senders.
-///
-/// # Errors
-///
-/// Returns an error on socket connect failure, serialisation failure,
-/// or I/O error writing to or reading from the socket.
-async fn send_line(socket: &Path, payload: &serde_json::Value) -> Result<()> {
-    use tokio::io::AsyncBufReadExt;
-
-    let line = format!("{}\n", serde_json::to_string(payload)?);
-    let stream = UnixStream::connect(socket)
-        .await
-        .with_context(|| format!("connect hyperhive socket {}", socket.display()))?;
-    let (read, mut write) = stream.into_split();
-    write
-        .write_all(line.as_bytes())
-        .await
-        .with_context(|| format!("write to {}", socket.display()))?;
-    write
-        .shutdown()
-        .await
-        .with_context(|| format!("shutdown write to {}", socket.display()))?;
-    let mut reader = tokio::io::BufReader::new(read);
-    let mut resp = String::new();
-    let _ = reader.read_line(&mut resp).await;
-    Ok(())
+    notify(&socket, &payload, TODO_SOCKET_RETRY).await
 }
 
 /// Format a wake-message body from a list of per-room unread summaries.