v0.74.0

Added

• Added synapse multihub follow, the network counterpart of synapse multihub observe. Where
  observe reads a peer hub's event-store file, follow pulls the peer's log over a real
  connection (--peer-uri ws://… | wss://…), folds it through the same read-only follower, and
  prints the observed board, progress, and advisory claims (or --json). It grants nothing, like
  observe, and accepts --token, --limit, and --timeout; deny-by-default federation/mTLS
  gating remains available in the library. This makes the cross-host transport usable from the
  command line for a peer reachable over the network rather than a shared filesystem.
• Added deny-by-default authorisation for a multi-hub pull, so a follower only pulls from a peer
  an operator has explicitly granted. A single decision composes the federation policy with
  mutual-TLS peer verification through the existing composition law — a pull is permitted only
  when every layer permits it, and federation never widens a check. It is fail-closed: an
  unknown, revoked, or expired peering, a namespace the peering does not grant, an unaccepted
  certificate pin, or a certificate file that cannot even be loaded all refuse the pull, and the
  gate re-evaluates a peering's expiry and revocation on every poll. The network fetcher accepts
  this gate and consults it before each fetch connects, failing closed without connecting when
  the peer is not authorised. (Wiring the same decision into the serving hub from the live mTLS
  connection is a deployment follow-up.)
• Added the wire codec for a cross-host multi-hub event-log pull. It names the two shapes one
  hub uses to ask another for the events past a cursor — a request carrying an exclusive
  after_seq and an optional batch limit, and a snapshot carrying the batch of events plus a
  next_cursor to resume from — and converts them to and from the JSON-object wire bodies. The
  codec is pure, with no network, clock, or hub dependency, and decoding is defensive: a
  malformed body raises rather than yielding a half-built batch, so the fetching follower can
  fail the poll and leave the peer's cursor unadvanced. This is the first step toward following a
  peer hub over a real connection rather than only over a shared filesystem.
• Added the serving half of the multi-hub event-log pull: a hub now answers a peer's
  multihub_log_request (an after_seq cursor and optional limit) with a private
  multihub_log_snapshot carrying the events past the cursor and a next_cursor to resume from,
  read through the durable event log's existing cursor. The handler is read-only — it mutates
  nothing and the access layer leaves it ungated like the other read snapshots — and forgiving of
  a malformed request (it answers with an empty snapshot rather than an error); a hub running
  without persistence serves an empty snapshot anchored at the requested cursor. This is the
  network counterpart of the follower's shared-filesystem reader.
• Added the fetching half of the multi-hub event-log pull, so a hub can follow a peer over a real
  connection rather than only over a shared filesystem. network_fetcher returns a follower
  EventFetcher that opens a connection to a peer hub, requests the events past a cursor, and
  decodes the snapshot reply — dropping into the existing follower with no change to its seam.
  Each fetch uses a fresh connection and holds no state between polls, and every failure mode (a
  refused or dropped connection, a hub error frame, a malformed or absent snapshot, or a timeout)
  is raised as a single error type, so the follower advances a peer's cursor only on a clean fetch
  and leaves it unadvanced otherwise — the fail-closed posture extended across the network.
• Added an opt-in step that turns the deliberation advisor's per-round signals into automatic
  actions. The advisor stays purely advisory; this separate reactor lets an orchestrator arm a
  chosen subset of signals (compact-soon, log-now, high-error-rate) to trigger a compact,
  log, or handover via caller-supplied handlers. Every axis is opt-in — an action fires only when
  its signal is present, the action is armed, and a handler is supplied — so the default does
  nothing and the concrete side effects stay the operator's. The routed deliberation loop and its
  bus binding both accept this dispatch and record the actions taken per round.

Changed

• Clarified the Grok participant's support status: the driver is built and unit-tested, so the
  integration is ready to enable, but it is not recommended until xAI ships a stable Grok CLI.
  The CLI is not yet stable, so its streaming-json output schema could not be captured at source
  and stays unverified; the schema must be re-verified against a stable Grok CLI before the
  gated real smoke is trusted.

Fixed

• Fixed the multi-hub network fetcher not catching a fetch timeout on Python 3.10, where the
  timeout error is a distinct type from the built-in. A timed-out fetch now fails closed
  uniformly across supported Python versions.