Pure planning of the tmux `set-hook` invocations that install and remove
ingestion.

The plan is DATA: a vector of argv vectors. Nothing here runs tmux, so the
whole installation surface is testable without a server, and the boundary
that does run it stays a one-liner.

Joins a hook arrival to the registry and the event system.

Effects arrive as an injected map (`:registry` `:deregister!` `:dispatch!`)
rather than as direct calls on `hive-tmux.state` and `hive-events`, so the
whole arrival path is exercised against recording fns.

Start and stop tmux-originated ingestion for the addon.

Installing hooks is OPT-IN and off by default. `set-hook -g` is a persistent,
server-wide change to the operator's tmux, and an addon that rewrites it on
every init would be editing an environment it does not own. The listener
itself is inert (a socket nobody writes to), so it starts by default and the
operator turns on the half that touches their server.

UNIX-socket boundary: accepts hook arrivals and hands each decoded event to
an injected dispatch fn.

The dispatch fn is an argument rather than a direct `hive-events` call, so
the accept loop is exercised in tests against a recording fn and carries no
dependency on the event system it feeds.

Turns one hook arrival into a registry action.

The registry is keyed by ling-id while an arrival carries only a pane-id, so
reconciling needs a reverse lookup. Planning is pure over a registry VALUE:
the decision is testable without a registry, a tmux server or a socket, and
the boundary that performs it stays a `case` over the plan.

Malli value objects for tmux-originated event ingestion.

JVM-only on purpose: malli arrives as a `:mvn/version` coordinate, which
ClojureWasm does not resolve. The portable half of the subsystem lives in
`hive-tmux.observe.wire` and carries no contracts of its own; these schemas
describe its values from the JVM side, where they can be enforced and can
generate tests.

Wire format shared by the JVM listener and the cljw hook client.

This namespace is loaded by ClojureWasm, which resolves only `:git/url` and
`:local/root` coordinates. It therefore requires nothing outside
`clojure.core` and `clojure.edn`, and must stay that way: a `:mvn/version`
dependency reached from here is silently skipped by cljw and fails at call
time rather than load time.