host TA: the fed-sx transport adapter — federation loop proven at the seam

lib/host/ta.sx — a seam transport {:emit :deliver} over a DIRECTIONAL wire (out = outbox→followers,
in = inbox←follows). The transport is the SERIALIZATION boundary: activities cross the wire as
SX-source strings (host/ta--serialize/deserialize map the keyword-keyed activity ↔ a flat
string-keyed wire form of the P2 activity fields). host/ta--make-transport(out-wire, in-wire) +
host/ta--make-mem-wire (an in-memory directional queue for tests).

Proven (ta 5/5): content + relation activities round-trip through the wire; the FEDERATION LOOP —
instance A emits an activity → the wire carries it → instance B's behavior/pump delivers + processes
it → B's engine fires ITS behavior on A's activity; DIRECTIONAL (B re-emits to its own outbox, not
back into the inbox — no loop). 'Everything works over fed-sx', proven at the seam.

TA-live (deferred, same shape as RA-live): swap the mem-wire for the real next/ delivery wire —
needs a PERSISTENT next/ kernel (gen_servers don't survive across erlang-eval-ast calls) + the ACTOR
MODEL (peer_actors/follower_graph decide who the out-wire delivers to) + pushing /activities onto it.

Full host conformance green (+ta 5).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

plans/business-logic-fed-flows.md

@@ -271,10 +271,23 @@ the flow instance Id is the resume handle.
   The runner + marshalling + suspend/resume mechanics are all proven; this is process lifecycle + wiring.
 
 ## TA — the FED-SX TRANSPORT adapter   ← federation proper
-- [ ] A seam transport over next/ delivery: :emit → outbox → peers; :deliver → inbox. A remote
-  peer's engine fires its own triggers. Everything works over fed-sx. RISK: next/ delivery M2
-  blockers (er-scheduler context). Needs the ACTOR MODEL real (:actor was a P0 placeholder —
-  peer_actors / follower_graph / per-author identity).
+- [x] **TA TRANSPORT BUILT + the federation LOOP PROVEN 2026-07-02.** lib/host/ta.sx — a seam
+  transport {:emit :deliver} over a DIRECTIONAL wire (out=outbox→followers, in=inbox←follows). The
+  transport is the SERIALIZATION boundary: activities cross as SX-source strings via host/ta--
+  serialize/deserialize (keyword-keyed activity ↔ flat string-keyed wire form — the P2 activity
+  fields). host/ta--make-transport(out-wire, in-wire) + host/ta--make-mem-wire (an in-memory
+  directional queue). PROVEN (ta 5/5): a content + a relation activity round-trip through the wire;
+  the FEDERATION LOOP — instance A emits an activity → the wire carries it → instance B's
+  behavior/pump delivers + processes it → B's engine fires ITS behavior on A's activity; DIRECTIONAL
+  (B re-emits to its own outbox, not back into the inbox — no loop). This is "everything works over
+  fed-sx" proven at the seam. Full host conformance green.
+- [ ] **TA-LIVE (deferred — same shape as RA-live).** Swap the mem-wire for the REAL next/ delivery
+  wire (outbox → http_server → peer inbox). Needs: (a) a PERSISTENT next/ kernel process (gen_servers
+  don't survive across erlang-eval-ast calls — the RA-live finding; next/ outbox/http_server are the
+  persistent side); (b) the ACTOR MODEL real (:actor is a "site" placeholder — peer_actors /
+  follower_graph / per-author identity decide WHO the out-wire delivers to); (c) push /activities
+  (the P2 event source) onto the out-wire. RISK: next/ delivery M2 blockers (er-scheduler context).
+  The transport contract + serialization + the loop are proven; TA-live is the wire impl + placement.
 
 ## AX — artdag GROWS control-flow (business logic MIGRATES to artdag) [DEMAND-DRIVEN]
 Today artdag is pure dataflow and the execute-fold is the synchronous control-flow runner. That's
@@ -303,6 +316,13 @@ covers everything until a DAG's cost/latency/placement forces the substrate.
   activities), so business logic can change state, which federates, which triggers more flows.
 
 ## Progress log (newest first)
+- 2026-07-02 — TA TRANSPORT built + the federation LOOP proven (lib/host/ta.sx, ta 5/5). A seam
+  transport over a directional wire (serialization boundary; activities cross as SX-source). Proven
+  in-memory: A emits → wire → B pump → B's engine fires ITS behavior on A's activity (directional, no
+  loop). "Everything works over fed-sx" proven at the seam. TA-live (real next/ delivery wire) deferred
+  — needs the persistent kernel (RA-live finding) + the actor model (who to deliver to). NEXT: the
+  DISTRIBUTED HALF is now all proven-at-the-seam (RA + TA); the remaining live steps (RA-live, TA-live)
+  share ONE prerequisite — a persistent next/ kernel process + the actor model. Or P4/AX/RX.
 - 2026-07-02 — P2 DONE + LIVE-VERIFIED. All observable state changes now emit canonical activities
   through the seam: content Create/Update + relation Add/Remove. DEBT #1 fixed (per-event ids; edge-
   based for relations). The activity log is the durable event source, surfaced at /activities. Live: