f791584 refactor(protocol): isolate binary wire encoding (#228) · vev

M AGENTS.md +4 -2

 Layer map:
 - `main.go` → `internal/app`: CLI parsing, wiring, daemon startup, hidden subcommands.
-- `internal/ports`: interfaces and wire protocol.
+- `internal/ports`: application and raw carriage interfaces.
+- `internal/protocol`: typed transport-neutral messages and negotiated session policy.
+- `internal/protocol/wire`: message IDs, frames, strict binary codecs, compression, and encoded bounds.
 - `internal/usecase/daemon`: sessions, tabs, panes, VT screens, renderer shadows, daemon features.
 - `internal/usecase/client`: raw-mode thin client; writes output bytes verbatim and interprets nothing.
 - `internal/adapters`: IPC, SSH stdio, PTY, terminal, and clock implementations.
 ## Wire protocol
-Semantic presentation, route, and session-control values live in `internal/protocol`. Frame IDs and codecs live in `internal/ports/frame.go`, `internal/ports/wire.go`, `internal/ports/routes_wire.go`, and `internal/ports/wire_command.go`. Connection framing lives in `internal/adapters/ipc/transport.go`.
+Typed messages and negotiated version live in `internal/protocol`. Message IDs, frames, strict codecs, compression, and encoded bounds live in `internal/protocol/wire`; raw carriage interfaces remain in `internal/ports`. Connection framing lives in concrete carriage adapters such as `internal/adapters/ipc`.
 - IPC frames on a connection are 4-byte big-endian length, 1 type byte, then payload.
 - Client message types occupy `1–13`, `15`, `32–33`, and `35` (`MsgParkedRouteRequest`); server types occupy `16–23`, `25–31`, `34`, and `36` (`MsgParkedRouteResponse`). Types `14` and `24` remain reserved.

M internal/adapters/dgram/control_plane_test.go +5 -4

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 	a.diagnosticCh = make(chan Diagnostic, 1)
 	a.mu.Unlock()
-	if err := b.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("first")}); err != nil {
+	if err := b.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("first")}); err != nil {
 		t.Fatal(err)
 	}
 	awaitSignal(t, contacts, "first authenticated record")
 	awaitSignal(t, ackStarted, "blocked ACK")
 	clk.advance(time.Second)
-	if err := b.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("second")}); err != nil {
+	if err := b.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("second")}); err != nil {
 		t.Fatal(err)
 	}
 	awaitSignal(t, contacts, "second authenticated record while ACK write is blocked")
 	a.mu.Lock()
 	for seq := uint64(1); seq <= 64; seq++ {
 		a.pending[seq] = &pending{
-			frame:    ports.Frame{Type: ports.MsgInput, Payload: make([]byte, 24*a.mtu)},
+			frame:    wire.Frame{Type: wire.MsgInput, Payload: make([]byte, 24*a.mtu)},
 			enqueued: now.Add(-time.Second), first: now.Add(-time.Second), last: now.Add(-time.Second),
 		}
 	}
 	now := clk.Now()
 	a.mu.Lock()
 	a.pending[1] = &pending{
-		frame:    ports.Frame{Type: ports.MsgInput, Payload: make([]byte, 24*a.mtu)},
+		frame:    wire.Frame{Type: wire.MsgInput, Payload: make([]byte, 24*a.mtu)},
 		enqueued: now.Add(-time.Second), first: now.Add(-time.Second), last: now.Add(-time.Second),
 	}
 	a.mu.Unlock()

M internal/adapters/dgram/diagnostics_test.go +3 -2

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestDiagnosticSnapshotSeparatesProgressAges(t *testing.T) {
 		retransmits:             64,
 		reassemblyInflight:      2,
 		pending: map[uint64]*pending{
-			1: {frame: ports.Frame{Payload: make([]byte, 7)}},
+			1: {frame: wire.Frame{Payload: make([]byte, 7)}},
-			2: {frame: ports.Frame{Payload: make([]byte, 11)}},
+			2: {frame: wire.Frame{Payload: make([]byte, 11)}},
 		},
 		diagnosticCh: make(chan Diagnostic, diagnosticBufferSize),
 		done:         make(chan struct{}),

M internal/adapters/dgram/network_sim_test.go +7 -6

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 		}
 		b.mu.Unlock()
 		primer := mustMarshalOutput(protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("primer")})
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: primer}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: primer}); err != nil {
 			t.Fatal(err)
 		}
 		awaitSignal(t, primerWritten, "primer write")
 				Size:  domain.Size{Cols: 1, Rows: 1},
 				Data:  bytes.Repeat([]byte{byte(state + 1)}, outputDataBytes),
 			})
-			if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: payload}); err != nil {
+			if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: payload}); err != nil {
 				t.Fatal(err)
 			}
 		}
 			for {
 				select {
 				case frame := <-b.in:
-					output, err := ports.UnmarshalOutput(frame.Payload)
+					output, err := wire.UnmarshalOutput(frame.Payload)
 					if err != nil {
 						t.Fatal(err)
 					}
 		// A fresh record queues behind the sole data sender while control traffic
 		// remains independent of congestion tokens and the blocked data write.
 		go func() {
-			freshReturned <- a.Send(ports.Frame{Type: ports.MsgOutput, Payload: floodOutputPayload(floodRecordCount, 128)})
+			freshReturned <- a.Send(wire.Frame{Type: wire.MsgOutput, Payload: floodOutputPayload(floodRecordCount, 128)})
 		}()
 		select {
 		case err := <-freshReturned:
 	const mtu = 128
 	for state := range floodRecordCount {
 		payload := floodOutputPayload(state, mtu)
-		output, err := ports.UnmarshalOutput(payload)
+		output, err := wire.UnmarshalOutput(payload)
 		if err != nil {
 			t.Fatalf("state %d: %v", state, err)
 		}
 func sendFloodOutputs(t *testing.T, sender *Transport, count, mtu int) {
 	t.Helper()
 	for state := range count {
-		if err := sender.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: floodOutputPayload(state, mtu)}); err != nil {
+		if err := sender.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: floodOutputPayload(state, mtu)}); err != nil {
 			t.Fatal(err)
 		}
 	}

M internal/adapters/dgram/output_pacer.go +4 -4

@@ -1,11 +1,11 @@
1		package dgram	1		package dgram
2			2
3	-	import "github.com/bnema/vev/internal/ports"	3	+	import "github.com/bnema/vev/internal/protocol/wire"
4			4
5		type dataSendJob struct {	5		type dataSendJob struct {
6		seq uint64	6		seq uint64
7		reliable bool	7		reliable bool
8	-	frame ports.Frame	8	+	frame wire.Frame
9		done chan error	9		done chan error
10		}	10		}
11			11

@@ -52,8 +52,8 @@ func (t *Transport) notifyOutputPacerLocked() {
52		t.outputWake = make(chan struct{})	52		t.outputWake = make(chan struct{})
53		}	53		}
54			54
55	-	func shouldPaceOutput(f ports.Frame) bool {	55	+	func shouldPaceOutput(f wire.Frame) bool {
56	-	return f.Type == ports.MsgOutput	56	+	return f.Type == wire.MsgOutput
57		}	57		}
58			58
59		func (t *Transport) markPendingSent(seq uint64, reliable bool) {	59		func (t *Transport) markPendingSent(seq uint64, reliable bool) {

M internal/adapters/dgram/proxy.go +6 -5

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const (
 	dst              ports.Transport
 	recvKind         proxyCopyErrKind
 	sendKind         proxyCopyErrKind
-	transform        func(ports.Frame) ports.Frame
+	transform        func(wire.Frame) wire.Frame
 	retryRecoverable bool
 }
 // clampDatagramHelloOutputWindow enforces the datagram-safe state window at
 // the adapter boundary. Invalid Hello payloads pass through unchanged so the
 // daemon remains the single authority for strict decoding and version checks.
-func clampDatagramHelloOutputWindow(f ports.Frame) ports.Frame {
+func clampDatagramHelloOutputWindow(f wire.Frame) wire.Frame {
-	if f.Type != ports.MsgHello {
+	if f.Type != wire.MsgHello {
 		return f
 	}
-	hello, err := ports.UnmarshalHello(f.Payload)
+	hello, err := wire.UnmarshalHello(f.Payload)
 	if err != nil {
 		return f
 	}
 	hello.MaxOutputInFlight = 1
-	f.Payload = ports.MarshalHello(hello)
+	f.Payload = wire.MarshalHello(hello)
 	return f
 }

M internal/adapters/dgram/proxy_test.go +28 -27

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type fakeTransport struct {
 	recv       chan recvResult
-	sent       chan ports.Frame
+	sent       chan wire.Frame
 	sendErr    chan error
 	linkState  ports.LinkState
 	linkEvents chan ports.LinkEvent
 }
 type recvResult struct {
-	frame ports.Frame
+	frame wire.Frame
 	err   error
 }
 func newFakeTransport() *fakeTransport {
-	return &fakeTransport{recv: make(chan recvResult, 4), sent: make(chan ports.Frame, 4), sendErr: make(chan error, 4), linkEvents: make(chan ports.LinkEvent, 4), linkState: ports.LinkStateConnected, closed: make(chan struct{})}
+	return &fakeTransport{recv: make(chan recvResult, 4), sent: make(chan wire.Frame, 4), sendErr: make(chan error, 4), linkEvents: make(chan ports.LinkEvent, 4), linkState: ports.LinkStateConnected, closed: make(chan struct{})}
 }
-func (f *fakeTransport) Send(fr ports.Frame) error {
+func (f *fakeTransport) Send(fr wire.Frame) error {
 	select {
 	case err := <-f.sendErr:
 		return err
 	f.sent <- fr
 	return nil
 }
-func (f *fakeTransport) Recv() (ports.Frame, error) {
+func (f *fakeTransport) Recv() (wire.Frame, error) {
 	select {
 	case r := <-f.recv:
 		return r.frame, r.err
 	case <-f.closed:
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}
 }
 func (f *fakeTransport) Close() error {
 	daemon := newFakeTransport()
 	errCh := make(chan error, 1)
 	go func() { errCh <- ProxyRuntime{Client: client, Daemon: daemon, IdleTTL: time.Hour}.Run(t.Context()) }()
-	client.recv <- recvResult{frame: ports.Frame{Type: ports.MsgInput, Payload: []byte("x")}}
+	client.recv <- recvResult{frame: wire.Frame{Type: wire.MsgInput, Payload: []byte("x")}}
 	select {
 	case got := <-daemon.sent:
-		if got.Type != ports.MsgInput {
+		if got.Type != wire.MsgInput {
 			t.Fatalf("daemon got type %v", got.Type)
 		}
 	case <-time.After(time.Second):
 			errCh := make(chan error, 1)
 			go func() { errCh <- ProxyRuntime{Client: client, Daemon: daemon, IdleTTL: time.Hour}.Run(t.Context()) }()
 			hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: requested}
-			client.recv <- recvResult{frame: ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}}
+			client.recv <- recvResult{frame: wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)}}
 			select {
 			case frame := <-daemon.sent:
-				got, err := ports.UnmarshalHello(frame.Payload)
+				got, err := wire.UnmarshalHello(frame.Payload)
 				if err != nil {
 					t.Fatal(err)
 				}
 				t.Fatal("timeout waiting for proxied Hello")
 			}
-			input := ports.Frame{Type: ports.MsgInput, Payload: []byte("still flowing")}
+			input := wire.Frame{Type: wire.MsgInput, Payload: []byte("still flowing")}
-			ack := ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: 1, State: 7})}
+			ack := wire.Frame{Type: wire.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: 1, State: 7})}
 			client.recv <- recvResult{frame: input}
 			client.recv <- recvResult{frame: ack}
-			for _, want := range []ports.Frame{input, ack} {
+			for _, want := range []wire.Frame{input, ack} {
 				select {
 				case got := <-daemon.sent:
 					if !reflect.DeepEqual(got, want) {
 				errCh <- ProxyRuntime{Client: client, Daemon: daemon, IdleTTL: time.Hour, RetryBackoff: time.Nanosecond}.Run(t.Context())
 			}()
 			client.sendErr <- tt.err
-			daemon.recv <- recvResult{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("preserved during outage")}}
+			daemon.recv <- recvResult{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("preserved during outage")}}
 			select {
 			case got := <-client.sent:
-				if got.Type != ports.MsgOutput || string(got.Payload) != "preserved during outage" {
+				if got.Type != wire.MsgOutput || string(got.Payload) != "preserved during outage" {
 					t.Fatalf("client got %+v, want retried output", got)
 				}
 			case <-time.After(time.Second):
 	const frames = 4
 	for i := range frames {
 		client.sendErr <- ErrPendingFull
-		daemon.recv <- recvResult{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}}
+		daemon.recv <- recvResult{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}}
 		select {
 		case got := <-client.sent:
-			if got.Type != ports.MsgOutput || len(got.Payload) != 1 || got.Payload[0] != byte(i) {
+			if got.Type != wire.MsgOutput || len(got.Payload) != 1 || got.Payload[0] != byte(i) {
 				t.Fatalf("frame %d delivered out of order or dropped: %+v", i, got)
 			}
 		case <-time.After(time.Second):
 	}()
 	client.sendErr <- ErrLinkDead
-	daemon.recv <- recvResult{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("client is gone")}}
+	daemon.recv <- recvResult{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("client is gone")}}
 	waitForProxyManualTimers(t, clk, 1)
 	select {
 	case err := <-errCh:
 	return &retryingOfflineTransport{closed: make(chan struct{}), firstSend: make(chan struct{})}
 }
-func (t *retryingOfflineTransport) Send(ports.Frame) error {
+func (t *retryingOfflineTransport) Send(wire.Frame) error {
 	t.firstSendOnce.Do(func() { close(t.firstSend) })
 	return errors.New("offline")
 }
-func (t *retryingOfflineTransport) Recv() (ports.Frame, error) {
+func (t *retryingOfflineTransport) Recv() (wire.Frame, error) {
 	<-t.closed
-	return ports.Frame{}, io.EOF
+	return wire.Frame{}, io.EOF
 }
 func (t *retryingOfflineTransport) Close() error {
 		close(done)
 	}()
-	daemon.recv <- recvResult{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("retry until cancel")}}
+	daemon.recv <- recvResult{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("retry until cancel")}}
 	select {
 	case <-client.firstSend:
 	case <-time.After(time.Second):
 func TestClampDatagramHelloOutputWindowPreservesProtocolValidation(t *testing.T) {
 	t.Run("malformed payload remains malformed", func(t *testing.T) {
-		payload := append(ports.MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8}), 0xff)
+		payload := append(wire.MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8}), 0xff)
-		frame := ports.Frame{Type: ports.MsgHello, Payload: payload}
+		frame := wire.Frame{Type: wire.MsgHello, Payload: payload}
 		got := clampDatagramHelloOutputWindow(frame)
 		if !reflect.DeepEqual(got, frame) {
 			t.Fatalf("malformed Hello changed: got %#v, want %#v", got, frame)
 		}
-		if _, err := ports.UnmarshalHello(got.Payload); err == nil {
+		if _, err := wire.UnmarshalHello(got.Payload); err == nil {
 			t.Fatal("malformed Hello became decodable")
 		}
 	})
 	t.Run("mismatched version remains mismatched", func(t *testing.T) {
 		wantVersion := protocol.Version + 1
-		frame := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
+		frame := wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(protocol.Hello{
 			Version: wantVersion, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8,
 		})}
-		got, err := ports.UnmarshalHello(clampDatagramHelloOutputWindow(frame).Payload)
+		got, err := wire.UnmarshalHello(clampDatagramHelloOutputWindow(frame).Payload)
 		if err != nil {
 			t.Fatal(err)
 		}

M internal/adapters/dgram/transport.go +5 -4

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 	recvMu sync.Mutex
 	replay *pdgram.ReplayWindow
 	reasm  *pdgram.Reassembler
-	in     chan ports.Frame
+	in     chan wire.Frame
 	done   chan struct{}
 	// Connection replacement takes writeMu, controlConnMu, then mu. Data writes
 	deliverMu   sync.Mutex
 	deliverCond *sync.Cond
 	nextRecvSeq uint64
-	recvBuf     map[uint64]ports.Frame
+	recvBuf     map[uint64]wire.Frame
 }
 type pending struct {
-	frame           ports.Frame
+	frame           wire.Frame
 	enqueued        time.Time
 	first           time.Time
 	last            time.Time
 type retransmitRecord struct {
 	seq uint64
-	f   ports.Frame
+	f   wire.Frame
 }
 type writeDeadlineState struct {

M internal/adapters/dgram/transport_health_test.go +11 -10

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 	defer func() { _ = a.Close() }()
 	defer func() { _ = b.Close() }()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("survive")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("survive")}); err != nil {
 		t.Fatal(err)
 	}
 	a.mu.Lock()
 	}
 	aPC.drop = nil
 	got := recvWithin(t, b, time.Second)
-	if got.Type != ports.MsgInput || string(got.Payload) != "survive" {
+	if got.Type != wire.MsgInput || string(got.Payload) != "survive" {
 		t.Fatalf("got=%+v, want pending reliable message", got)
 	}
 	select {
 func TestPendingAttemptsResetWhenLinkRecovers(t *testing.T) {
 	tr, _ := newResendTestTransport(t, 10)
 	tr.linkState = ports.LinkStateDegraded
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("stale")}, attempts: 4}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("stale")}, attempts: 4}
-	tr.pending[2] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("stale")}, attempts: 7}
+	tr.pending[2] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("stale")}, attempts: 7}
 	tr.setLinkState(ports.LinkStateConnected, nil)
 	defer func() { _ = a.Close() }()
 	defer func() { _ = b.Close() }()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("first")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("first")}); err != nil {
 		t.Fatal(err)
 	}
 	done := make(chan error, 2)
-	go func() { done <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("second")}) }()
+	go func() { done <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("second")}) }()
-	go func() { done <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("third")}) }()
+	go func() { done <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("third")}) }()
 	waitForManualTimers(t, clk, 2)
 	a.setLinkState(ports.LinkStateDegraded, nil)
 	for i := range 2 {
 	now := time.Now()
 	a.mu.Lock()
 	a.health = healthTracker{lastPacket: now, lastRecord: now.Add(-time.Minute), lastProgress: now.Add(-time.Minute)}
-	a.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput}, enqueued: now.Add(-time.Minute), attempts: 3}
+	a.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput}, enqueued: now.Add(-time.Minute), attempts: 3}
 	a.mu.Unlock()
 	a.checkSilence()
 	}
 	defer func() { _ = tr.Close() }()
 	defer func() { _ = bPC.Close() }()
-	if err := tr.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("unacked")}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("unacked")}); err != nil {
 		t.Fatal(err)
 	}
 	now := tr.clock.Now()
 	tr.linkState = ports.LinkStateDegraded
 	tr.health = healthTracker{lastPacket: now, lastRecord: now.Add(-time.Minute), lastProgress: now.Add(-time.Minute)}
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput}, first: now, last: now}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput}, first: now, last: now}
 	tr.handleRecord(ackRecord(1))
 	if got := tr.LinkState(); got != ports.LinkStateConnected {

M internal/adapters/dgram/transport_lifecycle.go +6 -5

 	"sync"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 		pending:                 make(map[uint64]*pending),
 		replay:                  pdgram.NewReplayWindow(),
 		reasm:                   pdgram.NewReassembler(),
-		in:                      make(chan ports.Frame, 32),
+		in:                      make(chan wire.Frame, 32),
 		done:                    make(chan struct{}),
 		health:                  newHealthTracker(opts.Clock.Now()),
 		lastAuthenticatedPacket: opts.Clock.Now(),
 		probeWait:               make(map[uint64]chan struct{}),
 		rebind:                  opts.RebindPacketConn,
 		nextRecvSeq:             1,
-		recvBuf:                 make(map[uint64]ports.Frame),
+		recvBuf:                 make(map[uint64]wire.Frame),
 	}
 	for _, opt := range runtimeOpts {
 		if opt != nil {
 	return t, nil
 }
-func (t *Transport) Recv() (ports.Frame, error) {
+func (t *Transport) Recv() (wire.Frame, error) {
 	end := t.beginRuntimeOperation(ports.RuntimeAdapterReceiveStart, 0)
 	select {
 	case f := <-t.in:
 		t.mu.Unlock()
 		if err != nil {
 			end(false)
-			return ports.Frame{}, err
+			return wire.Frame{}, err
 		}
 		err = errors.New("dgram: closed")
 		end(false)
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
 }

M internal/adapters/dgram/transport_observability_test.go +4 -3

 	"github.com/bnema/vev/internal/adapters/observability"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestTransportObservabilityDgramFailedCloseEndsReceiveAndSend(t *testing.T) {
 	if err != nil {
 		t.Fatalf("NewTransportWithOptions() error = %v", err)
 	}
-	if err := transport.Send(ports.Frame{Type: ports.MsgOutput, Payload: []byte("write failure")}); err == nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgOutput, Payload: []byte("write failure")}); err == nil {
 		t.Fatal("Send() error = nil on packet write failure")
 	}
 	recvDone := make(chan error, 1)
 	}
 	defer func() { _ = b.Close() }()
-	want := ports.Frame{Type: ports.MsgOutput, Payload: []byte("datagram carriage remains exact")}
+	want := wire.Frame{Type: wire.MsgOutput, Payload: []byte("datagram carriage remains exact")}
 	if err := a.Send(want); err != nil {
 		t.Fatalf("Send() error = %v", err)
 	}
-	gotCh := make(chan ports.Frame, 1)
+	gotCh := make(chan wire.Frame, 1)
 	errCh := make(chan error, 1)
 	go func() {
 		frame, recvErr := b.Recv()

M internal/adapters/dgram/transport_receive.go +8 -7

 	"net"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 	}
 }
-func (t *Transport) enqueueReliable(seq uint64, f ports.Frame) (ackSeq uint64, ack bool, queued bool) {
+func (t *Transport) enqueueReliable(seq uint64, f wire.Frame) (ackSeq uint64, ack bool, queued bool) {
 	t.deliverMu.Lock()
 	defer t.deliverMu.Unlock()
 	if seq < t.nextRecvSeq {
 	return t.closed
 }
-func (t *Transport) deliver(f ports.Frame) {
+func (t *Transport) deliver(f wire.Frame) {
 	select {
 	case t.in <- f:
 	case <-t.done:
 	}
 }
-func encodeData(seq uint64, reliable bool, f ports.Frame) []byte {
+func encodeData(seq uint64, reliable bool, f wire.Frame) []byte {
 	b := make([]byte, dataRecordHeaderSize+len(f.Payload))
 	b[0] = recData
 	binary.BigEndian.PutUint64(b[1:9], seq)
 	copy(b[dataRecordHeaderSize:], f.Payload)
 	return b
 }
-func decodeData(b []byte) (uint64, bool, ports.Frame, bool) {
+func decodeData(b []byte) (uint64, bool, wire.Frame, bool) {
 	if len(b) < dataRecordHeaderSize || b[0] != recData {
-		return 0, false, ports.Frame{}, false
+		return 0, false, wire.Frame{}, false
 	}
 	if b[11] != 0 {
-		return 0, false, ports.Frame{}, false
+		return 0, false, wire.Frame{}, false
 	}
-	return binary.BigEndian.Uint64(b[1:9]), b[9] == 1, ports.Frame{Type: ports.MsgType(b[10]), Payload: append([]byte(nil), b[dataRecordHeaderSize:]...)}, true
+	return binary.BigEndian.Uint64(b[1:9]), b[9] == 1, wire.Frame{Type: wire.MsgType(b[10]), Payload: append([]byte(nil), b[dataRecordHeaderSize:]...)}, true
 }

M internal/adapters/dgram/transport_receive_test.go +18 -17

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 			t.Errorf("close b: %v", err)
 		}
 	}()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("typed")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("typed")}); err != nil {
 		t.Fatal(err)
 	}
 	got := recvWithin(t, b, time.Second)
-	if got.Type != ports.MsgInput || string(got.Payload) != "typed" {
+	if got.Type != wire.MsgInput || string(got.Payload) != "typed" {
 		t.Fatalf("got=%+v", got)
 	}
 	eventually(t, time.Second, droppedAck.Load)
 		t.Fatalf("unauthenticated packet changed peer to %v", a.Peer())
 	}
 	c, _ := pdgram.NewCodec(key())
-	rec := encodeData(7, true, ports.Frame{Type: ports.MsgPing})
+	rec := encodeData(7, true, wire.Frame{Type: wire.MsgPing})
 	frags, _ := pdgram.FragmentPayload(9, rec, pdgram.DefaultMTU)
 	raw, _ := pdgram.MarshalFragment(frags[0])
 	aPC.in <- packet{c.Seal(2, 99, raw, nil), testAddr("evil")}
 }
 func TestReliableReceiveBufferDoesNotDropAckedFutureFrame(t *testing.T) {
-	tr := &Transport{maxRecvBuffer: 1, nextRecvSeq: 1, recvBuf: make(map[uint64]ports.Frame)}
+	tr := &Transport{maxRecvBuffer: 1, nextRecvSeq: 1, recvBuf: make(map[uint64]wire.Frame)}
-	_, ack, queued := tr.enqueueReliable(2, ports.Frame{Type: ports.MsgOutput, Payload: []byte("future")})
+	_, ack, queued := tr.enqueueReliable(2, wire.Frame{Type: wire.MsgOutput, Payload: []byte("future")})
 	if !ack || !queued {
 		t.Fatalf("future enqueue ack=%v queued=%v, want true/true", ack, queued)
 	}
-	_, ack, queued = tr.enqueueReliable(1, ports.Frame{Type: ports.MsgOutput, Payload: []byte("next")})
+	_, ack, queued = tr.enqueueReliable(1, wire.Frame{Type: wire.MsgOutput, Payload: []byte("next")})
 	if !ack || !queued {
 		t.Fatalf("next enqueue ack=%v queued=%v, want true/true", ack, queued)
 	}
 }
 func TestDataRecordWireEncoding(t *testing.T) {
-	got := encodeData(5, true, ports.Frame{Type: ports.MsgOutput, Payload: []byte("x")})
+	got := encodeData(5, true, wire.Frame{Type: wire.MsgOutput, Payload: []byte("x")})
-	want := []byte{recData, 0, 0, 0, 0, 0, 0, 0, 5, 1, byte(ports.MsgOutput), 0, 'x'}
+	want := []byte{recData, 0, 0, 0, 0, 0, 0, 0, 5, 1, byte(wire.MsgOutput), 0, 'x'}
 	if !bytes.Equal(got, want) {
 		t.Fatalf("encoded data=%v, want %v", got, want)
 	}
 	seq, reliable, frame, ok := decodeData(got)
-	if !ok || seq != 5 || !reliable || frame.Type != ports.MsgOutput || string(frame.Payload) != "x" {
+	if !ok || seq != 5 || !reliable || frame.Type != wire.MsgOutput || string(frame.Payload) != "x" {
 		t.Fatalf("decoded seq=%d reliable=%v frame=%+v ok=%v", seq, reliable, frame, ok)
 	}
 }
 func TestDataRecordWireDecodeRejectsUnknownFlags(t *testing.T) {
-	withTrailingGarbage := []byte{recData, 0, 0, 0, 0, 0, 0, 0, 5, 1, byte(ports.MsgOutput), 1, 'x'}
+	withTrailingGarbage := []byte{recData, 0, 0, 0, 0, 0, 0, 0, 5, 1, byte(wire.MsgOutput), 1, 'x'}
 	if _, _, _, ok := decodeData(withTrailingGarbage); ok {
 		t.Fatal("decodeData accepted unknown data-record flags with trailing garbage")
 	}
 	defer func() { _ = b.Close() }()
 	for i := range 100 {
-		if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte{byte(i)}}); err != nil {
+		if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte{byte(i)}}); err != nil {
 			t.Fatal(err)
 		}
 	}
 	for i := range 100 {
 		got := recvWithin(t, b, time.Second)
-		if got.Type != ports.MsgInput || len(got.Payload) != 1 || got.Payload[0] != byte(i) {
+		if got.Type != wire.MsgInput || len(got.Payload) != 1 || got.Payload[0] != byte(i) {
 			t.Fatalf("frame %d delivered out of order: %+v", i, got)
 		}
 	}
 	defer func() { _ = b.Close() }()
 	for i := range cap(b.in) + 20 {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
 			t.Fatal(err)
 		}
 	}
 }
 func TestReliableReceiverAcksOnlyHighestContiguousSequence(t *testing.T) {
-	tr := &Transport{maxRecvBuffer: maxRecvBuffer, nextRecvSeq: 1, recvBuf: make(map[uint64]ports.Frame)}
+	tr := &Transport{maxRecvBuffer: maxRecvBuffer, nextRecvSeq: 1, recvBuf: make(map[uint64]wire.Frame)}
-	ackSeq, ack, queued := tr.enqueueReliable(3, ports.Frame{Type: ports.MsgOutput, Payload: []byte("third")})
+	ackSeq, ack, queued := tr.enqueueReliable(3, wire.Frame{Type: wire.MsgOutput, Payload: []byte("third")})
 	if !ack || !queued {
 		t.Fatalf("out-of-order enqueue ack=%v queued=%v, want true/true", ack, queued)
 	}
 		t.Fatalf("out-of-order ack=%d, want highest contiguous %d", got, want)
 	}
-	ackSeq, ack, queued = tr.enqueueReliable(1, ports.Frame{Type: ports.MsgOutput, Payload: []byte("first")})
+	ackSeq, ack, queued = tr.enqueueReliable(1, wire.Frame{Type: wire.MsgOutput, Payload: []byte("first")})
 	if !ack || !queued {
 		t.Fatalf("first enqueue ack=%v queued=%v, want true/true", ack, queued)
 	}
 		t.Fatalf("first contiguous ack=%d, want %d", got, want)
 	}
-	ackSeq, ack, queued = tr.enqueueReliable(2, ports.Frame{Type: ports.MsgOutput, Payload: []byte("second")})
+	ackSeq, ack, queued = tr.enqueueReliable(2, wire.Frame{Type: wire.MsgOutput, Payload: []byte("second")})
 	if !ack || !queued {
 		t.Fatalf("gap fill enqueue ack=%v queued=%v, want true/true", ack, queued)
 	}

M internal/adapters/dgram/transport_replay_test.go +3 -3


@@ -3,13 +3,13 @@ package dgram
3		import (	3		import (
4		"testing"	4		"testing"
5			5
6	-	"github.com/bnema/vev/internal/ports"	6	+	"github.com/bnema/vev/internal/protocol/wire"
7		"github.com/bnema/vev/internal/testutil/replaytest"	7		"github.com/bnema/vev/internal/testutil/replaytest"
8		"github.com/stretchr/testify/require"	8		"github.com/stretchr/testify/require"
9		)	9		)
10			10
11		func TestTransportReplay(t *testing.T) {	11		func TestTransportReplay(t *testing.T) {
12	-	replaytest.Run(t, func(t *testing.T, frames []ports.Frame) []ports.Frame {	12	+	replaytest.Run(t, func(t *testing.T, frames []wire.Frame) []wire.Frame {
13		link := newSimulatedLink(fixedClock{}, packetPolicy{})	13		link := newSimulatedLink(fixedClock{}, packetPolicy{})
14		leftPC, rightPC := newPairWithCapacity(link, 32)	14		leftPC, rightPC := newPairWithCapacity(link, 32)
15		left, err := NewTransport(leftPC, testAddr("b"), key(), 1, 2)	15		left, err := NewTransport(leftPC, testAddr("b"), key(), 1, 2)

@@ -18,7 +18,7 @@ func TestTransportReplay(t *testing.T) {
18		require.NoError(t, err)	18		require.NoError(t, err)
19		t.Cleanup(func() { _ = left.Close(); _ = right.Close() })	19		t.Cleanup(func() { _ = left.Close(); _ = right.Close() })
20			20
21	-	got := make([]ports.Frame, 0, len(frames))	21	+	got := make([]wire.Frame, 0, len(frames))
22		for _, frame := range frames {	22		for _, frame := range frames {
23		require.NoError(t, left.Send(frame))	23		require.NoError(t, left.Send(frame))
24		link.flush(rightPC)	24		link.flush(rightPC)

M internal/adapters/dgram/transport_retransmit_test.go +21 -20

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestResendSkipsQueuedOutputBeforeFirstWireAttempt(t *testing.T) {
 	tr, writes := newResendTestTransport(t, 10)
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("queued")}}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("queued")}}
 	tr.resendPending()
 	tr, writes := newResendTestTransport(t, 10)
 	now := tr.clock.Now()
 	tr.pending[1] = &pending{
-		frame:           ports.Frame{Type: ports.MsgOutput, Payload: []byte("sending")},
+		frame:           wire.Frame{Type: wire.MsgOutput, Payload: []byte("sending")},
 		first:           now.Add(-time.Second),
 		last:            now.Add(-time.Second),
 		initialInFlight: true,
 			t.Errorf("close b: %v", err)
 		}
 	}()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("typed")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("typed")}); err != nil {
 		t.Fatal(err)
 	}
 	got := recvWithin(t, b, time.Second)
-	if got.Type != ports.MsgInput || string(got.Payload) != "typed" || !dropped.Load() {
+	if got.Type != wire.MsgInput || string(got.Payload) != "typed" || !dropped.Load() {
 		t.Fatalf("got=%+v dropped=%v", got, dropped.Load())
 	}
 }
 			t.Errorf("close b: %v", err)
 		}
 	}()
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("state1")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("state1")}); err != nil {
 		t.Fatal(err)
 	}
 	got := recvWithin(t, b, time.Second)
-	if got.Type != ports.MsgOutput || string(got.Payload) != "state1" || !dropped.Load() {
+	if got.Type != wire.MsgOutput || string(got.Payload) != "state1" || !dropped.Load() {
 		t.Fatalf("got=%+v dropped=%v", got, dropped.Load())
 	}
 }
 		t.Error("ACK did not retire pending frame before WriteTo returned")
 	}
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("state")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("state")}); err != nil {
 		t.Fatal(err)
 	}
 	eventually(t, time.Second, func() bool {
 	defer func() { _ = b.Close() }()
 	for _, payload := range []string{"state1", "state2", "state3"} {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte(payload)}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte(payload)}); err != nil {
 			t.Fatal(err)
 		}
 	}
 	for _, want := range []string{"state1", "state2", "state3"} {
 		got := recvWithin(t, b, time.Second)
-		if got.Type != ports.MsgOutput || string(got.Payload) != want {
+		if got.Type != wire.MsgOutput || string(got.Payload) != want {
 			t.Fatalf("got=%+v, want ordered prerequisite output %q", got, want)
 		}
 	}
 	tr, writes := newResendTestTransport(t, 2)
 	now := tr.clock.Now()
 	for i := range 5 {
-		tr.pending[uint64(i+1)] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}, last: now.Add(-time.Second)}
+		tr.pending[uint64(i+1)] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}, last: now.Add(-time.Second)}
 	}
 	tr.resendPending()
 	now := tr.clock.Now()
 	for seq := uint64(1); seq <= 3; seq++ {
 		tr.pending[seq] = &pending{
-			frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(seq)}},
+			frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(seq)}},
 			last:  now.Add(-time.Second),
 		}
 	}
 	tr, writes := newResendTestTransport(t, 1)
 	now := tr.clock.Now()
 	tr.pending[1] = &pending{
-		frame:     ports.Frame{Type: ports.MsgOutput, Payload: []byte("acked")},
+		frame:     wire.Frame{Type: wire.MsgOutput, Payload: []byte("acked")},
 		first:     now.Add(-time.Second),
 		last:      now.Add(-time.Second),
 		wireBytes: tr.mtu,
 	tr.clock = clk
 	tr.done = make(chan struct{})
 	tr.pending[1] = &pending{
-		frame: ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 24*tr.mtu)},
+		frame: wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 24*tr.mtu)},
 		last:  clk.now.Add(-time.Second),
 	}
 	done := make(chan struct{})
 func TestResendPendingUsesExponentialBackoffAndMaxDelay(t *testing.T) {
 	tr, writes := newResendTestTransport(t, 10)
 	now := tr.clock.Now()
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("too-soon")}, last: now.Add(-150 * time.Millisecond), attempts: 1}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("too-soon")}, last: now.Add(-150 * time.Millisecond), attempts: 1}
-	tr.pending[2] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("ready")}, last: now.Add(-250 * time.Millisecond), attempts: 1}
+	tr.pending[2] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("ready")}, last: now.Add(-250 * time.Millisecond), attempts: 1}
-	tr.pending[3] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte("capped")}, last: now.Add(-time.Second), attempts: 10}
+	tr.pending[3] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte("capped")}, last: now.Add(-time.Second), attempts: 10}
 	tr.resendPending()
 	if got := writes.Load(); got != 2 {
 	tr, _ := newResendTestTransport(t, 10)
 	now := tr.clock.Now()
 	for seq := uint64(1); seq <= 3; seq++ {
-		tr.pending[seq] = &pending{frame: ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(seq)}}, first: now, last: now}
+		tr.pending[seq] = &pending{frame: wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(seq)}}, first: now, last: now}
 	}
 	tr.handleRecord(ackRecord(3))
 	tr.resendAfter = 100 * time.Millisecond
 	tr.maxResendAfter = time.Second
 	tr.rto = tr.resendAfter
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput}, first: clk.now.Add(-200 * time.Millisecond), last: clk.now.Add(-200 * time.Millisecond)}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput}, first: clk.now.Add(-200 * time.Millisecond), last: clk.now.Add(-200 * time.Millisecond)}
 	tr.handleRecord(ackRecord(1))
 	if tr.rto <= tr.resendAfter {
 		t.Fatalf("rto=%v, want above initial resend after RTT sample", tr.rto)
 	}
-	tr.pending[2] = &pending{frame: ports.Frame{Type: ports.MsgOutput}, first: clk.now, last: clk.now.Add(-(tr.rto - time.Millisecond))}
+	tr.pending[2] = &pending{frame: wire.Frame{Type: wire.MsgOutput}, first: clk.now, last: clk.now.Add(-(tr.rto - time.Millisecond))}
 	tr.resendPending()
 	if got := writes.Load(); got != 0 {
 		t.Fatalf("writes before rto=%d, want 0", got)
 	tr.resendAfter = 100 * time.Millisecond
 	tr.maxResendAfter = time.Second
 	tr.rto = tr.resendAfter
-	tr.pending[1] = &pending{frame: ports.Frame{Type: ports.MsgOutput}, first: clk.now.Add(-200 * time.Millisecond), last: clk.now.Add(-tr.resendAfter)}
+	tr.pending[1] = &pending{frame: wire.Frame{Type: wire.MsgOutput}, first: clk.now.Add(-200 * time.Millisecond), last: clk.now.Add(-tr.resendAfter)}
 	tr.resendPending()
 	tr.linkState = ports.LinkStateOffline

M internal/adapters/dgram/transport_send.go +5 -4

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
-func (t *Transport) Send(f ports.Frame) error {
+func (t *Transport) Send(f wire.Frame) error {
 	end := t.beginRuntimeOperation(ports.RuntimeAdapterSendStart, uint64(len(f.Payload)))
 	err := t.send(f, false)
 	end(err == nil)
 	return err
 }
-func (t *Transport) SendAsync(f ports.Frame) error {
+func (t *Transport) SendAsync(f wire.Frame) error {
 	end := t.beginRuntimeOperation(ports.RuntimeAdapterSendStart, uint64(len(f.Payload)))
 	err := t.send(f, true)
 	end(err == nil)
 // SendSynchronous owns queue reservation, fragment pacing, per-write deadlines,
 // and close cancellation. Callers must not layer a shorter preflight timer over it.
-func (t *Transport) SendSynchronous(f ports.Frame) error { return t.Send(f) }
+func (t *Transport) SendSynchronous(f wire.Frame) error { return t.Send(f) }
-func (t *Transport) send(f ports.Frame, async bool) error {
+func (t *Transport) send(f wire.Frame, async bool) error {
 	reliable := true
 	if err := t.lockOutboundSlot(reliable); err != nil {
 		return err

M internal/adapters/dgram/transport_send_test.go +31 -31

 	"time"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 	"github.com/stretchr/testify/require"
 )
 	defer func() { _ = a.Close() }()
 	maxFragmentData := mtu - pdgram.HeaderSize - a.codec.Overhead() - 16
-	frame := ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, maxFragmentData-dataRecordHeaderSize+1)}
+	frame := wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, maxFragmentData-dataRecordHeaderSize+1)}
 	if err := a.Send(frame); err != nil {
 		t.Fatal(err)
 	}
 	defer func() { _ = a.Close() }()
 	maxFragmentData := mtu - pdgram.HeaderSize - a.codec.Overhead()
-	frame := ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 2*maxFragmentData)}
+	frame := wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 2*maxFragmentData)}
 	if err := a.SendAsync(frame); err != nil {
 		t.Fatal(err)
 	}
 	defer func() { _ = a.Close() }()
 	for i := range 3 {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
 			t.Fatal(err)
 		}
 	}
 	eventuallyPacketCount(t, bPC, 3)
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("next")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("next")}); err != nil {
 		t.Fatal(err)
 	}
 	eventuallyPacketCount(t, bPC, 4)
 	}
 	defer func() { _ = a.Close() }()
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("prime")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("prime")}); err != nil {
 		t.Fatal(err)
 	}
 	large := mustMarshalOutput(protocol.Output{Epoch: 1, Base: 1, New: 2, Size: domain.Size{Cols: 1, Rows: 1}, Data: make([]byte, 24*a.mtu)})
 	for range 2 {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: large}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: large}); err != nil {
 			t.Fatal(err)
 		}
 	}
 		t.Fatal(err)
 	}
 	defer func() { _ = a.Close() }()
-	large := ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 24*a.mtu)}
+	large := wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 24*a.mtu)}
 	done := make(chan error, 1)
 	go func() { done <- a.Send(large) }()
 	start := clk.Now()
 	a.srtt = 500 * time.Millisecond
 	a.mu.Unlock()
 	for i := range 8 {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}); err != nil {
 			t.Fatal(err)
 		}
 	}
 	a.mu.Lock()
 	for _, seq := range []uint64{100, 101} {
 		a.pending[seq] = &pending{
-			frame:    ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 20*a.mtu)},
+			frame:    wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 20*a.mtu)},
 			enqueued: now.Add(-time.Second), first: now.Add(-time.Second), last: now.Add(-time.Second),
 		}
 	}
 	a.mu.Unlock()
 	go a.resendPending()
-	sideEffect := ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: make([]byte, 100*1024)})}
+	sideEffect := wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: make([]byte, 100*1024)})}
 	done := make(chan error, 1)
 	go func() { done <- a.SendSynchronous(sideEffect) }()
 	a.writeMu.Lock()
 	for _, payload := range []string{"first", "queued"} {
-		if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte(payload)}); err != nil {
+		if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte(payload)}); err != nil {
 			t.Fatal(err)
 		}
 	}
 	done := make(chan error, 1)
-	go func() { done <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("typed")}) }()
+	go func() { done <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("typed")}) }()
 	select {
 	case err := <-done:
 		a.writeMu.Unlock()
 		t.Fatal(err)
 	}
 	inputDone := make(chan error, 1)
-	go func() { inputDone <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("typed")}) }()
+	go func() { inputDone <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("typed")}) }()
 	if err := <-inputDone; err == nil {
 		t.Fatal("data send succeeded after paced wire failure")
 	}
 func TestCloseUnblocksQueuedSynchronousFrames(t *testing.T) {
 	frames := []struct {
 		name  string
-		frame ports.Frame
+		frame wire.Frame
 	}{
-		{name: "control", frame: ports.Frame{Type: ports.MsgPing}},
+		{name: "control", frame: wire.Frame{Type: wire.MsgPing}},
-		{name: "terminal side effect", frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("osc")})}},
+		{name: "terminal side effect", frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("osc")})}},
 	}
 	for _, tt := range frames {
 		t.Run(tt.name, func(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 3*a.mtu)}); err != nil {
+			if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 3*a.mtu)}); err != nil {
 				t.Fatal(err)
 			}
 			done := make(chan error, 1)
 	if err := bPC.Close(); err != nil {
 		t.Fatal(err)
 	}
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("fails")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("fails")}); err != nil {
 		t.Fatal(err)
 	}
 	case <-time.After(time.Second):
 		t.Fatal("transport remained open after paced output write failed")
 	}
-	if err := a.Send(ports.Frame{Type: ports.MsgInput}); err == nil || err.Error() != "peer closed" {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput}); err == nil || err.Error() != "peer closed" {
 		t.Fatalf("send after paced write failure err=%v, want peer closed", err)
 	}
 }
 	}
 	defer func() { _ = a.Close() }()
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("output")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("output")}); err != nil {
 		t.Fatal(err)
 	}
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("queued")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("queued")}); err != nil {
 		t.Fatal(err)
 	}
 	eventuallyPacketCount(t, bPC, 2)
 	inputDone := make(chan error, 1)
-	go func() { inputDone <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("typed")}) }()
+	go func() { inputDone <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("typed")}) }()
 	eventuallyPacketCount(t, bPC, 3)
 	if err := <-inputDone; err != nil {
 		t.Fatal(err)
 	}
-	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("queued-before-control")}); err != nil {
+	if err := a.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("queued-before-control")}); err != nil {
 		t.Fatal(err)
 	}
 	controlDone := make(chan error, 1)
-	go func() { controlDone <- a.Send(ports.Frame{Type: ports.MsgPing}) }()
+	go func() { controlDone <- a.Send(wire.Frame{Type: wire.MsgPing}) }()
 	eventuallyPacketCount(t, bPC, 5)
 	if err := <-controlDone; err != nil {
 		t.Fatal(err)
 	defer func() { _ = tr.Close() }()
 	done := make(chan error, 1)
-	go func() { done <- tr.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("blocked")}) }()
+	go func() { done <- tr.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("blocked")}) }()
 	select {
 	case err := <-done:
 		if err == nil {
 	defer func() { _ = a.Close() }()
 	defer func() { _ = b.Close() }()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("first")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("first")}); err != nil {
 		t.Fatal(err)
 	}
 	done := make(chan error, 1)
-	go func() { done <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("second")}) }()
+	go func() { done <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("second")}) }()
 	select {
 	case err := <-done:
 	defer func() { _ = a.Close() }()
 	defer func() { _ = b.Close() }()
-	if err := a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("first")}); err != nil {
+	if err := a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("first")}); err != nil {
 		t.Fatal(err)
 	}
 	done := make(chan error, 1)
-	go func() { done <- a.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("second")}) }()
+	go func() { done <- a.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("second")}) }()
 	waitForManualTimers(t, clk, 4)
 	clk.advance(50 * time.Millisecond)
 	}
 	defer func() { _ = tr.Close() }()
-	if err := tr.Send(ports.Frame{Type: ports.MsgInput, Payload: []byte("deadline")}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgInput, Payload: []byte("deadline")}); err != nil {
 		t.Fatal(err)
 	}
 	got, _ := pc.deadline.Load().(time.Time)

M internal/adapters/dgram/transport_test_helpers_test.go +19 -18

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 }
 func TestReliableRecvBufferBoundedForFarFutureSequences(t *testing.T) {
-	tr := &Transport{nextRecvSeq: 1, recvBuf: make(map[uint64]ports.Frame), maxRecvBuffer: maxRecvBuffer, done: make(chan struct{})}
+	tr := &Transport{nextRecvSeq: 1, recvBuf: make(map[uint64]wire.Frame), maxRecvBuffer: maxRecvBuffer, done: make(chan struct{})}
 	tr.deliverCond = sync.NewCond(&tr.deliverMu)
 	for i := range maxRecvBuffer + 100 {
-		tr.enqueueReliable(uint64(1000+i), ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}})
+		tr.enqueueReliable(uint64(1000+i), wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}})
 	}
 	if got := len(tr.recvBuf); got != maxRecvBuffer {
 		t.Fatalf("recvBuf len=%d, want %d", got, maxRecvBuffer)
 	}
-	tr.enqueueReliable(1, ports.Frame{Type: ports.MsgOutput, Payload: []byte("next")})
+	tr.enqueueReliable(1, wire.Frame{Type: wire.MsgOutput, Payload: []byte("next")})
 	if _, ok := tr.recvBuf[1]; !ok {
 		t.Fatalf("next expected sequence was dropped when far-future buffer was full")
 	}
 func TestOutputPrerequisitesRemainInFullReceiveBuffer(t *testing.T) {
 	tr := &Transport{
 		nextRecvSeq:   1,
-		recvBuf:       map[uint64]ports.Frame{2: {Type: ports.MsgOutput, Payload: []byte("stale")}},
+		recvBuf:       map[uint64]wire.Frame{2: {Type: wire.MsgOutput, Payload: []byte("stale")}},
 		maxRecvBuffer: 1,
 		done:          make(chan struct{}),
 	}
 	tr.deliverCond = sync.NewCond(&tr.deliverMu)
-	ackSeq, ack, queued := tr.enqueueReliable(3, ports.Frame{Type: ports.MsgOutput, Payload: []byte("replacement")})
+	ackSeq, ack, queued := tr.enqueueReliable(3, wire.Frame{Type: wire.MsgOutput, Payload: []byte("replacement")})
 	if ack || queued || ackSeq != 0 {
 		t.Fatalf("replacement ackSeq=%d ack=%v queued=%v, want output rejected while prerequisite buffer is full", ackSeq, ack, queued)
 	}
 	if err != nil {
 		t.Fatal(err)
 	}
-	tr := &Transport{pc: aPC, peer: testAddr("b"), codec: codec, sendDir: 1, mtu: pdgram.DefaultMTU, nextRecvSeq: 1, recvBuf: make(map[uint64]ports.Frame), maxRecvBuffer: maxRecvBuffer, clock: realClock{}, done: make(chan struct{})}
+	tr := &Transport{pc: aPC, peer: testAddr("b"), codec: codec, sendDir: 1, mtu: pdgram.DefaultMTU, nextRecvSeq: 1, recvBuf: make(map[uint64]wire.Frame), maxRecvBuffer: maxRecvBuffer, clock: realClock{}, done: make(chan struct{})}
 	tr.deliverCond = sync.NewCond(&tr.deliverMu)
 	defer func() { _ = aPC.Close() }()
 	defer func() { _ = bPC.Close() }()
 	for i := range maxRecvBuffer {
-		tr.recvBuf[uint64(1000+i)] = ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}
+		tr.recvBuf[uint64(1000+i)] = wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}
 	}
-	tr.handleRecord(encodeData(9999, true, ports.Frame{Type: ports.MsgOutput, Payload: []byte("dropped")}))
+	tr.handleRecord(encodeData(9999, true, wire.Frame{Type: wire.MsgOutput, Payload: []byte("dropped")}))
 	select {
 	case pkt := <-bPC.in:
 		t.Fatalf("unexpected ACK packet for dropped frame: %x", pkt.b)
 	case <-time.After(25 * time.Millisecond):
 	}
-	tr.handleRecord(encodeData(1, true, ports.Frame{Type: ports.MsgOutput, Payload: []byte("next")}))
+	tr.handleRecord(encodeData(1, true, wire.Frame{Type: wire.MsgOutput, Payload: []byte("next")}))
 	select {
 	case <-bPC.in:
 	case <-time.After(time.Second):
 	}
 }
-func recvMaybe(tr *Transport, d time.Duration) (ports.Frame, bool) {
+func recvMaybe(tr *Transport, d time.Duration) (wire.Frame, bool) {
-	ch := make(chan ports.Frame, 1)
+	ch := make(chan wire.Frame, 1)
 	go func() { f, _ := tr.Recv(); ch <- f }()
 	select {
 	case f := <-ch:
 		return f, true
 	case <-time.After(d):
-		return ports.Frame{}, false
+		return wire.Frame{}, false
 	}
 }
-func recvWithin(t *testing.T, tr *Transport, d time.Duration) ports.Frame {
+func recvWithin(t *testing.T, tr *Transport, d time.Duration) wire.Frame {
 	t.Helper()
-	ch := make(chan ports.Frame, 1)
+	ch := make(chan wire.Frame, 1)
 	go func() { f, _ := tr.Recv(); ch <- f }()
 	select {
 	case f := <-ch:
 		return f
 	case <-time.After(d):
 		t.Fatal("timeout")
-		return ports.Frame{}
+		return wire.Frame{}
 	}
 }
 	t.Fatalf("peer=%v, want %s", tr.Peer(), want)
 }
-func recvErrWithin(t *testing.T, tr *Transport, d time.Duration) (ports.Frame, error) {
+func recvErrWithin(t *testing.T, tr *Transport, d time.Duration) (wire.Frame, error) {
 	t.Helper()
 	type result struct {
-		f   ports.Frame
+		f   wire.Frame
 		err error
 	}
 	ch := make(chan result, 1)
 		return r.f, r.err
 	case <-time.After(d):
 		t.Fatal("timeout")
-		return ports.Frame{}, nil
+		return wire.Frame{}, nil
 	}
 }

M internal/adapters/dgram/wire_test_helpers_test.go +3 -3

 package dgram
 import (
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalOutput(m protocol.Output) []byte {
-	payload, err := ports.MarshalOutput(m)
+	payload, err := wire.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 	}
 }
 func mustMarshalAck(m protocol.Ack) []byte {
-	payload, err := ports.MarshalAck(m)
+	payload, err := wire.MarshalAck(m)
 	if err != nil {
 		panic(err)
 	}

M internal/adapters/ipc/listener_test.go +3 -3


@@ -9,7 +9,7 @@ import (
9		"strings"	9		"strings"
10		"testing"	10		"testing"
11			11
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol/wire"
13		)	13		)
14			14
15		func TestListenAcceptRoundTrip(t *testing.T) {	15		func TestListenAcceptRoundTrip(t *testing.T) {

@@ -43,7 +43,7 @@ func TestListenAcceptRoundTrip(t *testing.T) {
43		}	43		}
44		defer func() { _ = conn.Close() }()	44		defer func() { _ = conn.Close() }()
45		client := NewTransport(conn)	45		client := NewTransport(conn)
46	-	errCh <- client.Send(ports.Frame{Type: ports.MsgPing})	46	+	errCh <- client.Send(wire.Frame{Type: wire.MsgPing})
47		}()	47		}()
48			48
49		transport, err := ln.Accept()	49		transport, err := ln.Accept()

@@ -56,7 +56,7 @@ func TestListenAcceptRoundTrip(t *testing.T) {
56		if err != nil {	56		if err != nil {
57		t.Fatalf("Recv() error = %v", err)	57		t.Fatalf("Recv() error = %v", err)
58		}	58		}
59	-	if got.Type != ports.MsgPing {	59	+	if got.Type != wire.MsgPing {
60		t.Fatalf("Recv() type = %v, want MsgPing", got.Type)	60		t.Fatalf("Recv() type = %v, want MsgPing", got.Type)
61		}	61		}
62		if err := <-errCh; err != nil {	62		if err := <-errCh; err != nil {

M internal/adapters/ipc/transport.go +13 -12

 	"sync"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // frameHeaderLen is the size, in bytes, of the length prefix that precedes
 var ErrZeroLengthFrame = errors.New("ipc: zero-length frame")
 // ErrFrameTooLarge is returned by Recv when a frame's length field exceeds
-// ports.MaxFrameLen, and by Send when a payload is too large to encode.
+// wire.MaxFrameLen, and by Send when a payload is too large to encode.
 var ErrFrameTooLarge = errors.New("ipc: frame exceeds maximum length")
 // ErrBackpressure means the bounded IPC egress queue is full. Callers using
 }
 // Send queues f for the sole writer and waits for its wire attempt.
-func (t *unixTransport) Send(f ports.Frame) error {
+func (t *unixTransport) Send(f wire.Frame) error {
 	data, err := marshalFrame(f)
 	if err != nil {
 		return err
 // SendAsync accepts f for ordered background transmission without waiting for
 // a socket write. The queue is bounded and ownership includes a payload copy.
-func (t *unixTransport) SendAsync(f ports.Frame) error {
+func (t *unixTransport) SendAsync(f wire.Frame) error {
 	data, err := marshalFrame(f)
 	if err != nil {
 		return err
 	return nil
 }
-func marshalFrame(f ports.Frame) ([]byte, error) {
+func marshalFrame(f wire.Frame) ([]byte, error) {
 	n := 1 + len(f.Payload) // type + payload
-	if n > ports.MaxFrameLen {
+	if n > wire.MaxFrameLen {
 		return nil, ErrFrameTooLarge
 	}
 	buf := make([]byte, frameHeaderLen+n)
 // Recv reads one frame: a 4-byte length, then a body of that many bytes
 // (type byte + payload). It blocks until a full frame arrives, the
 // connection is closed (io.EOF), or an error occurs.
-func (t *unixTransport) Recv() (ports.Frame, error) {
+func (t *unixTransport) Recv() (wire.Frame, error) {
 	end := t.beginOperation(ports.RuntimeAdapterReceiveStart, 0)
 	var hdr [frameHeaderLen]byte
 	if _, err := io.ReadFull(t.conn, hdr[:]); err != nil {
 		end(false)
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
 	n := binary.BigEndian.Uint32(hdr[:])
 	if n == 0 {
 		end(false)
-		return ports.Frame{}, ErrZeroLengthFrame
+		return wire.Frame{}, ErrZeroLengthFrame
 	}
-	if n > ports.MaxFrameLen {
+	if n > wire.MaxFrameLen {
 		end(false)
-		return ports.Frame{}, ErrFrameTooLarge
+		return wire.Frame{}, ErrFrameTooLarge
 	}
 	if cap(t.readBuf) < int(n) {
 	}
 	if _, err := io.ReadFull(t.conn, t.readBuf); err != nil {
 		end(false)
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
 	var payload []byte
 		copy(payload, t.readBuf[1:])
 	}
 	end(true)
-	return ports.Frame{Type: ports.MsgType(t.readBuf[0]), Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgType(t.readBuf[0]), Payload: payload}, nil
 }
 func (t *unixTransport) beginOperation(start ports.RuntimeMarkKind, bytes uint64) func(bool) {

M internal/adapters/ipc/transport_benchmark_test.go +4 -4


@@ -7,14 +7,14 @@ import (
7		"testing"	7		"testing"
8		"time"	8		"time"
9			9
10	-	"github.com/bnema/vev/internal/ports"	10	+	"github.com/bnema/vev/internal/protocol/wire"
11		)	11		)
12			12
13		func BenchmarkTransportSend(b *testing.B) {	13		func BenchmarkTransportSend(b *testing.B) {
14		conn := discardConn{}	14		conn := discardConn{}
15		tr := NewTransport(conn)	15		tr := NewTransport(conn)
16		payload := []byte("payload payload payload")	16		payload := []byte("payload payload payload")
17	-	frame := ports.Frame{Type: ports.MsgOutput, Payload: payload}	17	+	frame := wire.Frame{Type: wire.MsgOutput, Payload: payload}
18			18
19		b.ReportAllocs()	19		b.ReportAllocs()
20		for b.Loop() {	20		for b.Loop() {

@@ -26,7 +26,7 @@ func BenchmarkTransportSend(b *testing.B) {
26			26
27		func BenchmarkTransportRecvReuse(b *testing.B) {	27		func BenchmarkTransportRecvReuse(b *testing.B) {
28		payload := []byte("payload payload payload")	28		payload := []byte("payload payload payload")
29	-	encoded := encodeBenchmarkFrame(ports.Frame{Type: ports.MsgOutput, Payload: payload})	29	+	encoded := encodeBenchmarkFrame(wire.Frame{Type: wire.MsgOutput, Payload: payload})
30		recv := &unixTransport{conn: &loopingReaderConn{data: encoded}}	30		recv := &unixTransport{conn: &loopingReaderConn{data: encoded}}
31			31
32		b.ReportAllocs()	32		b.ReportAllocs()

@@ -37,7 +37,7 @@ func BenchmarkTransportRecvReuse(b *testing.B) {
37		}	37		}
38		}	38		}
39			39
40	-	func encodeBenchmarkFrame(f ports.Frame) []byte {	40	+	func encodeBenchmarkFrame(f wire.Frame) []byte {
41		n := 1 + len(f.Payload)	41		n := 1 + len(f.Payload)
42		buf := make([]byte, frameHeaderLen+n)	42		buf := make([]byte, frameHeaderLen+n)
43		binary.BigEndian.PutUint32(buf[:frameHeaderLen], uint32(n))	43		binary.BigEndian.PutUint32(buf[:frameHeaderLen], uint32(n))

M internal/adapters/ipc/transport_observability_test.go +3 -2

 	"github.com/bnema/vev/internal/adapters/observability"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestTransportObservabilityIPCEOFAndCloseEndFailedSpans(t *testing.T) {
 	left, right := net.Pipe()
 	transport := NewTransport(left, WithRuntimeObserver(reporter))
 	_ = right.Close()
-	if err := transport.Send(ports.Frame{Type: ports.MsgOutput, Payload: []byte("failed")}); err == nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgOutput, Payload: []byte("failed")}); err == nil {
 		t.Fatal("Send() error = nil after peer close")
 	}
 	_ = transport.Close()
 	defer func() { _ = right.Close() }()
 	client := NewTransport(left, WithRuntimeObserver(reporter))
 	server := NewTransport(right, WithRuntimeObserver(reporter))
-	want := ports.Frame{Type: ports.MsgOutput, Payload: []byte("wire bytes stay exact")}
+	want := wire.Frame{Type: wire.MsgOutput, Payload: []byte("wire bytes stay exact")}
 	var wg sync.WaitGroup
 	wg.Go(func() {

M internal/adapters/ipc/transport_replay_test.go +3 -3


@@ -5,12 +5,12 @@ import (
5		"sync"	5		"sync"
6		"testing"	6		"testing"
7			7
8	-	"github.com/bnema/vev/internal/ports"	8	+	"github.com/bnema/vev/internal/protocol/wire"
9		"github.com/bnema/vev/internal/testutil/replaytest"	9		"github.com/bnema/vev/internal/testutil/replaytest"
10		)	10		)
11			11
12		func TestTransportReplay(t *testing.T) {	12		func TestTransportReplay(t *testing.T) {
13	-	replaytest.Run(t, func(t *testing.T, frames []ports.Frame) []ports.Frame {	13	+	replaytest.Run(t, func(t *testing.T, frames []wire.Frame) []wire.Frame {
14		left, right := net.Pipe()	14		left, right := net.Pipe()
15		t.Cleanup(func() { _ = left.Close(); _ = right.Close() })	15		t.Cleanup(func() { _ = left.Close(); _ = right.Close() })
16		sender, receiver := NewTransport(left), NewTransport(right)	16		sender, receiver := NewTransport(left), NewTransport(right)

@@ -24,7 +24,7 @@ func TestTransportReplay(t *testing.T) {
24		}	24		}
25		}	25		}
26		})	26		})
27	-	got := make([]ports.Frame, 0, len(frames))	27	+	got := make([]wire.Frame, 0, len(frames))
28		for range frames {	28		for range frames {
29		frame, err := receiver.Recv()	29		frame, err := receiver.Recv()
30		if err != nil {	30		if err != nil {

M internal/adapters/ipc/transport_test.go +27 -26

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestTransportSendRecvBothDirections(t *testing.T) {
 	client := NewTransport(c1)
 	server := NewTransport(c2)
-	clientToServer := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{Version: 1, Intent: protocol.IntentNew, Name: "w0"})}
+	clientToServer := wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(protocol.Hello{Version: 1, Intent: protocol.IntentNew, Name: "w0"})}
-	serverToClient := ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"})}
+	serverToClient := wire.Frame{Type: wire.MsgWelcome, Payload: wire.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"})}
 	var wg sync.WaitGroup
 	wg.Go(func() {
 	server := NewTransport(c2)
 	// Largest payload whose frame length (1 + len(payload)) still fits
-	// exactly at ports.MaxFrameLen.
+	// exactly at wire.MaxFrameLen.
-	payload := make([]byte, ports.MaxFrameLen-1)
+	payload := make([]byte, wire.MaxFrameLen-1)
 	for i := range payload {
 		payload[i] = byte(i)
 	}
-	want := ports.Frame{Type: ports.MsgOutput, Payload: payload}
+	want := wire.Frame{Type: wire.MsgOutput, Payload: payload}
 	var wg sync.WaitGroup
 	wg.Go(func() {
 	server := NewTransport(c2)
 	const count = 200
-	frames := make([]ports.Frame, count)
+	frames := make([]wire.Frame, count)
 	for i := range frames {
-		frames[i] = ports.Frame{Type: ports.MsgPing, Payload: nil}
+		frames[i] = wire.Frame{Type: wire.MsgPing, Payload: nil}
 	}
 	// Vary a couple to prove ordering and content are both preserved.
-	frames[7] = ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("hop")})}
+	frames[7] = wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("hop")})}
-	frames[150] = ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}
+	frames[150] = wire.Frame{Type: wire.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}
 	var wg sync.WaitGroup
 	wg.Go(func() {
 	go func() {
 		var hdr [4]byte
-		binary.BigEndian.PutUint32(hdr[:], ports.MaxFrameLen+1)
+		binary.BigEndian.PutUint32(hdr[:], wire.MaxFrameLen+1)
 		_, _ = c1.Write(hdr[:])
 	}()
 	defer func() { _ = c2.Close() }()
 	client := NewTransport(c1)
-	payload := make([]byte, ports.MaxFrameLen) // +1 byte type => exceeds max
+	payload := make([]byte, wire.MaxFrameLen) // +1 byte type => exceeds max
-	err := client.Send(ports.Frame{Type: ports.MsgOutput, Payload: payload})
+	err := client.Send(wire.Frame{Type: wire.MsgOutput, Payload: payload})
 	if !errors.Is(err, ErrFrameTooLarge) {
 		t.Fatalf("client.Send() error = %v, want ErrFrameTooLarge", err)
 	}
 		t.Fatal("IPC transport does not implement AsyncTransport")
 	}
-	welcome := ports.Frame{Type: ports.MsgWelcome, Payload: []byte("welcome")}
+	welcome := wire.Frame{Type: wire.MsgWelcome, Payload: []byte("welcome")}
 	sent := make(chan error, 1)
 	go func() { sent <- server.Send(welcome) }()
 	got, err := client.Recv()
 	}
 	payload := []byte("first")
-	if err := async.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: payload}); err != nil {
+	if err := async.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: payload}); err != nil {
 		t.Fatalf("SendAsync first output: %v", err)
 	}
 	payload[0] = 'X' // async ownership must not retain caller memory.
-	if err := async.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("second")}); err != nil {
+	if err := async.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("second")}); err != nil {
 		t.Fatalf("SendAsync second output: %v", err)
 	}
-	for _, want := range []ports.Frame{
+	for _, want := range []wire.Frame{
-		{Type: ports.MsgOutput, Payload: []byte("first")},
+		{Type: wire.MsgOutput, Payload: []byte("first")},
-		{Type: ports.MsgOutput, Payload: []byte("second")},
+		{Type: wire.MsgOutput, Payload: []byte("second")},
 	} {
 		got, err := client.Recv()
 		if err != nil {
 	}
 	queued := fillAsyncEgress(t, transport, async, timeout)
-	want := ports.Frame{Type: ports.MsgOutput, Payload: []byte("synchronous")}
+	want := wire.Frame{Type: wire.MsgOutput, Payload: []byte("synchronous")}
 	sent := make(chan error, 1)
 	go func() { sent <- server.Send(want) }()
 	waitForEgressSender(t, transport, timeout)
 	fillAsyncEgress(t, transport, async, timeout)
 	sent := make(chan error, 1)
-	go func() { sent <- server.Send(ports.Frame{Type: ports.MsgOutput, Payload: []byte("synchronous")}) }()
+	go func() { sent <- server.Send(wire.Frame{Type: wire.MsgOutput, Payload: []byte("synchronous")}) }()
 	waitForEgressSender(t, transport, timeout)
 	closeTransport(t, server)
 	}
 }
-func fillAsyncEgress(t *testing.T, transport *unixTransport, async ports.AsyncTransport, timeout time.Duration) []ports.Frame {
+func fillAsyncEgress(t *testing.T, transport *unixTransport, async ports.AsyncTransport, timeout time.Duration) []wire.Frame {
 	t.Helper()
-	first := ports.Frame{Type: ports.MsgOutput, Payload: []byte{0}}
+	first := wire.Frame{Type: wire.MsgOutput, Payload: []byte{0}}
 	if err := async.SendAsync(first); err != nil {
 		t.Fatalf("SendAsync blocked frame: %v", err)
 	}
 	waitForEgressDequeue(t, transport, timeout)
-	queued := []ports.Frame{first}
+	queued := []wire.Frame{first}
 	for i := 1; ; i++ {
-		frame := ports.Frame{Type: ports.MsgOutput, Payload: []byte{byte(i)}}
+		frame := wire.Frame{Type: wire.MsgOutput, Payload: []byte{byte(i)}}
 		err := async.SendAsync(frame)
 		switch {
 		case err == nil:
 	}
 	// The first write blocks in net.Pipe because the peer never drains it.
-	if err := async.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("blocked")}); err != nil {
+	if err := async.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("blocked")}); err != nil {
 		t.Fatalf("SendAsync blocked frame: %v", err)
 	}
 	var backpressure error
 	for range sendQueueCapacity + 2 {
-		err := async.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("queued")})
+		err := async.SendAsync(wire.Frame{Type: wire.MsgOutput, Payload: []byte("queued")})
 		if errors.Is(err, ErrBackpressure) {
 			backpressure = err
 			break

M internal/adapters/ipc/wire_test_helpers_test.go +2 -2

 package ipc
 import (
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalResize(m protocol.Resize) []byte {
-	payload, err := ports.MarshalResize(m)
+	payload, err := wire.MarshalResize(m)
 	if err != nil {
 		panic(err)
 	}

M internal/adapters/remote/preview.go +3 -2

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const (
 func (c *PreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error) {
 	request := protocol.RemotePreviewRequest{Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: width, Height: height}
-	payload := ports.MarshalRemotePreviewRequest(request)
+	payload := wire.MarshalRemotePreviewRequest(request)
 	if payload == nil {
 		return protocol.RemotePreview{}, protocol.ErrInvalidRemotePreviewRequest
 	}
 	if stdout.overflow || stderr.overflow {
 		return protocol.RemotePreview{}, errRemotePreviewTooLarge
 	}
-	preview, err := ports.UnmarshalRemotePreview(stdout.Bytes())
+	preview, err := wire.UnmarshalRemotePreview(stdout.Bytes())
 	if err != nil {
 		return protocol.RemotePreview{}, err
 	}

M internal/adapters/remote/preview_test.go +4 -4

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/adapters/sshstdio"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func previewClientTargetForTest() domain.RemoteSessionTarget {
 		LifecycleID: lifecycle, TabID: target.LiveTabID, Revision: 7, Width: 1, Height: 1,
 		Cells: []renderer.Cell{{Rune: 'x', Style: renderer.DefaultStyle()}},
 	}
-	payload := ports.MarshalRemotePreview(want)
+	payload := wire.MarshalRemotePreview(want)
 	require.NotNil(t, payload)
 	var gotPath string
 		if err != nil {
 			t.Fatalf("decode request: %v", err)
 		}
-		request, err := ports.UnmarshalRemotePreviewRequest(requestPayload)
+		request, err := wire.UnmarshalRemotePreviewRequest(requestPayload)
 		if err != nil {
 			t.Fatalf("decode request payload: %v", err)
 		}
 		t.Run(tt.name, func(t *testing.T) {
 			preview := valid
 			tt.mutate(&preview)
-			payload := ports.MarshalRemotePreview(preview)
+			payload := wire.MarshalRemotePreview(preview)
 			require.NotNil(t, payload)
 			client := &PreviewClient{command: func(ctx context.Context, _ string, _ ...string) *exec.Cmd {

M internal/adapters/sshstdio/transport.go +9 -8

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const (
-	maxFrameLen     = ports.MaxFrameLen
+	maxFrameLen     = wire.MaxFrameLen
 	frameHeaderLen  = 4
 	sshCloseTimeout = 3 * time.Second
 )
 	return r.pump.read(r.done, dst)
 }
-func (t *transport) Send(f ports.Frame) error {
+func (t *transport) Send(f wire.Frame) error {
 	end := t.beginOperation(ports.RuntimeAdapterSendStart, uint64(len(f.Payload)))
 	n := 1 + len(f.Payload)
 	if n > maxFrameLen {
 	return err
 }
-func (t *transport) Recv() (ports.Frame, error) {
+func (t *transport) Recv() (wire.Frame, error) {
 	end := t.beginOperation(ports.RuntimeAdapterReceiveStart, 0)
 	var hdr [frameHeaderLen]byte
 	if _, err := io.ReadFull(t.r, hdr[:]); err != nil {
 		err = t.mapEOFError(err)
 		end(false)
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
 	n := binary.BigEndian.Uint32(hdr[:])
 	if n == 0 {
 		end(false)
-		return ports.Frame{}, ErrZeroLengthFrame
+		return wire.Frame{}, ErrZeroLengthFrame
 	}
 	if n > maxFrameLen {
 		end(false)
-		return ports.Frame{}, ErrFrameTooLarge
+		return wire.Frame{}, ErrFrameTooLarge
 	}
 	if cap(t.readBuf) < int(n) {
 	if _, err := io.ReadFull(t.r, t.readBuf); err != nil {
 		err = t.mapEOFError(err)
 		end(false)
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
 	payload := append([]byte(nil), t.readBuf[1:]...)
 	end(true)
-	return ports.Frame{Type: ports.MsgType(t.readBuf[0]), Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgType(t.readBuf[0]), Payload: payload}, nil
 }
 func (t *transport) beginOperation(start ports.RuntimeMarkKind, bytes uint64) func(bool) {

M internal/adapters/sshstdio/transport_observability_test.go +2 -1

 	"github.com/bnema/vev/internal/adapters/observability"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestTransportObservabilitySSHStdioEOFEndsReceive(t *testing.T) {
 	reporter := ports.NewSerializedRuntimeObserver(observer, 64)
 	defer reporter.Close()
-	frame := ports.Frame{Type: ports.MsgOutput, Payload: []byte("stdio bytes stay exact")}
+	frame := wire.Frame{Type: wire.MsgOutput, Payload: []byte("stdio bytes stay exact")}
 	var observed, baseline bytes.Buffer
 	if err := NewTransport(bytes.NewReader(nil), &observed, nil, WithRuntimeObserver(reporter)).Send(frame); err != nil {
 		t.Fatalf("observed Send() error = %v", err)

M internal/adapters/sshstdio/transport_replay_test.go +3 -3


@@ -5,12 +5,12 @@ import (
5		"sync"	5		"sync"
6		"testing"	6		"testing"
7			7
8	-	"github.com/bnema/vev/internal/ports"	8	+	"github.com/bnema/vev/internal/protocol/wire"
9		"github.com/bnema/vev/internal/testutil/replaytest"	9		"github.com/bnema/vev/internal/testutil/replaytest"
10		)	10		)
11			11
12		func TestTransportReplay(t *testing.T) {	12		func TestTransportReplay(t *testing.T) {
13	-	replaytest.Run(t, func(t *testing.T, frames []ports.Frame) []ports.Frame {	13	+	replaytest.Run(t, func(t *testing.T, frames []wire.Frame) []wire.Frame {
14		clientRead, serverWrite := io.Pipe()	14		clientRead, serverWrite := io.Pipe()
15		serverRead, clientWrite := io.Pipe()	15		serverRead, clientWrite := io.Pipe()
16		sender := NewTransport(clientRead, clientWrite, func() error { return clientWrite.Close() })	16		sender := NewTransport(clientRead, clientWrite, func() error { return clientWrite.Close() })

@@ -26,7 +26,7 @@ func TestTransportReplay(t *testing.T) {
26		}	26		}
27		}	27		}
28		})	28		})
29	-	got := make([]ports.Frame, 0, len(frames))	29	+	got := make([]wire.Frame, 0, len(frames))
30		for range frames {	30		for range frames {
31		frame, err := receiver.Recv()	31		frame, err := receiver.Recv()
32		if err != nil {	32		if err != nil {

M internal/adapters/sshstdio/transport_test.go +15 -15

 	"time"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestBuildCommandUsesExecArgs(t *testing.T) {
 	transport := NewTransport(nil, writer, nil)
 	sendDone := make(chan error, 1)
-	go func() { sendDone <- transport.Send(ports.Frame{Type: ports.MsgOutput, Payload: []byte("blocked")}) }()
+	go func() { sendDone <- transport.Send(wire.Frame{Type: wire.MsgOutput, Payload: []byte("blocked")}) }()
 	<-writer.started
 	if err := transport.Close(); err != nil {
 		t.Fatalf("Close() error = %v", err)
 			t.Errorf("server Recv: %v", err)
 			return
 		}
-		got, err := ports.UnmarshalHello(f.Payload)
+		got, err := wire.UnmarshalHello(f.Payload)
 		if err != nil {
 			t.Errorf("UnmarshalHello: %v", err)
 			return
 		if got.Version == protocol.Version {
 			t.Errorf("test did not send a mismatched version")
 		}
-		_ = server.Send(ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "protocol version mismatch"})})
+		_ = server.Send(wire.Frame{Type: wire.MsgError, Payload: wire.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "protocol version mismatch"})})
 	}()
-	if err := client.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}); err != nil {
+	if err := client.Send(wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)}); err != nil {
 		t.Fatalf("client Send: %v", err)
 	}
 	reply, err := client.Recv()
 	if err != nil {
 		t.Fatalf("client Recv: %v", err)
 	}
-	if reply.Type != ports.MsgError {
+	if reply.Type != wire.MsgError {
 		t.Fatalf("reply type = %d, want MsgError", reply.Type)
 	}
-	em, err := ports.UnmarshalErrorMsg(reply.Payload)
+	em, err := wire.UnmarshalErrorMsg(reply.Payload)
 	if err != nil {
 		t.Fatalf("UnmarshalErrorMsg: %v", err)
 	}
 }
 func TestTransportUsesCanonicalFrameMaximum(t *testing.T) {
-	boundaryPayload := make([]byte, ports.MaxFrameLen-1)
+	boundaryPayload := make([]byte, wire.MaxFrameLen-1)
 	boundaryWire := &bytes.Buffer{}
 	boundarySend := NewTransport(nil, boundaryWire, nil)
-	if err := boundarySend.Send(ports.Frame{Type: ports.MsgOutput, Payload: boundaryPayload}); err != nil {
+	if err := boundarySend.Send(wire.Frame{Type: wire.MsgOutput, Payload: boundaryPayload}); err != nil {
 		t.Fatalf("boundary Send error = %v", err)
 	}
-	if got := binary.BigEndian.Uint32(boundaryWire.Bytes()[:frameHeaderLen]); got != ports.MaxFrameLen {
+	if got := binary.BigEndian.Uint32(boundaryWire.Bytes()[:frameHeaderLen]); got != wire.MaxFrameLen {
-		t.Fatalf("boundary frame length = %d, want %d", got, ports.MaxFrameLen)
+		t.Fatalf("boundary frame length = %d, want %d", got, wire.MaxFrameLen)
 	}
 	boundaryRecv := NewTransport(bytes.NewReader(boundaryWire.Bytes()), io.Discard, nil)
 	boundaryFrame, err := boundaryRecv.Recv()
 	if err != nil {
 		t.Fatalf("boundary Recv error = %v", err)
 	}
-	if boundaryFrame.Type != ports.MsgOutput || len(boundaryFrame.Payload) != len(boundaryPayload) {
+	if boundaryFrame.Type != wire.MsgOutput || len(boundaryFrame.Payload) != len(boundaryPayload) {
-		t.Fatalf("boundary frame = type %d, payload %d bytes; want type %d, payload %d bytes", boundaryFrame.Type, len(boundaryFrame.Payload), ports.MsgOutput, len(boundaryPayload))
+		t.Fatalf("boundary frame = type %d, payload %d bytes; want type %d, payload %d bytes", boundaryFrame.Type, len(boundaryFrame.Payload), wire.MsgOutput, len(boundaryPayload))
 	}
 	if !bytes.Equal(boundaryFrame.Payload, boundaryPayload) {
 		t.Fatal("boundary payload was corrupted")
 	}
 	send := NewTransport(nil, io.Discard, nil)
-	err = send.Send(ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, ports.MaxFrameLen)})
+	err = send.Send(wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, wire.MaxFrameLen)})
 	if !errors.Is(err, ErrFrameTooLarge) {
 		t.Fatalf("Send error = %v, want ErrFrameTooLarge", err)
 	}
 	var header [frameHeaderLen]byte
-	binary.BigEndian.PutUint32(header[:], ports.MaxFrameLen+1)
+	binary.BigEndian.PutUint32(header[:], wire.MaxFrameLen+1)
 	recv := NewTransport(bytes.NewReader(header[:]), io.Discard, nil)
 	_, err = recv.Recv()
 	if !errors.Is(err, ErrFrameTooLarge) {

M internal/app/cmd.go +6 -5

 	"github.com/bnema/vev/internal/adapters/ipc"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	commandusecase "github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/daemon"
 )
 		return usagef("--self requires running inside a vev pane")
 	}
-	if _, err := ports.MarshalCommandRequest(request); errors.Is(err, ports.ErrTooManyCommandArgs) {
+	if _, err := wire.MarshalCommandRequest(request); errors.Is(err, wire.ErrTooManyCommandArgs) {
 		return usagef("too many command arguments")
 	} else if err != nil {
 		return fmt.Errorf("encoding command: %w", err)
 	const generation = uint64(1)
 	requestID, outcome := tracker.Publish(generation)
 	request.RequestID = requestID
-	payload, err := ports.MarshalCommandRequest(request)
+	payload, err := wire.MarshalCommandRequest(request)
 	if err != nil {
 		tracker.Remove(requestID, generation)
 		return fmt.Errorf("encoding command: %w", err)
 	}
-	if err := transport.Send(ports.Frame{Type: ports.MsgCommand, Payload: payload}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgCommand, Payload: payload}); err != nil {
 		tracker.Remove(requestID, generation)
 		return &exitCoded{code: 3, err: fmt.Errorf("sending command: %w", err)}
 	}
 			tracker.Fail(requestID, generation, fmt.Errorf("reading command reply: %w", recvErr))
 			return
 		}
-		if reply.Type != ports.MsgCommandResult {
+		if reply.Type != wire.MsgCommandResult {
 			tracker.Fail(requestID, generation, fmt.Errorf("unexpected command reply type %d", reply.Type))
 			return
 		}
-		result, decodeErr := ports.UnmarshalCommandResult(reply.Payload)
+		result, decodeErr := wire.UnmarshalCommandResult(reply.Payload)
 		if decodeErr != nil {
 			tracker.Fail(requestID, generation, fmt.Errorf("decoding command reply: %w", decodeErr))
 			return

M internal/app/cmd_test.go +21 -20

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 		t.Run(tt.slug, func(t *testing.T) {
 			parsed, err := parseArgs(append([]string{"cmd", tt.slug}, tt.args...))
 			require.NoError(t, err)
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
+			transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 			require.NoError(t, runCmdWithDeps(context.Background(), parsed.cmd, cmdDeps{
 				stdout: io.Discard,
 				getenv: func(string) string { return "" },
 				dial:   func(context.Context, string) (ports.Transport, error) { return transport, nil },
 			}))
 			require.Len(t, transport.sent, 1)
-			request, err := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+			request, err := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 			require.NoError(t, err)
 			require.Equal(t, tt.slug, request.Slug)
 			require.Equal(t, tt.args, request.Args)
 }
 func TestRemoteCatalogCommandEnsuresDaemon(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	ensureCalls := 0
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "remote-catalog", jsonOut: true}, cmdDeps{
 		stdout: io.Discard,
 		{slug: "move-tab", args: []string{"work", "extra"}},
 	} {
 		t.Run(invocation.slug+"/"+strconv.Itoa(len(invocation.args)), func(t *testing.T) {
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{
+			transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{
 				Code: protocol.ErrInvalidCommandArgs, Text: "invalid command arguments",
 			})}}
 			err := runCmdWithDeps(context.Background(), invocation, cmdDeps{
 		t.Run(slug, func(t *testing.T) {
 			invocation, err := parseArgs([]string{"cmd", "--self", slug})
 			require.NoError(t, err)
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
+			transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 			require.NoError(t, runCmdWithDeps(context.Background(), invocation.cmd, cmdDeps{
 				stdout: io.Discard,
 				getenv: func(string) string { return "session=work,tab=t_abc,pane=p_def" },
 				dial:   func(context.Context, string) (ports.Transport, error) { return transport, nil },
 			}))
 			require.Len(t, transport.sent, 1)
-			request, err := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+			request, err := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 			require.NoError(t, err)
 			require.Equal(t, slug, request.Slug)
 			require.True(t, request.Self)
 }
 func TestRunCmdBuildsOneShotTargetedRequest(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true, Output: "done"})}}
+	transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true, Output: "done"})}}
 	out := new(strings.Builder)
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right", self: true}, cmdDeps{
 		stdout: out,
 	if len(transport.sent) != 1 || transport.recvCalls != 1 || transport.closeCalls != 1 {
 		t.Fatalf("transport calls: sent=%d recv=%d close=%d", len(transport.sent), transport.recvCalls, transport.closeCalls)
 	}
-	req, err := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+	req, err := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 	if err != nil {
 		t.Fatalf("decode request: %v", err)
 	}
-	if transport.sent[0].Type != ports.MsgCommand || req.Slug != "split-right" || !req.Self || req.TargetSession != "old" || req.TargetTab != "t_abc" || req.TargetPane != "p_def" {
+	if transport.sent[0].Type != wire.MsgCommand || req.Slug != "split-right" || !req.Self || req.TargetSession != "old" || req.TargetTab != "t_abc" || req.TargetPane != "p_def" {
 		t.Fatalf("request = type %d %+v", transport.sent[0].Type, req)
 	}
 	if out.String() != "done\n" {
 }
 func TestRunCmdVEVWithoutSelfUsesIDsOnlyAsSessionLocator(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right"}, cmdDeps{
 		stdout: io.Discard,
 		getenv: func(string) string { return "session=old,tab=t_abc,pane=p_def" },
 	if err != nil {
 		t.Fatalf("runCmdWithDeps: %v", err)
 	}
-	req, err := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+	req, err := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 	if err != nil {
 		t.Fatalf("decode request: %v", err)
 	}
 }
 func TestRunCmdExplicitSessionDoesNotUseEnvIDsWithoutSelf(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "new-tab", session: "current"}, cmdDeps{
 		stdout: io.Discard,
 		getenv: func(string) string { return "session=old,tab=t_abc,pane=p_def" },
 	if err != nil {
 		t.Fatalf("runCmdWithDeps: %v", err)
 	}
-	req, err := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+	req, err := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 	if err != nil {
 		t.Fatalf("decode request: %v", err)
 	}
 	if ExitCode(err) != 3 || !errors.Is(err, daemon.ErrCommandRequestTimeout) {
 		t.Fatalf("timeout error=%v code=%d", err, ExitCode(err))
 	}
-	request, decodeErr := ports.UnmarshalCommandRequest(transport.sent[0].Payload)
+	request, decodeErr := wire.UnmarshalCommandRequest(transport.sent[0].Payload)
 	if decodeErr != nil || request.RequestID == 0 {
 		t.Fatalf("request=%+v decode=%v, want non-zero request ID", request, decodeErr)
 	}
 func TestRunCmdZeroRequestIDReplyReturnsDaemonError(t *testing.T) {
 	const want = "daemon error"
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{
+	transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(protocol.CommandResult{
 		Code: protocol.ErrInternal, Text: want,
 	})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right"}, cmdDeps{
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(tt.result)}}
+			transport := &cmdTestTransport{recv: wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(tt.result)}}
 			err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right"}, cmdDeps{
 				stdout: io.Discard,
 				getenv: func(string) string { return "" },
 }
 type cmdTestTransport struct {
-	sent        []ports.Frame
+	sent        []wire.Frame
-	recv        ports.Frame
+	recv        wire.Frame
 	recvErr     error
 	recvCalls   int
 	closeCalls  int
 	recvGate    <-chan struct{}
 }
-func (t *cmdTestTransport) Send(frame ports.Frame) error {
+func (t *cmdTestTransport) Send(frame wire.Frame) error {
 	t.sent = append(t.sent, frame)
 	return nil
 }
-func (t *cmdTestTransport) Recv() (ports.Frame, error) {
+func (t *cmdTestTransport) Recv() (wire.Frame, error) {
 	t.recvCalls++
 	if t.recvStarted != nil {
 		close(t.recvStarted)

M internal/app/daemon_integration_test.go +38 -37

 	"github.com/bnema/vev/internal/persist"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/bnema/vev/internal/usecase/recovery"
 )
 // pump wires a background Recv pump to a transport so tests can await frames
 // with a timeout (ports.Transport has no read deadline).
-type pump struct{ ch chan ports.Frame }
+type pump struct{ ch chan wire.Frame }
 func recvPump(tr ports.Transport) *pump {
-	p := &pump{ch: make(chan ports.Frame, 128)}
+	p := &pump{ch: make(chan wire.Frame, 128)}
 	go func() {
 		for {
 			f, err := tr.Recv()
 	tr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	hello := protocol.Hello{Version: protocol.Version, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color", TrueColor: true, Env: env}
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)}))
 	p := recvPump(tr)
 	select {
 	case f, ok := <-p.ch:
 		require.True(t, ok, "connection closed before welcome")
-		require.Equal(t, ports.MsgWelcome, f.Type)
+		require.Equal(t, wire.MsgWelcome, f.Type)
 	case <-time.After(3 * time.Second):
 		t.Fatal("timed out waiting for welcome")
 	}
 	tr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = tr.Close() }()
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgList, Payload: wire.MarshalList(protocol.List{})}))
 	f, err := tr.Recv()
 	require.NoError(t, err)
-	require.Equal(t, ports.MsgSessions, f.Type)
+	require.Equal(t, wire.MsgSessions, f.Type)
-	sessions, err := ports.UnmarshalSessions(f.Payload)
+	sessions, err := wire.UnmarshalSessions(f.Payload)
 	require.NoError(t, err)
 	return sessions
 }
 		return err
 	}
 	defer func() { _ = tr.Close() }()
-	if err := tr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgKill, Payload: wire.MarshalKill(protocol.Kill{All: true})}); err != nil {
 		return err
 	}
 	_, err = tr.Recv()
 			if !ok {
 				t.Fatalf("connection closed before %q appeared; screen=%q", want, screenText(screen))
 			}
-			if f.Type == ports.MsgOutput {
+			if f.Type == wire.MsgOutput {
-				o, err := ports.UnmarshalOutput(f.Payload)
+				o, err := wire.UnmarshalOutput(f.Payload)
 				require.NoError(t, err)
 				screen.Write(o.Data)
 				text := screenText(screen)
 			if !ok {
 				return
 			}
-			if f.Type == ports.MsgOutput {
+			if f.Type == wire.MsgOutput {
-				o, err := ports.UnmarshalOutput(f.Payload)
+				o, err := wire.UnmarshalOutput(f.Payload)
 				require.NoError(t, err)
 				screen.Write(o.Data)
 				require.NotContains(t, screenText(screen), absent)
 func assertChildEnvironment(t *testing.T, tr ports.Transport, p *pump, sz domain.Size, wantTestEnv, wantShell, wantRuntimeDir, wantWayland string) {
 	t.Helper()
 	command := "printf '\\033[2J\\033[H'; printf 'VEV_TEST_ENV=%s SHELL=%s XDG_RUNTIME_DIR=%s WAYLAND_DISPLAY=%s TERM=%s COLORTERM=%s TERM_PROGRAM=%s VEV_PREFIX=%.24s\\n' \"$VEV_TEST_ENV\" \"${SHELL##*/}\" \"$XDG_RUNTIME_DIR\" \"$WAYLAND_DISPLAY\" \"$TERM\" \"$COLORTERM\" \"$TERM_PROGRAM\" \"$VEV\"\n"
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(command)})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte(command)})}))
 	text := awaitScreenText(t, p, sz, "TERM_PROGRAM=vev")
 	for _, want := range []string{
 		"VEV_TEST_ENV=" + wantTestEnv,
 	// The first shell was already running, so it retains its original environment.
 	assertChildEnvironment(t, tr2, p2, sz, "first", firstShell, "/run/first", "wayland-first")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr2.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p2, sz, "Commands")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr2.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	awaitText(t, p2, sz, "SHELL_COMMAND=second")
 	assertChildEnvironment(t, tr2, p2, sz, "second", secondShell, "/run/second", "wayland-second")
 }
 	// The second attachment mutates shared tab state. Its newly opened PTY must
 	// also be rendered to that attachment, not only to the coordinator primary.
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr2.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p2, sz, "Commands")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr2.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	awaitText(t, p2, sz, "SHELL_COMMAND=second")
 	// Each attachment owns its selected tab. Move the first attachment to the
 	// new PTY before releasing its gate, so the fresh PTY output must reach both
 	// views rather than only being recovered by a later first paint.
-	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b2")})}))
+	require.NoError(t, tr1.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1b2")})}))
 	awaitText(t, p1, sz, "SHELL_COMMAND=second")
-	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("go\n")})}))
+	require.NoError(t, tr1.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("go\n")})}))
 	awaitText(t, p2, sz, sharedOutput)
 	awaitText(t, p1, sz, sharedOutput)
 }
 	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("PINGPONG\n")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("PINGPONG\n")})}))
 	awaitText(t, p, sz, "PINGPONG")
 }
 	defer func() { _ = tr.Close() }()
 	awaitText(t, p, sz, "READY")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p, sz, "Commands")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	// Tab labels are enriched with the focused pane's title; with no process
 	// inspector wired in this test, that title falls back to the shell's
 	// basename ("sh").
 	text := awaitScreenText(t, p, sz, "READY")
 	require.Contains(t, text, " 0* ")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p, sz, "Commands")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("RNS\r")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("RNS\r")})}))
 	awaitText(t, p, sz, "Rename session")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x7fwork\r")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x7fwork\r")})}))
 	text = awaitScreenText(t, p, sz, " work ")
 	require.NotContains(t, text, "work*")
 	listTr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = listTr.Close() }()
-	require.NoError(t, listTr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}))
+	require.NoError(t, listTr.Send(wire.Frame{Type: wire.MsgList, Payload: wire.MarshalList(protocol.List{})}))
 	f, err := listTr.Recv()
 	require.NoError(t, err)
-	require.Equal(t, ports.MsgSessions, f.Type)
+	require.Equal(t, wire.MsgSessions, f.Type)
-	sessions, err := ports.UnmarshalSessions(f.Payload)
+	sessions, err := wire.UnmarshalSessions(f.Payload)
 	require.NoError(t, err)
 	require.NotEmpty(t, sessions.Sessions)
 	require.Equal(t, "work", sessions.Sessions[0].Name)
 	text := awaitScreenText(t, p, sz, "READY")
 	require.NotContains(t, text, " 1  2 ")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1bc")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("\x1bc")})}))
 	assertNoTextAfterInput(t, p, sz, " 1  2 ")
 }
 	go func() { served <- d.Serve(ctx, listener) }()
 	tr, _ := attach(t, runtimeDir, protocol.IntentNew, name, domain.Size{Cols: 80, Rows: 24})
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("checkpoint me\n")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("checkpoint me\n")})}))
 	require.Eventually(t, func() bool {
 		record, ok, _ := opened.Catalogue.Record(name)
 		return ok && record.Committed != nil && record.DegradedReason == ""
 	awaitLifecycleStage(t, listenerReady, "daemon listener")
 	tr, _ := attach(t, runtimeDir, protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24})
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("dirty state\n")})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte("dirty state\n")})}))
 	awaitLifecycleStage(t, repository.entered, "snapshot publication")
 	require.NoError(t, tr.Close())
 	require.Eventually(t, func() bool {
 type integrationTransport struct{}
-func (*integrationTransport) Send(ports.Frame) error     { return nil }
+func (*integrationTransport) Send(wire.Frame) error     { return nil }
-func (*integrationTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*integrationTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*integrationTransport) Close() error               { return nil }
+func (*integrationTransport) Close() error              { return nil }
-func (*integrationTransport) LocalAddr() net.Addr        { return nil }
+func (*integrationTransport) LocalAddr() net.Addr       { return nil }
-func (*integrationTransport) RemoteAddr() net.Addr       { return nil }
+func (*integrationTransport) RemoteAddr() net.Addr      { return nil }
 func TestIntegration_KillAllShutsDownDaemon(t *testing.T) {
 	sz := domain.Size{Cols: 80, Rows: 24}
 	killTr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = killTr.Close() }()
-	require.NoError(t, killTr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}))
+	require.NoError(t, killTr.Send(wire.Frame{Type: wire.MsgKill, Payload: wire.MarshalKill(protocol.Kill{All: true})}))
 	_, err = killTr.Recv()
 	require.ErrorIs(t, err, io.EOF)

M internal/app/final_acceptance_test.go +17 -16

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/stretchr/testify/require"
 )
 func sendAcceptanceInput(t *testing.T, tr ports.Transport, data string) {
 	t.Helper()
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(data)})}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte(data)})}))
 }
-func awaitAcceptanceFrame(t *testing.T, p *pump, typ ports.MsgType, predicate func(ports.Frame) bool) ports.Frame {
+func awaitAcceptanceFrame(t *testing.T, p *pump, typ wire.MsgType, predicate func(wire.Frame) bool) wire.Frame {
 	t.Helper()
 	deadline := time.NewTimer(5 * time.Second)
 	defer deadline.Stop()
 func awaitAcceptanceCommand(t *testing.T, p *pump, requestID uint64) protocol.CommandResult {
 	t.Helper()
-	frame := awaitAcceptanceFrame(t, p, ports.MsgCommandResult, func(frame ports.Frame) bool {
+	frame := awaitAcceptanceFrame(t, p, wire.MsgCommandResult, func(frame wire.Frame) bool {
-		result, err := ports.UnmarshalCommandResult(frame.Payload)
+		result, err := wire.UnmarshalCommandResult(frame.Payload)
 		require.NoError(t, err)
 		return result.RequestID == requestID
 	})
-	result, err := ports.UnmarshalCommandResult(frame.Payload)
+	result, err := wire.UnmarshalCommandResult(frame.Payload)
 	require.NoError(t, err)
 	return result
 }
 func awaitAcceptanceOutput(t *testing.T, p *pump, predicate func(protocol.Output) bool) protocol.Output {
 	t.Helper()
-	frame := awaitAcceptanceFrame(t, p, ports.MsgOutput, func(frame ports.Frame) bool {
+	frame := awaitAcceptanceFrame(t, p, wire.MsgOutput, func(frame wire.Frame) bool {
-		output, err := ports.UnmarshalOutput(frame.Payload)
+		output, err := wire.UnmarshalOutput(frame.Payload)
 		require.NoError(t, err)
 		return predicate(output)
 	})
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	return output
 }
 func awaitAcceptanceCommandResult(t *testing.T, tr ports.Transport, p *pump, requestID uint64, slug string) protocol.CommandResult {
 	t.Helper()
-	payload, err := ports.MarshalCommandRequest(protocol.CommandRequest{
+	payload, err := wire.MarshalCommandRequest(protocol.CommandRequest{
 		Version: protocol.Version, RequestID: requestID, Attached: true, Slug: slug,
 	})
 	require.NoError(t, err)
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgCommand, Payload: payload}))
+	require.NoError(t, tr.Send(wire.Frame{Type: wire.MsgCommand, Payload: payload}))
 	return awaitAcceptanceCommand(t, p, requestID)
 }
 	// The resize keeps its attachment-local output stream while recalculating
 	// shared PTY/content geometry from the latest valid attachment claim; the
 	// peer stream remains independent.
-	resizePayload, err := ports.MarshalResize(protocol.Resize{Size: domain.Size{Cols: 100, Rows: 30}})
+	resizePayload, err := wire.MarshalResize(protocol.Resize{Size: domain.Size{Cols: 100, Rows: 30}})
 	require.NoError(t, err)
-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgResize, Payload: resizePayload}))
+	require.NoError(t, first.Send(wire.Frame{Type: wire.MsgResize, Payload: resizePayload}))
 	resized := awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Size == (domain.Size{Cols: 100, Rows: 30}) })
 	require.Equal(t, domain.Size{Cols: 100, Rows: 30}, resized.Size)
 	assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")
-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
+	require.NoError(t, first.Send(wire.Frame{Type: wire.MsgOutputResetRequest, Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
 	reset := awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Base == 0 && output.Full })
 	require.True(t, reset.Full)
 	assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")
-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}))
+	require.NoError(t, first.Send(wire.Frame{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})}))
 	deadline := time.NewTimer(5 * time.Second)
 	defer deadline.Stop()
 	for {
 		select {
 		case frame := <-firstPump.ch:
-			if frame.Type == ports.MsgDetached {
+			if frame.Type == wire.MsgDetached {
 				goto detached
 			}
 		case <-deadline.C:
 	}
 drained:
-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
+	require.NoError(t, first.Send(wire.Frame{Type: wire.MsgOutputResetRequest, Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
 	awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Full && output.Base == 0 })
 	assertNoTextAfterInput(t, secondPump, size, "Commands")
 }

M internal/app/remote_final_acceptance_test.go +12 -11

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 	"github.com/stretchr/testify/require"
 )
 			return
 		}
 		if !welcomed {
-			if frame.Type != ports.MsgHello {
+			if frame.Type != wire.MsgHello {
 				continue
 			}
-			if err := tr.Send(ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: target})}); err != nil {
+			if err := tr.Send(wire.Frame{Type: wire.MsgWelcome, Payload: wire.MarshalWelcome(protocol.Welcome{SessionID: target})}); err != nil {
 				return
 			}
 			welcomed = true
 			continue
 		}
 		if handoff.Endpoint != "" {
-			_ = tr.Send(ports.Frame{Type: ports.MsgAttachTarget, Payload: ports.MarshalAttachTarget(handoff)})
+			_ = tr.Send(wire.Frame{Type: wire.MsgAttachTarget, Payload: wire.MarshalAttachTarget(handoff)})
 			for {
 				if _, err := tr.Recv(); err != nil {
 					return
 		if outputs != nil {
 			outputs <- string(data)
 		}
-		payload, err := ports.MarshalOutput(protocol.Output{
+		payload, err := wire.MarshalOutput(protocol.Output{
 			Epoch: 1, New: 1, Full: true, Size: domain.Size{Cols: 80, Rows: 24}, Data: data,
 		})
 		if err != nil {
 			return
 		}
-		if err := tr.Send(ports.Frame{Type: ports.MsgOutput, Payload: payload}); err != nil {
+		if err := tr.Send(wire.Frame{Type: wire.MsgOutput, Payload: payload}); err != nil {
 			return
 		}
-		_ = tr.Send(ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})})
+		_ = tr.Send(wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})})
 		for {
 			if _, err := tr.Recv(); err != nil {
 				return
 		handoff: protocol.AttachTarget{Endpoint: "picked.example", Session: "picked", Intent: protocol.IntentAttach},
 	}).Dial(context.Background())
 	require.NoError(t, err)
-	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
+	require.NoError(t, wireTransport.Send(wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(protocol.Hello{
 		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24},
 	})}))
 	welcome, err := wireTransport.Recv()
 	require.NoError(t, err)
-	require.Equal(t, ports.MsgWelcome, welcome.Type)
+	require.Equal(t, wire.MsgWelcome, welcome.Type)
-	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(protocol.Theme{})}))
+	require.NoError(t, wireTransport.Send(wire.Frame{Type: wire.MsgTheme, Payload: wire.MarshalTheme(protocol.Theme{})}))
 	attachTarget, err := wireTransport.Recv()
 	require.NoError(t, err)
-	target, err := ports.UnmarshalAttachTarget(attachTarget.Payload)
+	target, err := wire.UnmarshalAttachTarget(attachTarget.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.MsgAttachTarget, attachTarget.Type)
+	require.Equal(t, wire.MsgAttachTarget, attachTarget.Type)
 	require.Equal(t, "picked.example", target.Endpoint)
 	require.NoError(t, wireTransport.Close())

M internal/app/remote_preview.go +8 -8

 	"os"
 	"github.com/bnema/vev/internal/adapters/ipc"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // runRemotePreview is the hidden SSH-side carriage. The request is encoded in
 	if err != nil {
 		return fmt.Errorf("vev: invalid remote preview request: %w", err)
 	}
-	if _, err := ports.UnmarshalRemotePreviewRequest(request); err != nil {
+	if _, err := wire.UnmarshalRemotePreviewRequest(request); err != nil {
 		return fmt.Errorf("vev: invalid remote preview request: %w", err)
 	}
 	transport, err := ipc.DialContext(ctx, ipc.SocketDir())
 		return writeRemotePreviewStatus(protocol.RemotePreviewUnavailable)
 	}
 	defer func() { _ = transport.Close() }()
-	if err := transport.Send(ports.Frame{Type: ports.MsgRemotePreviewRequest, Payload: request}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgRemotePreviewRequest, Payload: request}); err != nil {
 		return fmt.Errorf("vev: sending remote preview request: %w", err)
 	}
 	frameCh := make(chan struct {
-		frame ports.Frame
+		frame wire.Frame
 		err   error
 	}, 1)
 	go func() {
 		frame, err := transport.Recv()
 		frameCh <- struct {
-			frame ports.Frame
+			frame wire.Frame
 			err   error
 		}{frame: frame, err: err}
 	}()
 		if result.err != nil {
 			return fmt.Errorf("vev: receiving remote preview: %w", result.err)
 		}
-		if result.frame.Type != ports.MsgRemotePreviewResponse {
+		if result.frame.Type != wire.MsgRemotePreviewResponse {
 			return fmt.Errorf("vev: unexpected remote preview response %d", result.frame.Type)
 		}
-		if _, err := ports.UnmarshalRemotePreview(result.frame.Payload); err != nil {
+		if _, err := wire.UnmarshalRemotePreview(result.frame.Payload); err != nil {
 			return fmt.Errorf("vev: malformed remote preview response: %w", err)
 		}
 		_, err := os.Stdout.Write(result.frame.Payload)
 }
 func writeRemotePreviewStatus(status protocol.RemotePreviewStatus) error {
-	payload := ports.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: status})
+	payload := wire.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: status})
 	if payload == nil {
 		return errors.New("vev: failed to encode remote preview status")
 	}

M internal/app/remote_test.go +5 -4

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 func TestDecodeSessionListErrorReply(t *testing.T) {
 	t.Run("valid", func(t *testing.T) {
-		_, err := decodeSessionListReply(ports.Frame{
+		_, err := decodeSessionListReply(wire.Frame{
-			Type:    ports.MsgError,
+			Type:    wire.MsgError,
-			Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Text: "denied"}),
+			Payload: wire.MarshalErrorMsg(protocol.ErrorMsg{Text: "denied"}),
 		})
 		require.EqualError(t, err, "vev: denied")
 	})
 	t.Run("malformed", func(t *testing.T) {
-		_, err := decodeSessionListReply(ports.Frame{Type: ports.MsgError, Payload: []byte{0}})
+		_, err := decodeSessionListReply(wire.Frame{Type: wire.MsgError, Payload: []byte{0}})
 		require.ErrorContains(t, err, "vev: decoding error reply")
 	})
 }

M internal/app/run.go +16 -15

 	"github.com/bnema/vev/internal/platform"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/bnema/vev/internal/usecase/recovery"
 		cwd = ""
 	}
 	hello := detachedLocalHello(name, cwd)
-	if err := transport.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)}); err != nil {
 		return fmt.Errorf("vev: creating detached session: %w", err)
 	}
 	type detachedReply struct {
-		frame ports.Frame
+		frame wire.Frame
 		err   error
 	}
 	replyCh := make(chan detachedReply, 1)
 			return fmt.Errorf("vev: awaiting detached session creation: %w", reply.err)
 		}
 		switch reply.frame.Type {
-		case ports.MsgWelcome:
+		case wire.MsgWelcome:
 			return nil
-		case ports.MsgError:
+		case wire.MsgError:
-			em, derr := ports.UnmarshalErrorMsg(reply.frame.Payload)
+			em, derr := wire.UnmarshalErrorMsg(reply.frame.Payload)
 			if derr != nil {
 				return fmt.Errorf("vev: decoding error reply: %w", derr)
 			}
 		return errors.Join(errors.New("vev: no daemon running"), owner.Release())
 	}
 	defer func() { _ = transport.Close() }()
-	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgKill, Payload: wire.MarshalKill(protocol.Kill{All: true})}); err != nil {
 		return fmt.Errorf("vev: requesting daemon stop: %w", err)
 	}
 	if _, err := transport.Recv(); err != nil && !errors.Is(err, io.EOF) {
 	}
 	defer func() { _ = transport.Close() }()
-	if err := transport.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgList, Payload: wire.MarshalList(protocol.List{})}); err != nil {
 		return nil, fmt.Errorf("vev: requesting session list: %w", err)
 	}
 	reply, err := transport.Recv()
 	return decodeSessionListReply(reply)
 }
-func decodeSessionListReply(reply ports.Frame) ([]protocol.SessionInfo, error) {
+func decodeSessionListReply(reply wire.Frame) ([]protocol.SessionInfo, error) {
-	if reply.Type == ports.MsgError {
+	if reply.Type == wire.MsgError {
-		em, err := ports.UnmarshalErrorMsg(reply.Payload)
+		em, err := wire.UnmarshalErrorMsg(reply.Payload)
 		if err != nil {
 			return nil, fmt.Errorf("vev: decoding error reply: %w", err)
 		}
 		return nil, fmt.Errorf("vev: %s", em.Text)
 	}
-	if reply.Type != ports.MsgSessions {
+	if reply.Type != wire.MsgSessions {
 		return nil, fmt.Errorf("vev: unexpected reply type %d to list", reply.Type)
 	}
-	sessions, err := ports.UnmarshalSessions(reply.Payload)
+	sessions, err := wire.UnmarshalSessions(reply.Payload)
 	if err != nil {
 		return nil, fmt.Errorf("vev: decoding session list: %w", err)
 	}
 	}
 	defer func() { _ = transport.Close() }()
-	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{Name: name, All: all || daemon})}); err != nil {
+	if err := transport.Send(wire.Frame{Type: wire.MsgKill, Payload: wire.MarshalKill(protocol.Kill{Name: name, All: all || daemon})}); err != nil {
 		return fmt.Errorf("vev: requesting kill: %w", err)
 	}
 	reply, err := transport.Recv()
 		}
 		return fmt.Errorf("vev: reading kill reply: %w", err)
 	}
-	if reply.Type == ports.MsgError {
+	if reply.Type == wire.MsgError {
-		em, _ := ports.UnmarshalErrorMsg(reply.Payload)
+		em, _ := wire.UnmarshalErrorMsg(reply.Payload)
 		return fmt.Errorf("vev: %s", em.Text)
 	}
 	printKillSuccess(name, all, daemon)

M internal/ports/mocks/transport_mock.go +43 -42

 	"context"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	mock "github.com/stretchr/testify/mock"
 )
 }
 // Recv provides a mock function for the type MockTransport
-func (_mock *MockTransport) Recv() (ports.Frame, error) {
+func (_mock *MockTransport) Recv() (wire.Frame, error) {
 	ret := _mock.Called()
 	if len(ret) == 0 {
 		panic("no return value specified for Recv")
 	}
-	var r0 ports.Frame
+	var r0 wire.Frame
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func() (wire.Frame, error)); ok {
 		return returnFunc()
 	}
-	if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
+	if returnFunc, ok := ret.Get(0).(func() wire.Frame); ok {
 		r0 = returnFunc()
 	} else {
-		r0 = ret.Get(0).(ports.Frame)
+		r0 = ret.Get(0).(wire.Frame)
 	}
 	if returnFunc, ok := ret.Get(1).(func() error); ok {
 		r1 = returnFunc()
 	return _c
 }
-func (_c *MockTransport_Recv_Call) Return(frame ports.Frame, err error) *MockTransport_Recv_Call {
+func (_c *MockTransport_Recv_Call) Return(frame wire.Frame, err error) *MockTransport_Recv_Call {
 	_c.Call.Return(frame, err)
 	return _c
 }
-func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockTransport_Recv_Call {
+func (_c *MockTransport_Recv_Call) RunAndReturn(run func() (wire.Frame, error)) *MockTransport_Recv_Call {
 	_c.Call.Return(run)
 	return _c
 }
 // Send provides a mock function for the type MockTransport
-func (_mock *MockTransport) Send(frame ports.Frame) error {
+func (_mock *MockTransport) Send(frame wire.Frame) error {
 	ret := _mock.Called(frame)
 	if len(ret) == 0 {
 	}
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(wire.Frame) error); ok {
 		r0 = returnFunc(frame)
 	} else {
 		r0 = ret.Error(0)
 }
 // Send is a helper method to define mock.On call
-//   - frame ports.Frame
+//   - frame wire.Frame
 func (_e *MockTransport_Expecter) Send(frame any) *MockTransport_Send_Call {
 	return &MockTransport_Send_Call{Call: _e.mock.On("Send", frame)}
 }
-func (_c *MockTransport_Send_Call) Run(run func(frame ports.Frame)) *MockTransport_Send_Call {
+func (_c *MockTransport_Send_Call) Run(run func(frame wire.Frame)) *MockTransport_Send_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 ports.Frame
+		var arg0 wire.Frame
 		if args[0] != nil {
-			arg0 = args[0].(ports.Frame)
+			arg0 = args[0].(wire.Frame)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockTransport_Send_Call {
+func (_c *MockTransport_Send_Call) RunAndReturn(run func(frame wire.Frame) error) *MockTransport_Send_Call {
 	_c.Call.Return(run)
 	return _c
 }
 }
 // Recv provides a mock function for the type MockDatagramTransport
-func (_mock *MockDatagramTransport) Recv() (ports.Frame, error) {
+func (_mock *MockDatagramTransport) Recv() (wire.Frame, error) {
 	ret := _mock.Called()
 	if len(ret) == 0 {
 		panic("no return value specified for Recv")
 	}
-	var r0 ports.Frame
+	var r0 wire.Frame
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func() (ports.Frame, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func() (wire.Frame, error)); ok {
 		return returnFunc()
 	}
-	if returnFunc, ok := ret.Get(0).(func() ports.Frame); ok {
+	if returnFunc, ok := ret.Get(0).(func() wire.Frame); ok {
 		r0 = returnFunc()
 	} else {
-		r0 = ret.Get(0).(ports.Frame)
+		r0 = ret.Get(0).(wire.Frame)
 	}
 	if returnFunc, ok := ret.Get(1).(func() error); ok {
 		r1 = returnFunc()
 	return _c
 }
-func (_c *MockDatagramTransport_Recv_Call) Return(frame ports.Frame, err error) *MockDatagramTransport_Recv_Call {
+func (_c *MockDatagramTransport_Recv_Call) Return(frame wire.Frame, err error) *MockDatagramTransport_Recv_Call {
 	_c.Call.Return(frame, err)
 	return _c
 }
-func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (ports.Frame, error)) *MockDatagramTransport_Recv_Call {
+func (_c *MockDatagramTransport_Recv_Call) RunAndReturn(run func() (wire.Frame, error)) *MockDatagramTransport_Recv_Call {
 	_c.Call.Return(run)
 	return _c
 }
 // Send provides a mock function for the type MockDatagramTransport
-func (_mock *MockDatagramTransport) Send(frame ports.Frame) error {
+func (_mock *MockDatagramTransport) Send(frame wire.Frame) error {
 	ret := _mock.Called(frame)
 	if len(ret) == 0 {
 	}
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(wire.Frame) error); ok {
 		r0 = returnFunc(frame)
 	} else {
 		r0 = ret.Error(0)
 }
 // Send is a helper method to define mock.On call
-//   - frame ports.Frame
+//   - frame wire.Frame
 func (_e *MockDatagramTransport_Expecter) Send(frame any) *MockDatagramTransport_Send_Call {
 	return &MockDatagramTransport_Send_Call{Call: _e.mock.On("Send", frame)}
 }
-func (_c *MockDatagramTransport_Send_Call) Run(run func(frame ports.Frame)) *MockDatagramTransport_Send_Call {
+func (_c *MockDatagramTransport_Send_Call) Run(run func(frame wire.Frame)) *MockDatagramTransport_Send_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 ports.Frame
+		var arg0 wire.Frame
 		if args[0] != nil {
-			arg0 = args[0].(ports.Frame)
+			arg0 = args[0].(wire.Frame)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame ports.Frame) error) *MockDatagramTransport_Send_Call {
+func (_c *MockDatagramTransport_Send_Call) RunAndReturn(run func(frame wire.Frame) error) *MockDatagramTransport_Send_Call {
 	_c.Call.Return(run)
 	return _c
 }
 }
 // SendAsync provides a mock function for the type MockAsyncTransport
-func (_mock *MockAsyncTransport) SendAsync(frame ports.Frame) error {
+func (_mock *MockAsyncTransport) SendAsync(frame wire.Frame) error {
 	ret := _mock.Called(frame)
 	if len(ret) == 0 {
 	}
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(wire.Frame) error); ok {
 		r0 = returnFunc(frame)
 	} else {
 		r0 = ret.Error(0)
 }
 // SendAsync is a helper method to define mock.On call
-//   - frame ports.Frame
+//   - frame wire.Frame
 func (_e *MockAsyncTransport_Expecter) SendAsync(frame any) *MockAsyncTransport_SendAsync_Call {
 	return &MockAsyncTransport_SendAsync_Call{Call: _e.mock.On("SendAsync", frame)}
 }
-func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame ports.Frame)) *MockAsyncTransport_SendAsync_Call {
+func (_c *MockAsyncTransport_SendAsync_Call) Run(run func(frame wire.Frame)) *MockAsyncTransport_SendAsync_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 ports.Frame
+		var arg0 wire.Frame
 		if args[0] != nil {
-			arg0 = args[0].(ports.Frame)
+			arg0 = args[0].(wire.Frame)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame ports.Frame) error) *MockAsyncTransport_SendAsync_Call {
+func (_c *MockAsyncTransport_SendAsync_Call) RunAndReturn(run func(frame wire.Frame) error) *MockAsyncTransport_SendAsync_Call {
 	_c.Call.Return(run)
 	return _c
 }
 }
 // SendSynchronous provides a mock function for the type MockOwnedSynchronousTransport
-func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame ports.Frame) error {
+func (_mock *MockOwnedSynchronousTransport) SendSynchronous(frame wire.Frame) error {
 	ret := _mock.Called(frame)
 	if len(ret) == 0 {
 	}
 	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(ports.Frame) error); ok {
+	if returnFunc, ok := ret.Get(0).(func(wire.Frame) error); ok {
 		r0 = returnFunc(frame)
 	} else {
 		r0 = ret.Error(0)
 }
 // SendSynchronous is a helper method to define mock.On call
-//   - frame ports.Frame
+//   - frame wire.Frame
 func (_e *MockOwnedSynchronousTransport_Expecter) SendSynchronous(frame any) *MockOwnedSynchronousTransport_SendSynchronous_Call {
 	return &MockOwnedSynchronousTransport_SendSynchronous_Call{Call: _e.mock.On("SendSynchronous", frame)}
 }
-func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame ports.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) Run(run func(frame wire.Frame)) *MockOwnedSynchronousTransport_SendSynchronous_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 ports.Frame
+		var arg0 wire.Frame
 		if args[0] != nil {
-			arg0 = args[0].(ports.Frame)
+			arg0 = args[0].(wire.Frame)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame ports.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
+func (_c *MockOwnedSynchronousTransport_SendSynchronous_Call) RunAndReturn(run func(frame wire.Frame) error) *MockOwnedSynchronousTransport_SendSynchronous_Call {
 	_c.Call.Return(run)
 	return _c
 }

M internal/ports/transport.go +9 -5

 package ports
-import "context"
+import (
+	"context"
+	"github.com/bnema/vev/internal/protocol/wire"
+)
 // Transport is a framed message channel over a single connection. Close must
 // be safe to call concurrently with Send and Recv, and must unblock active
 // Send and Recv calls.
 type Transport interface {
-	Send(Frame) error
+	Send(wire.Frame) error
-	Recv() (Frame, error) // blocking; io.EOF on close
+	Recv() (wire.Frame, error) // blocking; io.EOF on close
 	Close() error
 }
 // returns once the adapter owns the frame; Send retains its synchronous wire-
 // attempt contract. Daemon paint output may use this capability to pipeline.
 type AsyncTransport interface {
-	SendAsync(Frame) error
+	SendAsync(wire.Frame) error
 }
 // OwnedSynchronousTransport owns the complete bounded synchronous operation,
 // including adapter queues, pacing, write deadlines, and close cancellation.
 type OwnedSynchronousTransport interface {
-	SendSynchronous(Frame) error
+	SendSynchronous(wire.Frame) error
 }
 // Dialer establishes outbound Transport connections.

R internal/ports/frame.go → internal/protocol/wire/frame.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		// MaxFrameLen is the largest permitted frame length, including the type byte	3		// MaxFrameLen is the largest permitted frame length, including the type byte
4		// and excluding the four-byte length prefix.	4		// and excluding the four-byte length prefix.

R internal/ports/frame_test.go → internal/protocol/wire/frame_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"testing"	4		"testing"

R internal/ports/navigation_test.go → internal/protocol/wire/navigation_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"encoding/hex"	4		"encoding/hex"

R internal/ports/output_compression_test.go → internal/protocol/wire/output_compression_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

R internal/ports/remote_preview_hardening_test.go → internal/protocol/wire/remote_preview_hardening_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

R internal/ports/remote_preview_test.go → internal/protocol/wire/remote_preview_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"testing"	4		"testing"

R internal/ports/remote_target_wire_test.go → internal/protocol/wire/remote_target_wire_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

R internal/ports/routes_test.go → internal/protocol/wire/routes_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"encoding/hex"	4		"encoding/hex"

R internal/ports/routes_wire.go → internal/protocol/wire/routes_wire.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"fmt"	4		"fmt"

R internal/ports/same_peer_switch_test.go → internal/protocol/wire/same_peer_switch_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

R internal/ports/wire.go → internal/protocol/wire/wire.go +3 -6 renamed, 99% similar

-// Wire codecs for vev's IPC message payloads. They live in ports (alongside
+// Package wire owns vev's binary frame representation and strict payload
-// Frame and the MsgType constants) because wire encoding is protocol
+// codecs. It performs no I/O; carriage adapters transport Frame values.
-// surface, not I/O: everything here is pure, stdlib-only byte marshalling.
-// Adapters keep what actually performs I/O (framing over a connection,
-// listening on a socket) and import these types for the payloads they carry.
-package ports
+package wire
 import (
 	"bytes"

R internal/ports/wire_command.go → internal/protocol/wire/wire_command.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"encoding/binary"	4		"encoding/binary"

R internal/ports/wire_final_test.go → internal/protocol/wire/wire_final_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

R internal/ports/wire_test.go → internal/protocol/wire/wire_test.go +1 -1 renamed, 99% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package wire
2			2
3		import (	3		import (
4		"bytes"	4		"bytes"

M internal/testutil/replaytest/replay.go +12 -12

 	"testing"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalOutput(m protocol.Output) []byte {
-	payload, err := ports.MarshalOutput(m)
+	payload, err := wire.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 	}
 	return payload
 }
-var transcript = []ports.Frame{
+var transcript = []wire.Frame{
-	{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("\x1b[2J\x1b[Hone\r\ntwo")})},
+	{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("\x1b[2J\x1b[Hone\r\ntwo")})},
-	{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Base: 1, New: 2, Echo: 7, Size: domain.Size{Cols: 80, Rows: 24}, Data: []byte("\x1b[2;1HTWO")})},
+	{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{Epoch: 1, Base: 1, New: 2, Echo: 7, Size: domain.Size{Cols: 80, Rows: 24}, Data: []byte("\x1b[2;1HTWO")})},
 }
 // Transcript returns a deep copy of the canonical replay transcript so an
 // adapter cannot mutate the fixture observed by another adapter.
-func Transcript() []ports.Frame {
+func Transcript() []wire.Frame {
 	return cloneFrames(transcript)
 }
 // Exchange carries already-composed frames through one transport adapter.
-type Exchange func(t *testing.T, frames []ports.Frame) []ports.Frame
+type Exchange func(t *testing.T, frames []wire.Frame) []wire.Frame
 // Run verifies that an adapter preserves the canonical transcript exactly.
 func Run(t *testing.T, exchange Exchange) {
 			t.Errorf("frame %d payload = %x, want byte-for-byte %x", i, got[i].Payload, want[i].Payload)
 			continue
 		}
-		gotOutput, err := ports.UnmarshalOutput(got[i].Payload)
+		gotOutput, err := wire.UnmarshalOutput(got[i].Payload)
 		if err != nil {
 			t.Errorf("frame %d output decode: %v", i, err)
 			continue
 		}
-		wantOutput, err := ports.UnmarshalOutput(want[i].Payload)
+		wantOutput, err := wire.UnmarshalOutput(want[i].Payload)
 		if err != nil {
 			t.Fatalf("canonical frame %d output decode: %v", i, err)
 		}
 	}
 }
-func cloneFrames(frames []ports.Frame) []ports.Frame {
+func cloneFrames(frames []wire.Frame) []wire.Frame {
-	cloned := make([]ports.Frame, len(frames))
+	cloned := make([]wire.Frame, len(frames))
 	for i, frame := range frames {
-		cloned[i] = ports.Frame{Type: frame.Type, Payload: append([]byte(nil), frame.Payload...)}
+		cloned[i] = wire.Frame{Type: frame.Type, Payload: append([]byte(nil), frame.Payload...)}
 	}
 	return cloned
 }

M internal/usecase/client/ack_queue_test.go +26 -26


@@ -7,20 +7,20 @@ import (
7		"testing"	7		"testing"
8		"time"	8		"time"
9			9
10	-	"github.com/bnema/vev/internal/ports"	10	+	"github.com/bnema/vev/internal/protocol/wire"
11		"github.com/stretchr/testify/require"	11		"github.com/stretchr/testify/require"
12		)	12		)
13			13
14	-	type ackRecordingTransport struct{ sent chan ports.Frame }	14	+	type ackRecordingTransport struct{ sent chan wire.Frame }
15			15
16	-	func (t *ackRecordingTransport) Send(f ports.Frame) error { t.sent <- f; return nil }	16	+	func (t *ackRecordingTransport) Send(f wire.Frame) error { t.sent <- f; return nil }
17	-	func (t *ackRecordingTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }	17	+	func (t *ackRecordingTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
18	-	func (t *ackRecordingTransport) Close() error { return nil }	18	+	func (t *ackRecordingTransport) Close() error { return nil }
19			19
20		func TestCumulativeAckBypassesFullNormalSendQueue(t *testing.T) {	20		func TestCumulativeAckBypassesFullNormalSendQueue(t *testing.T) {
21	-	normal := make(chan ports.Frame, sendQueueDepth)	21	+	normal := make(chan wire.Frame, sendQueueDepth)
22		for range cap(normal) {	22		for range cap(normal) {
23	-	normal <- ports.Frame{Type: ports.MsgInput}	23	+	normal <- wire.Frame{Type: wire.MsgInput}
24		}	24		}
25		const epoch = 7	25		const epoch = 7
26		acks := newCumulativeAckQueue()	26		acks := newCumulativeAckQueue()

@@ -30,13 +30,13 @@ func TestCumulativeAckBypassesFullNormalSendQueue(t *testing.T) {
30			30
31		ctx, cancel := context.WithCancel(context.Background())	31		ctx, cancel := context.WithCancel(context.Background())
32		defer cancel()	32		defer cancel()
33	-	tr := &ackRecordingTransport{sent: make(chan ports.Frame, sendQueueDepth+1)}	33	+	tr := &ackRecordingTransport{sent: make(chan wire.Frame, sendQueueDepth+1)}
34		errCh := make(chan error, 1)	34		errCh := make(chan error, 1)
35		go runSender(ctx, cancel, tr, nil, nil, normal, nil, acks, errCh, slog.Default())	35		go runSender(ctx, cancel, tr, nil, nil, normal, nil, acks, errCh, slog.Default())
36			36
37		first := <-tr.sent	37		first := <-tr.sent
38	-	require.Equal(t, ports.MsgAck, first.Type)	38	+	require.Equal(t, wire.MsgAck, first.Type)
39	-	ack, err := ports.UnmarshalAck(first.Payload)	39	+	ack, err := wire.UnmarshalAck(first.Payload)
40		require.NoError(t, err)	40		require.NoError(t, err)
41		require.Equal(t, uint64(epoch), ack.Epoch)	41		require.Equal(t, uint64(epoch), ack.Epoch)
42		require.Equal(t, uint64(maxUnackedOutputStatesForTest), ack.State)	42		require.Equal(t, uint64(maxUnackedOutputStatesForTest), ack.State)

@@ -45,21 +45,21 @@ func TestCumulativeAckBypassesFullNormalSendQueue(t *testing.T) {
45		func TestSamePeerSwitchControlBypassesHeldInput(t *testing.T) {	45		func TestSamePeerSwitchControlBypassesHeldInput(t *testing.T) {
46		ctx, cancel := context.WithCancel(context.Background())	46		ctx, cancel := context.WithCancel(context.Background())
47		defer cancel()	47		defer cancel()
48	-	normal := make(chan ports.Frame, 1)	48	+	normal := make(chan wire.Frame, 1)
49	-	control := make(chan ports.Frame, 1)	49	+	control := make(chan wire.Frame, 1)
50		gate := newSamePeerInputGate()	50		gate := newSamePeerInputGate()
51		gate.setPaused(true)	51		gate.setPaused(true)
52		held := make(chan struct{})	52		held := make(chan struct{})
53		gate.afterInputHeld = func() { close(held) }	53		gate.afterInputHeld = func() { close(held) }
54	-	transport := &ackRecordingTransport{sent: make(chan ports.Frame, 2)}	54	+	transport := &ackRecordingTransport{sent: make(chan wire.Frame, 2)}
55		acks := newCumulativeAckQueue()	55		acks := newCumulativeAckQueue()
56		errs := make(chan error, 1)	56		errs := make(chan error, 1)
57		go runSender(ctx, cancel, transport, control, nil, normal, gate, acks, errs, slog.Default())	57		go runSender(ctx, cancel, transport, control, nil, normal, gate, acks, errs, slog.Default())
58			58
59	-	normal <- ports.Frame{Type: ports.MsgInput, Payload: []byte("held")}	59	+	normal <- wire.Frame{Type: wire.MsgInput, Payload: []byte("held")}
60		awaitSenderSignal(t, held)	60		awaitSenderSignal(t, held)
61	-	control <- ports.Frame{Type: ports.MsgSamePeerSwitchRequest, Payload: []byte("switch")}	61	+	control <- wire.Frame{Type: wire.MsgSamePeerSwitchRequest, Payload: []byte("switch")}
62	-	if got := awaitSenderFrame(t, transport.sent); got.Type != ports.MsgSamePeerSwitchRequest {	62	+	if got := awaitSenderFrame(t, transport.sent); got.Type != wire.MsgSamePeerSwitchRequest {
63		t.Fatalf("first frame = %d, want same-peer switch request", got.Type)	63		t.Fatalf("first frame = %d, want same-peer switch request", got.Type)
64		}	64		}
65		select {	65		select {

@@ -68,7 +68,7 @@ func TestSamePeerSwitchControlBypassesHeldInput(t *testing.T) {
68		default:	68		default:
69		}	69		}
70		gate.setPaused(false)	70		gate.setPaused(false)
71	-	if got := awaitSenderFrame(t, transport.sent); got.Type != ports.MsgInput {	71	+	if got := awaitSenderFrame(t, transport.sent); got.Type != wire.MsgInput {
72		t.Fatalf("released frame = %d, want input", got.Type)	72		t.Fatalf("released frame = %d, want input", got.Type)
73		}	73		}
74		}	74		}

@@ -76,14 +76,14 @@ func TestSamePeerSwitchControlBypassesHeldInput(t *testing.T) {
76		func TestSenderBarrierLeavesPausedInputQueued(t *testing.T) {	76		func TestSenderBarrierLeavesPausedInputQueued(t *testing.T) {
77		ctx, cancel := context.WithCancel(context.Background())	77		ctx, cancel := context.WithCancel(context.Background())
78		defer cancel()	78		defer cancel()
79	-	normal := make(chan ports.Frame, 1)	79	+	normal := make(chan wire.Frame, 1)
80		barriers := make(chan chan struct{})	80		barriers := make(chan chan struct{})
81		gate := newSamePeerInputGate()	81		gate := newSamePeerInputGate()
82		gate.setPaused(true)	82		gate.setPaused(true)
83	-	transport := &ackRecordingTransport{sent: make(chan ports.Frame, 1)}	83	+	transport := &ackRecordingTransport{sent: make(chan wire.Frame, 1)}
84		go runSender(ctx, cancel, transport, nil, barriers, normal, gate, newCumulativeAckQueue(), make(chan error, 1), slog.Default())	84		go runSender(ctx, cancel, transport, nil, barriers, normal, gate, newCumulativeAckQueue(), make(chan error, 1), slog.Default())
85			85
86	-	normal <- ports.Frame{Type: ports.MsgInput, Payload: []byte("held")}	86	+	normal <- wire.Frame{Type: wire.MsgInput, Payload: []byte("held")}
87		barrierDone := make(chan struct{})	87		barrierDone := make(chan struct{})
88		barriers <- barrierDone	88		barriers <- barrierDone
89		awaitSenderSignal(t, barrierDone)	89		awaitSenderSignal(t, barrierDone)

@@ -94,7 +94,7 @@ func TestSenderBarrierLeavesPausedInputQueued(t *testing.T) {
94		}	94		}
95			95
96		gate.setPaused(false)	96		gate.setPaused(false)
97	-	if got := awaitSenderFrame(t, transport.sent); got.Type != ports.MsgInput {	97	+	if got := awaitSenderFrame(t, transport.sent); got.Type != wire.MsgInput {
98		t.Fatalf("released frame = %d, want input", got.Type)	98		t.Fatalf("released frame = %d, want input", got.Type)
99		}	99		}
100		}	100		}

@@ -104,14 +104,14 @@ func TestSenderBarrierFlushesPendingAck(t *testing.T) {
104		defer cancel()	104		defer cancel()
105		acks := newCumulativeAckQueue()	105		acks := newCumulativeAckQueue()
106		acks.offer(3, 9)	106		acks.offer(3, 9)
107	-	transport := &ackRecordingTransport{sent: make(chan ports.Frame, 1)}	107	+	transport := &ackRecordingTransport{sent: make(chan wire.Frame, 1)}
108		barriers := make(chan chan struct{})	108		barriers := make(chan chan struct{})
109	-	go runSender(ctx, cancel, transport, nil, barriers, make(chan ports.Frame, 1), newSamePeerInputGate(), acks, make(chan error, 1), slog.Default())	109	+	go runSender(ctx, cancel, transport, nil, barriers, make(chan wire.Frame, 1), newSamePeerInputGate(), acks, make(chan error, 1), slog.Default())
110			110
111		done := make(chan struct{})	111		done := make(chan struct{})
112		barriers <- done	112		barriers <- done
113		frame := awaitSenderFrame(t, transport.sent)	113		frame := awaitSenderFrame(t, transport.sent)
114	-	require.Equal(t, ports.MsgAck, frame.Type)	114	+	require.Equal(t, wire.MsgAck, frame.Type)
115		awaitSenderSignal(t, done)	115		awaitSenderSignal(t, done)
116		}	116		}
117			117

@@ -124,14 +124,14 @@ func awaitSenderSignal(t *testing.T, signal <-chan struct{}) {
124		}	124		}
125		}	125		}
126			126
127	-	func awaitSenderFrame(t *testing.T, frames <-chan ports.Frame) ports.Frame {	127	+	func awaitSenderFrame(t *testing.T, frames <-chan wire.Frame) wire.Frame {
128		t.Helper()	128		t.Helper()
129		select {	129		select {
130		case frame := <-frames:	130		case frame := <-frames:
131		return frame	131		return frame
132		case <-time.After(time.Second):	132		case <-time.After(time.Second):
133		t.Fatal("sender did not emit frame")	133		t.Fatal("sender did not emit frame")
134	-	return ports.Frame{}	134	+	return wire.Frame{}
135		}	135		}
136		}	136		}
137			137

M internal/usecase/client/client.go +74 -73

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/theme"
 )
 		Remote:                 remote,
 	}
 	if err := sendHandshake(func() error {
-		return transport.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)})
+		return transport.Send(wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)})
 	}); err != nil {
 		return handshakeFailure("sending hello", err)
 	}
 	ms.helloSent = true
 	// 2. Await Welcome or a typed rejection.
-	var reply ports.Frame
+	var reply wire.Frame
 	if err := boundedHandshakeOperationWithTransition(handshakeCtx, transport, func() error {
 		var recvErr error
 		reply, recvErr = transport.Recv()
 		}
 	}
 	switch reply.Type {
-	case ports.MsgWelcome:
+	case wire.MsgWelcome:
-		welcome, derr := ports.UnmarshalWelcome(reply.Payload)
+		welcome, derr := wire.UnmarshalWelcome(reply.Payload)
 		if derr != nil {
 			return result(false, fmt.Errorf("vev: decoding welcome: %w", derr))
 		}
 				remember()
 			}
 		}
-	case ports.MsgError:
+	case wire.MsgError:
-		em, derr := ports.UnmarshalErrorMsg(reply.Payload)
+		em, derr := wire.UnmarshalErrorMsg(reply.Payload)
 		if derr != nil {
 			return result(false, fmt.Errorf("vev: decoding error reply: %w", derr))
 		}
 				return welcomedResult(fmt.Errorf("vev: committing route identity: %w", commitErr))
 			}
 		}
-		snapshotPayload, err := ports.MarshalRecentRouteSnapshot(a.runner.ledger.snapshot())
+		snapshotPayload, err := wire.MarshalRecentRouteSnapshot(a.runner.ledger.snapshot())
 		if err != nil {
 			return welcomedResult(fmt.Errorf("vev: encoding route snapshot: %w", err))
 		}
-		attentionPayload, err := ports.MarshalRouteAttentionSubscription(a.runner.ledger.attentionSubscription())
+		attentionPayload, err := wire.MarshalRouteAttentionSubscription(a.runner.ledger.attentionSubscription())
 		if err != nil {
 			return welcomedResult(fmt.Errorf("vev: encoding route attention subscription: %w", err))
 		}
 		if err := sendHandshake(func() error {
-			if err := transport.Send(ports.Frame{Type: ports.MsgRecentRouteSnapshot, Payload: snapshotPayload}); err != nil {
+			if err := transport.Send(wire.Frame{Type: wire.MsgRecentRouteSnapshot, Payload: snapshotPayload}); err != nil {
 				return err
 			}
-			return transport.Send(ports.Frame{Type: ports.MsgRouteAttentionSubscription, Payload: attentionPayload})
+			return transport.Send(wire.Frame{Type: wire.MsgRouteAttentionSubscription, Payload: attentionPayload})
 		}); err != nil {
 			return welcomedResult(fmt.Errorf("vev: publishing route snapshot: %w", err))
 		}
 	}
 	if a.runner.routeFailure != nil {
-		payload, err := ports.MarshalRouteNavigationFailure(*a.runner.routeFailure)
+		payload, err := wire.MarshalRouteNavigationFailure(*a.runner.routeFailure)
 		if err != nil {
 			return welcomedResult(fmt.Errorf("vev: encoding route navigation failure: %w", err))
 		}
 		if err := sendHandshake(func() error {
-			return transport.Send(ports.Frame{Type: ports.MsgRouteNavigationFailure, Payload: payload})
+			return transport.Send(wire.Frame{Type: wire.MsgRouteNavigationFailure, Payload: payload})
 		}); err != nil {
 			return welcomedResult(fmt.Errorf("vev: publishing route navigation failure: %w", err))
 		}
 		input.start()
 		defer input.stop()
 	}
-	sendCh := make(chan ports.Frame, sendQueueDepth)
+	sendCh := make(chan wire.Frame, sendQueueDepth)
-	controlCh := make(chan ports.Frame, 1)
+	controlCh := make(chan wire.Frame, 1)
 	barrierCh := make(chan chan struct{})
 	inputGate := newSamePeerInputGate()
 	ackQueue := newCumulativeAckQueue()
 		}
 	}
 	publish := func(snapshot protocol.Theme) error {
-		frame := ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(snapshot)}
+		frame := wire.Frame{Type: wire.MsgTheme, Payload: wire.MarshalTheme(snapshot)}
 		// The initial cleared snapshot is sent before the sender exists. This
 		// keeps the generation publication ordered before the first query and
 		// avoids leaving a queued Theme behind an immediate detach.
 			// Before the asynchronous sender starts, preserve transport ordering by
 			// requesting the reset synchronously after the initial Theme publication.
 			resetErr := sendHandshake(func() error {
-				payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+				payload, err := wire.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 				if err != nil {
 					return err
 				}
-				return transport.Send(ports.Frame{Type: ports.MsgResize, Payload: payload})
+				return transport.Send(wire.Frame{Type: wire.MsgResize, Payload: payload})
 			})
 			if resetErr != nil {
 				resetErr = handshakeContextError(ctx, handshakeTimedOut, resetErr)
 			return fmt.Errorf("reading terminal geometry for parked route: %w", err)
 		}
 		geometry = geometry.NormalizePixels()
-		payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+		payload, err := wire.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 		if err != nil {
 			return fmt.Errorf("encoding terminal size for parked route: %w", err)
 		}
 		select {
-		case controlCh <- ports.Frame{Type: ports.MsgResize, Payload: payload}:
+		case controlCh <- wire.Frame{Type: wire.MsgResize, Payload: payload}:
 			return nil
 		case <-loopCtx.Done():
 			return context.Canceled
 		}
 		nextParkedRequestID++
 		request := protocol.ParkedRouteRequest{RequestID: nextParkedRequestID, LeaseID: leaseID, Action: action, Target: target}
-		payload := ports.MarshalParkedRouteRequest(request)
+		payload := wire.MarshalParkedRouteRequest(request)
 		if payload == nil {
 			return errors.New("vev: invalid parked-route request")
 		}
 		select {
-		case controlCh <- ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: payload}:
+		case controlCh <- wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: payload}:
 			parkedPending = &parkedRoutePending{
 				requestID: request.RequestID, action: action, leaseID: leaseID,
 				timer: clk.NewTimer(protocol.HandshakeTimeout),
 			return fmt.Errorf("reading terminal geometry for reconnect reconciliation: %w", serr)
 		}
 		geometry = geometry.NormalizePixels()
-		payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+		payload, err := wire.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 		if err != nil {
 			return fmt.Errorf("encoding terminal size for reconnect reconciliation: %w", err)
 		}
 		select {
-		case sendCh <- ports.Frame{Type: ports.MsgResize, Payload: payload}:
+		case sendCh <- wire.Frame{Type: wire.MsgResize, Payload: payload}:
 			awaitingReconnectReset = true
 			return nil
 		case <-loopCtx.Done():
 		if a.runner.ledger == nil {
 			return errors.New("vev: route ledger unavailable")
 		}
-		snapshotPayload, err := ports.MarshalRecentRouteSnapshot(a.runner.ledger.snapshot())
+		snapshotPayload, err := wire.MarshalRecentRouteSnapshot(a.runner.ledger.snapshot())
 		if err != nil {
 			return err
 		}
-		attentionPayload, err := ports.MarshalRouteAttentionSubscription(a.runner.ledger.attentionSubscription())
+		attentionPayload, err := wire.MarshalRouteAttentionSubscription(a.runner.ledger.attentionSubscription())
 		if err != nil {
 			return err
 		}
-		for _, frame := range []ports.Frame{
+		for _, frame := range []wire.Frame{
-			{Type: ports.MsgRecentRouteSnapshot, Payload: snapshotPayload},
+			{Type: wire.MsgRecentRouteSnapshot, Payload: snapshotPayload},
-			{Type: ports.MsgRouteAttentionSubscription, Payload: attentionPayload},
+			{Type: wire.MsgRouteAttentionSubscription, Payload: attentionPayload},
 		} {
 			select {
 			case sendCh <- frame:
 		return nil
 	}
 	sendRouteFailure := func(action protocol.RouteNavigationAction, code protocol.RouteFailureCode) error {
-		payload, err := ports.MarshalRouteNavigationFailure(protocol.RouteNavigationFailure{
+		payload, err := wire.MarshalRouteNavigationFailure(protocol.RouteNavigationFailure{
 			Key:        action.Key,
 			Generation: action.Generation,
 			Code:       code,
 			return err
 		}
 		select {
-		case sendCh <- ports.Frame{Type: ports.MsgRouteNavigationFailure, Payload: payload}:
+		case sendCh <- wire.Frame{Type: wire.MsgRouteNavigationFailure, Payload: payload}:
 			return nil
 		case <-loopCtx.Done():
 			return context.Canceled
 					return welcomedResult(fmt.Errorf("dismissing reconnect toast: %w", err))
 				}
 				select {
-				case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkConnected})}:
+				case sendCh <- wire.Frame{Type: wire.MsgClientNotice, Payload: wire.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkConnected})}:
 				case <-loopCtx.Done():
 					return welcomedResult(nil)
 				}
 			if ev.State == ports.LinkStateDegraded {
 				log.Warn("UDP link degraded")
 				select {
-				case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkDegraded})}:
+				case sendCh <- wire.Frame{Type: wire.MsgClientNotice, Payload: wire.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkDegraded})}:
 				case <-loopCtx.Done():
 					return welcomedResult(nil)
 				}
 				return welcomedResult(fmt.Errorf("vev: receiving from daemon: %w", r.err))
 			}
 			switch r.frame.Type {
-			case ports.MsgOutput:
+			case wire.MsgOutput:
-				o, derr := ports.UnmarshalOutput(r.frame.Payload)
+				o, derr := wire.UnmarshalOutput(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding output: %w", derr))
 				}
 					// repeated gaps while that reset is in flight.
 					if !outputResetRequested {
 						select {
-						case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
+						case sendCh <- wire.Frame{Type: wire.MsgOutputResetRequest, Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
 							outputResetRequested = true
 						case <-loopCtx.Done():
 							return loopCanceledResult()
 					log.Debug("received first output")
 					endHandshake()
 				}
-			case ports.MsgAttachTarget:
+			case wire.MsgAttachTarget:
-				target, derr := ports.UnmarshalAttachTarget(r.frame.Payload)
+				target, derr := wire.UnmarshalAttachTarget(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding attach target: %w", derr))
 				}
 					}
 					nextSamePeerRequestID++
 					request := a.runner.ledger.samePeerHandoff(request, target)
-					payload, err := ports.MarshalSamePeerSwitchRequest(protocol.SamePeerSwitchRequest{
+					payload, err := wire.MarshalSamePeerSwitchRequest(protocol.SamePeerSwitchRequest{
 						RequestID:      nextSamePeerRequestID,
 						Target:         *target.ExactTarget,
 						PreferredTabID: request.PreferredTabID,
 					samePeerSwitch = &samePeerSwitchPending{requestID: nextSamePeerRequestID, target: *target.ExactTarget}
 					inputGate.setPaused(true)
 					select {
-					case controlCh <- ports.Frame{Type: ports.MsgSamePeerSwitchRequest, Payload: payload}:
+					case controlCh <- wire.Frame{Type: wire.MsgSamePeerSwitchRequest, Payload: payload}:
 						continue
 					case <-loopCtx.Done():
 						return loopCanceledResult()
 				handoff := welcomedResult(nil)
 				handoff.target = &target
 				return handoff
-			case ports.MsgParkedRouteResponse:
+			case wire.MsgParkedRouteResponse:
-				response, derr := ports.UnmarshalParkedRouteResponse(r.frame.Payload)
+				response, derr := wire.UnmarshalParkedRouteResponse(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding parked-route response: %w", derr))
 				}
 						return fallback
 					}
 				}
-			case ports.MsgNavigationAction:
+			case wire.MsgNavigationAction:
-				directive, derr := ports.UnmarshalNavigationDirective(r.frame.Payload)
+				directive, derr := wire.UnmarshalNavigationDirective(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding navigation action: %w", derr))
 				}
 				navigation := welcomedResult(nil)
 				navigation.action = directive.Action
 				return navigation
-			case ports.MsgNavigateRecentRoute:
+			case wire.MsgNavigateRecentRoute:
-				action, derr := ports.UnmarshalRouteNavigationAction(r.frame.Payload)
+				action, derr := wire.UnmarshalRouteNavigationAction(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding route navigation action: %w", derr))
 				}
 				navigation := welcomedResult(nil)
 				navigation.routeAction = &action
 				return navigation
-			case ports.MsgCommittedRouteIdentity:
+			case wire.MsgCommittedRouteIdentity:
-				identity, derr := ports.UnmarshalCommittedRouteIdentity(r.frame.Payload)
+				identity, derr := wire.UnmarshalCommittedRouteIdentity(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding committed route identity: %w", derr))
 				}
 					samePeerSwitch = nil
 					inputGate.setPaused(false)
 				}
-			case ports.MsgSamePeerSwitchFailure:
+			case wire.MsgSamePeerSwitchFailure:
-				failure, derr := ports.UnmarshalSamePeerSwitchFailure(r.frame.Payload)
+				failure, derr := wire.UnmarshalSamePeerSwitchFailure(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding same-peer switch failure: %w", derr))
 				}
 						transitionWaitingFull = true
 						if !outputResetRequested {
 							select {
-							case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
+							case sendCh <- wire.Frame{Type: wire.MsgOutputResetRequest, Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
 								outputResetRequested = true
 							case <-loopCtx.Done():
 								return loopCanceledResult()
 						transition.stop()
 					}
 				}
-			case ports.MsgRoutePosition:
+			case wire.MsgRoutePosition:
-				position, derr := ports.UnmarshalRoutePosition(r.frame.Payload)
+				position, derr := wire.UnmarshalRoutePosition(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding route position: %w", derr))
 				}
 					return welcomedResult(fmt.Errorf("vev: remembering route position: %w", derr))
 				}
 				routePosition = cloneRoutePosition(&position)
-			case ports.MsgRouteNavigationFailure:
+			case wire.MsgRouteNavigationFailure:
-				failure, derr := ports.UnmarshalRouteNavigationFailure(r.frame.Payload)
+				failure, derr := wire.UnmarshalRouteNavigationFailure(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding route navigation failure: %w", derr))
 				}
 				log.Warn("route navigation rejected", "key", failure.Key, "generation", failure.Generation, "code", failure.Code)
-			case ports.MsgDetached:
+			case wire.MsgDetached:
-				d, derr := ports.UnmarshalDetached(r.frame.Payload)
+				d, derr := wire.UnmarshalDetached(r.frame.Payload)
 				if derr != nil {
 					return welcomedResult(fmt.Errorf("vev: decoding detached: %w", derr))
 				}
 					log.Warn("detached by daemon", "reason", d.Reason)
 				}
 				return welcomedResult(detachedResult(d.Reason))
-			case ports.MsgPong:
+			case wire.MsgPong:
 				// Liveness reply; nothing to do.
 			default:
 				// Unknown/out-of-band message types are ignored so a newer
 // recvResult carries one framed message (or a read error) from the receive
 // pump to the main loop.
 type recvResult struct {
-	frame ports.Frame
+	frame wire.Frame
 	err   error
 }
 // runSender preserves normal-frame order while allowing switch control and
 // output ACKs to make progress when raw input is held for a same-peer switch.
-func runSender(ctx context.Context, cancel context.CancelFunc, transport ports.Transport, control <-chan ports.Frame, barriers <-chan chan struct{}, in <-chan ports.Frame, inputGate *samePeerInputGate, acks *cumulativeAckQueue, errCh chan<- error, log *slog.Logger) {
+func runSender(ctx context.Context, cancel context.CancelFunc, transport ports.Transport, control <-chan wire.Frame, barriers <-chan chan struct{}, in <-chan wire.Frame, inputGate *samePeerInputGate, acks *cumulativeAckQueue, errCh chan<- error, log *slog.Logger) {
 	defer log.Debug("sender pump exited")
-	send := func(f ports.Frame) bool {
+	send := func(f wire.Frame) bool {
 		if err := transport.Send(f); err != nil {
 			select {
 			case errCh <- err:
 		if state == 0 {
 			return true
 		}
-		payload, err := ports.MarshalAck(protocol.Ack{Epoch: epoch, State: state})
+		payload, err := wire.MarshalAck(protocol.Ack{Epoch: epoch, State: state})
 		if err != nil {
 			select {
 			case errCh <- fmt.Errorf("encoding output ACK: %w", err):
 			cancel()
 			return false
 		}
-		return send(ports.Frame{Type: ports.MsgAck, Payload: payload})
+		return send(wire.Frame{Type: wire.MsgAck, Payload: payload})
 	}
 	flushPending := func() bool {
 		for {
 		close(done)
 		return true
 	}
-	var heldInput *ports.Frame
+	var heldInput *wire.Frame
 	for {
 		if heldInput != nil {
 			paused, changed := inputGate.snapshot()
 				return
 			default:
 			}
-			if frame.Type == ports.MsgInput || frame.Type == ports.MsgImagePush {
+			if frame.Type == wire.MsgInput || frame.Type == wire.MsgImagePush {
 				if paused, _ := inputGate.snapshot(); paused {
 					held := frame
 					heldInput = &held
 	in                  io.Reader // compatibility for isolated scanner tests
 	input               *terminalInputPump
 	consumer            uint64
-	out                 chan<- ports.Frame
+	out                 chan<- wire.Frame
 	clock               ports.Clock
 	clipboard           ports.ClipboardReader
 	logger              *slog.Logger
 	var undeliveredMu sync.Mutex
 	var undelivered []byte
 	sendOK.Store(true)
-	send := func(frame ports.Frame) bool {
+	send := func(frame wire.Frame) bool {
 		if !sendOK.Load() {
 			return false
 		}
 			return
 		}
 		inputSeq++
-		if !send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{InputSeq: inputSeq, Data: append([]byte(nil), data...)})}) {
+		if !send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{InputSeq: inputSeq, Data: append([]byte(nil), data...)})}) {
 			undeliveredMu.Lock()
 			undelivered = append(undelivered, data...)
 			undeliveredMu.Unlock()
 			reader:    p.clipboard,
 			log:       p.logger,
 			sendNotice: func(action uint8) {
-				send(ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: action})})
+				send(wire.Frame{Type: wire.MsgClientNotice, Payload: wire.MarshalClientNotice(protocol.ClientNotice{Action: action})})
 			},
 			sendImage: func(mime string, data []byte) {
 				inputSeq++
-				send(ports.Frame{Type: ports.MsgImagePush, Payload: ports.MarshalImagePush(protocol.ImagePush{InputSeq: inputSeq, Mime: mime, Data: data})})
+				send(wire.Frame{Type: wire.MsgImagePush, Payload: wire.MarshalImagePush(protocol.ImagePush{InputSeq: inputSeq, Mime: mime, Data: data})})
 			},
 			next: coalescer.Scan,
 		}
 				disarmMarkerDeadline()
 				markers.flush(sink)
 				select {
-				case p.out <- ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}:
+				case p.out <- wire.Frame{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})}:
 				case <-p.ctx.Done():
 				}
 				p.cancel()
 // runResize forwards coalesced terminal resize events to the daemon. It
 // tolerates an already-closed resize channel (which the terminal adapter
 // hands back when restore ran before ResizeEvents was first called).
-func runResize(ctx context.Context, events <-chan domain.Geometry, out chan<- ports.Frame, sendLease *foregroundSendLease, log *slog.Logger) {
+func runResize(ctx context.Context, events <-chan domain.Geometry, out chan<- wire.Frame, sendLease *foregroundSendLease, log *slog.Logger) {
 	defer log.Debug("resize pump exited")
 	for {
 		select {
 				return
 			}
 			geometry = geometry.NormalizePixels()
-			payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+			payload, err := wire.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 			if err != nil {
 				log.Error("encoding terminal resize", "error", err)
 				continue
 			}
-			frame := ports.Frame{Type: ports.MsgResize, Payload: payload}
+			frame := wire.Frame{Type: wire.MsgResize, Payload: payload}
 			if !sendLease.send(func() bool {
 				select {
 				case out <- frame:

M internal/usecase/client/client_test.go +198 -197

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 )
 // recvItem is one scripted Recv result.
 type recvItem struct {
-	f    ports.Frame
+	f    wire.Frame
 	err  error
 	wait <-chan struct{}
 }
 		ch <- it
 	}
 	done := make(chan struct{})
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case it := <-ch:
 			if it.wait != nil {
 				select {
 				case <-it.wait:
 				case <-done:
-					return ports.Frame{}, io.EOF
+					return wire.Frame{}, io.EOF
 				}
 			}
 			return it.f, it.err
 		case <-done:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
 	return func() { close(done) }
 }
-func frameOf(t ports.MsgType, payload []byte) ports.Frame {
+func frameOf(t wire.MsgType, payload []byte) wire.Frame {
-	return ports.Frame{Type: t, Payload: payload}
+	return wire.Frame{Type: t, Payload: payload}
 }
 // blockingReader blocks on Read until closed, then returns EOF. Stands in
 	return tm, in
 }
-func isType(typ ports.MsgType) any {
+func isType(typ wire.MsgType) any {
-	return mock.MatchedBy(func(f ports.Frame) bool { return f.Type == typ })
+	return mock.MatchedBy(func(f wire.Frame) bool { return f.Type == typ })
 }
 // transportDialer adapts one already-open test transport to the Runner API.
 				return io.ErrClosedPipe
 			}
 			if tt.phase == "send" {
-				tr.EXPECT().Send(isType(ports.MsgHello)).RunAndReturn(func(ports.Frame) error {
+				tr.EXPECT().Send(isType(wire.MsgHello)).RunAndReturn(func(wire.Frame) error {
 					return block()
 				}).Once()
 			} else {
-				tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+				tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-				tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+				tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
-					return ports.Frame{}, block()
+					return wire.Frame{}, block()
 				}).Once()
 			}
 			dialer := portsmocks.NewMockDialer(t)
 			case <-time.After(time.Second):
 				t.Fatal("handshake operation leaked after Run returned")
 			}
-			tr.AssertNotCalled(t, "Send", isType(ports.MsgTheme))
+			tr.AssertNotCalled(t, "Send", isType(wire.MsgTheme))
 		})
 	}
 }
 	gotHello := make(chan protocol.Hello, 1)
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgHello)).RunAndReturn(func(f wire.Frame) error {
-		hello, err := ports.UnmarshalHello(f.Payload)
+		hello, err := wire.UnmarshalHello(f.Payload)
 		require.NoError(t, err)
 		gotHello <- hello
 		return nil
 	}).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	defer term.in.unblock()
 	lifecycle := domain.SessionLifecycleID{9, 8, 7}
 	tr := &recordingTransport{recvs: []recvItem{
-		{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID:   "s1",
 			SessionName: "main",
 			CommittedIdentity: &protocol.CommittedRouteIdentity{
 				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "main"},
 			},
 		}))},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	err := runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), client.AttachRequest{
 	foundSubscription := false
 	for _, frame := range tr.Sends() {
 		switch frame.Type {
-		case ports.MsgRecentRouteSnapshot:
+		case wire.MsgRecentRouteSnapshot:
 			var err error
-			snapshot, err = ports.UnmarshalRecentRouteSnapshot(frame.Payload)
+			snapshot, err = wire.UnmarshalRecentRouteSnapshot(frame.Payload)
 			require.NoError(t, err)
 			foundSnapshot = true
-		case ports.MsgRouteAttentionSubscription:
+		case wire.MsgRouteAttentionSubscription:
 			var err error
-			subscription, err = ports.UnmarshalRouteAttentionSubscription(frame.Payload)
+			subscription, err = wire.UnmarshalRouteAttentionSubscription(frame.Payload)
 			require.NoError(t, err)
 			foundSubscription = true
 		}
 	firstLifecycle := domain.SessionLifecycleID{1}
 	secondLifecycle := domain.SessionLifecycleID{2}
-	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
+	welcome := func(name string, lifecycle domain.SessionLifecycleID) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
 			CommittedIdentity: &protocol.CommittedRouteIdentity{
 				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 	secondTarget := protocol.ExactSessionTarget{LifecycleID: secondLifecycle, SessionName: "second"}
 	first := &recordingTransport{recvs: []recvItem{
 		{f: welcome("first", firstLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Session: "second", Intent: protocol.IntentAttach, ExactTarget: &secondTarget,
 			EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned, SamePeer: true,
 		}))},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: secondTarget}))},
+		{f: frameOf(wire.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: secondTarget}))},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	dialer := &sequenceDialer{trs: []ports.Transport{first}}
 	}
 	tr := &recordingTransport{recvs: []recvItem{
 		{f: welcomeFrame(0)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	require.NoError(t, runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), request))
 	sourceLifecycle := domain.SessionLifecycleID{1}
 	targetLifecycle := domain.SessionLifecycleID{2}
 	target := protocol.ExactSessionTarget{LifecycleID: targetLifecycle, SessionName: "stopped"}
-	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
+	welcome := func(name string, lifecycle domain.SessionLifecycleID) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
 			CommittedIdentity: &protocol.CommittedRouteIdentity{
 				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 	}
 	first := &recordingTransport{recvs: []recvItem{
 		{f: welcome("source", sourceLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Session: "stopped", Intent: protocol.IntentAttach, ExactTarget: &target,
 			EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	}}
 	second := &recordingTransport{recvs: []recvItem{
 		{f: welcome("stopped", targetLifecycle)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	dialer := &sequenceDialer{trs: []ports.Transport{first, second}}
 	defer term.in.unblock()
 	localLifecycle := domain.SessionLifecycleID{1}
 	remoteLifecycle := domain.SessionLifecycleID{2}
-	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
+	welcome := func(name string, lifecycle domain.SessionLifecycleID) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
 			CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
 		}))
 	}
 	local1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("local", localLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Endpoint: "remote", Session: "work", Intent: protocol.IntentAttach,
 			RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	}}
 	local2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("local", localLifecycle)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2}}
 	remoteDialer := &sequenceDialer{trs: []ports.Transport{remote}}
 	require.Equal(t, protocol.StartupOverlaySessionPicker, helloFromSend(t, local2).StartupOverlay)
 }
-func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
+func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) wire.Frame {
-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+	return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 		SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
 		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
 	}))
 func hybridLocalBootstrap(lifecycle domain.SessionLifecycleID, target domain.RemoteSessionTarget) *recordingTransport {
 	return &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", lifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
 			RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	return deps
 }
-func hybridParkedRequestHandler(requests chan<- protocol.ParkedRouteRequest, requestErrors chan<- error, signals map[protocol.ParkedRouteAction]chan struct{}) func(ports.Frame) {
+func hybridParkedRequestHandler(requests chan<- protocol.ParkedRouteRequest, requestErrors chan<- error, signals map[protocol.ParkedRouteAction]chan struct{}) func(wire.Frame) {
 	once := make(map[protocol.ParkedRouteAction]*sync.Once, len(signals))
 	for action := range signals {
 		once[action] = &sync.Once{}
 	}
-	return func(frame ports.Frame) {
+	return func(frame wire.Frame) {
-		if frame.Type != ports.MsgParkedRouteRequest {
+		if frame.Type != wire.MsgParkedRouteRequest {
 			return
 		}
-		request, err := ports.UnmarshalParkedRouteRequest(frame.Payload)
+		request, err := wire.UnmarshalParkedRouteRequest(frame.Payload)
 		if err != nil {
 			if requestErrors != nil {
 				requestErrors <- err
 	remote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", remoteSourceLifecycle)},
 		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},
+		{f: frameOf(wire.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}))},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}))},
-		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 2, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("target frame")}))},
+		{f: frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 2, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("target frame")}))},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	remote.onSend = hybridParkedRequestHandler(parkedRequests, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
 		protocol.ParkedRoutePrepare: parkSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Endpoint: "remote", Session: "target", Intent: protocol.IntentAttach,
 			RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	}}
 	var resizeOnce sync.Once
-	localPicker.onSend = func(frame ports.Frame) {
+	localPicker.onSend = func(frame wire.Frame) {
-		if frame.Type == ports.MsgHello {
+		if frame.Type == wire.MsgHello {
 			resizeOnce.Do(func() { term.setSize(domain.Size{Cols: 100, Rows: 40}) })
 		}
 	}
 	frames := remote.Sends()
 	switchIndex := -1
 	for i, frame := range frames {
-		if frame.Type != ports.MsgParkedRouteRequest {
+		if frame.Type != wire.MsgParkedRouteRequest {
 			continue
 		}
-		request, requestErr := ports.UnmarshalParkedRouteRequest(frame.Payload)
+		request, requestErr := wire.UnmarshalParkedRouteRequest(frame.Payload)
 		require.NoError(t, requestErr)
 		if request.Action == protocol.ParkedRouteSwitch {
 			switchIndex = i
 		}
 	}
 	require.Positive(t, switchIndex)
-	require.Equal(t, ports.MsgResize, frames[switchIndex-1].Type, "current size must precede the parked switch")
+	require.Equal(t, wire.MsgResize, frames[switchIndex-1].Type, "current size must precede the parked switch")
-	resize, resizeErr := ports.UnmarshalResize(frames[switchIndex-1].Payload)
+	resize, resizeErr := wire.UnmarshalResize(frames[switchIndex-1].Payload)
 	require.NoError(t, resizeErr)
 	require.Equal(t, domain.Size{Cols: 100, Rows: 40}, resize.Size)
 	require.Equal(t, int32(1), remoteDialer.calls.Load(), "same-host picker switch must retain the authenticated remote transport")
 	sourceRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", sourceLifecycle)},
 		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: prepareSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: prepareSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteExpired})), wait: switchSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteExpired})), wait: switchSent},
 	}}
 	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
 		protocol.ParkedRoutePrepare: prepareSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Endpoint: "remote", Session: "target", Intent: protocol.IntentAttach,
 			RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	}}
 	targetRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("target", targetLifecycle)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}
 	remoteDialer := &sequenceDialer{trs: []ports.Transport{
 	remote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("work", remoteLifecycle)},
 		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed})), wait: resumeSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed})), wait: resumeSent},
-		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("source frame")}))},
+		{f: frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("source frame")}))},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	remote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
 		protocol.ParkedRoutePrepare: parkSent,
 	sourceRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", sourceLifecycle)},
 		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(wire.MsgParkedRouteResponse, wire.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
 		{err: io.EOF, wait: keepSourceOpen},
 	}}
 	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(protocol.AttachTarget{
 			Endpoint: targetTarget.Endpoint, Session: targetTarget.SessionName, Intent: protocol.IntentAttach,
 			RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}))},
 	}}
 	targetRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("target", targetLifecycle)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}
 	sourceDialer := &sequenceDialer{trs: []ports.Transport{markedDatagramTransport{Transport: sourceRemote}}}
 	remoteLifecycle := domain.SessionLifecycleID{2, 2, 2}
 	newLifecycle := domain.SessionLifecycleID{3, 3, 3}
 	remoteNewLifecycle := domain.SessionLifecycleID{4, 4, 4}
-	welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {
+	welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID:    name + "-id",
 			SessionName:  name,
 			ResumeToken:  token,
 	local1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("test", localLifecycle, 11)},
-		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(remoteHandoff))},
+		{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(remoteHandoff))},
 	}}
 	local2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("test", localLifecycle, 11)},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
+		{f: frameOf(wire.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
 			Target: protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
 		}))},
-		{f: frameOf(ports.MsgNavigateRecentRoute, mustMarshalRouteAction(protocol.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 2}))},
+		{f: frameOf(wire.MsgNavigateRecentRoute, mustMarshalRouteAction(protocol.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 2}))},
 	}}
 	local3 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("test", localLifecycle, 11)},
 	}}
 	remote1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("remote-manual", remoteLifecycle, 22)},
-		{f: frameOf(ports.MsgNavigateRecentRoute, mustMarshalRouteAction(protocol.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}))},
+		{f: frameOf(wire.MsgNavigateRecentRoute, mustMarshalRouteAction(protocol.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}))},
 	}}
 	remote2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("remote-manual", remoteLifecycle, 22)},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
+		{f: frameOf(wire.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
 			Target: protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"},
 		}))},
-		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{
+		{f: frameOf(wire.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{
 			Target: protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, ActiveTabID: "tab-2",
 		}))},
 		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
 	}}
 	remote3 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("remote-new", remoteNewLifecycle, 22)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2, local3}}
 	remoteDialer := &sequenceDialer{trs: []ports.Transport{remote1, remote2, remote3}}
 	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, remoteNewHello.ExactTarget)
 }
-func navigationDirectiveFrame(action protocol.NavigationAction) ports.Frame {
+func navigationDirectiveFrame(action protocol.NavigationAction) wire.Frame {
 	directive := protocol.NavigationDirective{Action: action}
 	if action == protocol.NavigationOpenHomePicker {
 		directive.LeaseID = protocol.ParkedRouteLeaseID{1}
 	}
-	return frameOf(ports.MsgNavigationAction, ports.MarshalNavigationDirective(directive))
+	return frameOf(wire.MsgNavigationAction, wire.MarshalNavigationDirective(directive))
 }
 func mustMarshalCommittedIdentity(identity protocol.CommittedRouteIdentity) []byte {
-	payload, err := ports.MarshalCommittedRouteIdentity(identity)
+	payload, err := wire.MarshalCommittedRouteIdentity(identity)
 	if err != nil {
 		panic(err)
 	}
 }
 func mustMarshalRouteAction(action protocol.RouteNavigationAction) []byte {
-	payload, err := ports.MarshalRouteNavigationAction(action)
+	payload, err := wire.MarshalRouteNavigationAction(action)
 	if err != nil {
 		panic(err)
 	}
 }
 func mustMarshalRoutePosition(position protocol.RoutePosition) []byte {
-	payload, err := ports.MarshalRoutePosition(position)
+	payload, err := wire.MarshalRoutePosition(position)
 	if err != nil {
 		panic(err)
 	}
 	target := protocol.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: protocol.IntentAttach}
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "local"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "local"}))},
-		recvItem{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(target))},
+		recvItem{f: frameOf(wire.MsgAttachTarget, wire.MarshalAttachTarget(target))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	gotHello := make(chan protocol.Hello, 1)
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgHello)).RunAndReturn(func(f wire.Frame) error {
-		hello, err := ports.UnmarshalHello(f.Payload)
+		hello, err := wire.UnmarshalHello(f.Payload)
 		if err != nil {
 			return err
 		}
 		return nil
 	}).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	defer in.unblock()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgHello)).RunAndReturn(func(f wire.Frame) error {
-		hello, err := ports.UnmarshalHello(f.Payload)
+		hello, err := wire.UnmarshalHello(f.Payload)
 		require.NoError(t, err)
 		require.Equal(t, uint8(1), hello.MaxOutputInFlight)
 		return nil
 	}).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	defer in.unblock()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},
+		recvItem{f: frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	// EnterRaw must NOT be called on the error-before-welcome path.
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	tr.EXPECT().Recv().Return(
-		frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
+		frameOf(wire.MsgError, wire.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
 		nil,
 	).Once()
 	tr.EXPECT().Close().Return(nil).Once()
 	var pe *client.ProtocolError
 	require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)
 	require.Equal(t, protocol.ErrVersionMismatch, pe.Code)
-	tr.AssertNotCalled(t, "Send", isType(ports.MsgTheme))
+	tr.AssertNotCalled(t, "Send", isType(wire.MsgTheme))
 }
 func TestAttachRestoredOnRecvErrorMidStream(t *testing.T) {
 	defer in.unblock()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	boom := errors.New("connection reset")
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
 		recvItem{err: boom},
 	)
 	defer unblock()
 	defer in.unblock()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
 		recvItem{err: io.EOF},
 	)
 	defer unblock()
 	gotInput := make(chan []byte, 2)
 	allowDetach := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-	tr.EXPECT().Send(isType(ports.MsgInput)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgInput)).RunAndReturn(func(f wire.Frame) error {
-		in, err := ports.UnmarshalInput(f.Payload)
+		in, err := wire.UnmarshalInput(f.Payload)
 		require.NoError(t, err)
 		gotInput <- in.Data
 		close(allowDetach)
 		return nil
 	}).Once()
-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
+	welcome := frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
+	detached := frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
 	recvCh := make(chan recvItem, 1)
 	recvCh <- recvItem{f: welcome}
 	closed := make(chan struct{})
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case it := <-recvCh:
 			return it.f, it.err
 		case <-allowDetach:
 			select {
 			case <-closed:
-				return ports.Frame{}, io.EOF
+				return wire.Frame{}, io.EOF
 			default:
 				close(closed)
 				return detached, nil
 			}
 		case <-closed:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
 	tr.EXPECT().Close().Return(nil).Once()
 	gotInput := make(chan []byte, 1)
 	allowDetach := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-	tr.EXPECT().Send(isType(ports.MsgInput)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgInput)).RunAndReturn(func(f wire.Frame) error {
-		in, err := ports.UnmarshalInput(f.Payload)
+		in, err := wire.UnmarshalInput(f.Payload)
 		require.NoError(t, err)
 		gotInput <- in.Data
 		close(allowDetach)
 		return nil
 	}).Once()
-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
+	welcome := frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
+	detached := frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
 	recvCh := make(chan recvItem, 1)
 	recvCh <- recvItem{f: welcome}
 	closed := make(chan struct{})
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case it := <-recvCh:
 			return it.f, it.err
 		case <-allowDetach:
 			select {
 			case <-closed:
-				return ports.Frame{}, io.EOF
+				return wire.Frame{}, io.EOF
 			default:
 				close(closed)
 				return detached, nil
 			}
 		case <-closed:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
 	tr.EXPECT().Close().Return(nil).Once()
 	var firstRecvOnce sync.Once
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	// The resize frame is forwarded via the sender goroutine.
 	gotResize := make(chan protocol.Resize, 1)
-	tr.EXPECT().Send(isType(ports.MsgResize)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgResize)).RunAndReturn(func(f wire.Frame) error {
-		r, _ := ports.UnmarshalResize(f.Payload)
+		r, _ := wire.UnmarshalResize(f.Payload)
 		gotResize <- r
 		close(detachAfterResize)
 		return nil
 	}).Once()
-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
+	welcome := frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
+	detached := frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
 	recvCh := make(chan recvItem, 2)
 	recvCh <- recvItem{f: welcome}
 	done := make(chan struct{})
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		firstRecvOnce.Do(func() { close(firstRecv) })
 		select {
 		case it := <-recvCh:
 			// Deliver the detach once the resize has been observed.
 			select {
 			case <-done:
-				return ports.Frame{}, io.EOF
+				return wire.Frame{}, io.EOF
 			default:
 				close(done)
 				return detached, nil
 			}
 		case <-done:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
 	tr.EXPECT().Close().Return(nil).Once()
 	defer in.unblock()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	boom := errors.New("connection reset")
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
 		recvItem{err: boom},
 	)
 	defer unblock()
 	// EnterRaw must NOT be called when the daemon rejects Hello before Welcome.
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	tr.EXPECT().Recv().Return(
-		frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
+		frameOf(wire.MsgError, wire.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
 		nil,
 	).Once()
 	tr.EXPECT().Close().Return(nil).Once()
 	require.Error(t, err)
 	var pe *client.ProtocolError
 	require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)
-	tr.AssertNotCalled(t, "Send", isType(ports.MsgTheme))
+	tr.AssertNotCalled(t, "Send", isType(wire.MsgTheme))
 }
 func TestRunPhaseASingleAttempt(t *testing.T) {
 type recordingTransport struct {
 	mu      sync.Mutex
 	recvs   []recvItem
-	sends   []ports.Frame
+	sends   []wire.Frame
 	closed  atomic.Int32
 	stall   <-chan struct{}
-	onSend  func(ports.Frame)
+	onSend  func(wire.Frame)
 	onClose func()
 }
-func (t *recordingTransport) Send(f ports.Frame) error {
+func (t *recordingTransport) Send(f wire.Frame) error {
 	t.mu.Lock()
 	t.sends = append(t.sends, f)
 	onSend := t.onSend
 	return nil
 }
-func (t *recordingTransport) Sends() []ports.Frame {
+func (t *recordingTransport) Sends() []wire.Frame {
 	t.mu.Lock()
 	defer t.mu.Unlock()
-	return append([]ports.Frame(nil), t.sends...)
+	return append([]wire.Frame(nil), t.sends...)
 }
-func (t *recordingTransport) Recv() (ports.Frame, error) {
+func (t *recordingTransport) Recv() (wire.Frame, error) {
 	if len(t.recvs) == 0 {
 		if t.stall != nil {
 			<-t.stall
 		}
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}
 	it := t.recvs[0]
 	t.recvs = t.recvs[1:]
 	t.Helper()
 	sends := tr.Sends()
 	require.NotEmpty(t, sends)
-	require.Equal(t, ports.MsgHello, sends[0].Type)
+	require.Equal(t, wire.MsgHello, sends[0].Type)
-	h, err := ports.UnmarshalHello(sends[0].Payload)
+	h, err := wire.UnmarshalHello(sends[0].Payload)
 	require.NoError(t, err)
 	return h
 }
-func welcomeFrame(token uint64) ports.Frame {
+func welcomeFrame(token uint64) wire.Frame {
-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main", ResumeToken: token, Capabilities: protocol.CapabilityResume}))
+	return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main", ResumeToken: token, Capabilities: protocol.CapabilityResume}))
 }
 func TestRunReconnectsWithRotatedTokenAndSameClientID(t *testing.T) {
 	defer term.in.unblock()
 	tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}
 	tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {err: io.EOF}}}
-	tr3 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(33)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
+	tr3 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(33)}, {f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
 	d := &sequenceDialer{trs: []ports.Transport{tr1, tr2, tr3}}
 	clock := &reconnectTestClock{}
 	result := make(chan error, 1)
 	defer term.in.unblock()
 	lifecycle := domain.SessionLifecycleID{7, 8, 9}
 	target := protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
-	welcome := func(token uint64) ports.Frame {
+	welcome := func(token uint64) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID: "work", SessionName: "work", ResumeToken: token, Capabilities: protocol.CapabilityResume,
 			CommittedIdentity: &protocol.CommittedRouteIdentity{Target: target},
 		}))
 	}
 	tr1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome(11)},
-		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{Target: target, ActiveTabID: "tab-2"}))},
+		{f: frameOf(wire.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{Target: target, ActiveTabID: "tab-2"}))},
 		{err: io.EOF},
 	}}
 	tr2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome(22)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
 	clock := &reconnectTestClock{}
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: oldLifecycle,
 		SessionName: "old", LiveTabID: "tab-1",
 	}
-	welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {
+	welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) wire.Frame {
-		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
+		return frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: token, Capabilities: protocol.CapabilityResume,
 			CommittedIdentity: &protocol.CommittedRouteIdentity{
 				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 	}
 	tr1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("old", oldLifecycle, 11)},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
+		{f: frameOf(wire.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
 			Target: protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
 		}))},
 		{err: io.EOF},
 	}}
 	tr2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("new", newLifecycle, 22)},
-		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	}}
 	dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
 	clock := &reconnectTestClock{}
 			},
 			remember: func() error { return nil },
 			recv: []recvItem{
-				{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+				{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-				{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+				{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 			},
 			wantCalled: true,
 		},
 			},
 			remember: func() error { return errors.New("disk full") },
 			recv: []recvItem{
-				{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+				{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-				{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+				{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 			},
 			wantCalled: true,
 		},
 				return nil
 			},
 			recv: []recvItem{
-				{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+				{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-				{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+				{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 			},
 		},
 		{
 				return nil
 			},
 			recv: []recvItem{
-				{f: frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"}))},
+				{f: frameOf(wire.MsgError, wire.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"}))},
 			},
 			preWelcomeReject: true,
 			wantErr:          true,
 			},
 			remember: func() error { return nil },
 			recv: []recvItem{
-				{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+				{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
 				{err: errors.New("connection reset")},
 			},
 			wantCalled: true,
 			tr := portsmocks.NewMockTransport(t)
 			if !tt.preWelcomeReject {
-				tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+				tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
 			}
-			tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+			tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 			if tt.preWelcomeReject {
 				tr.EXPECT().Recv().Return(tt.recv[0].f, tt.recv[0].err).Once()
 			} else {
 	learnerDone := make(chan struct{})
 	tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}
-	tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
+	tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
 	d := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
 	deps := testDependencies(d, term, realClock{}, nil, nil)
 	learnerDone := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	learnerDone := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 	}).Maybe()
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Close().Return(nil).Once()
 func TestRunDoesNotRetryTerminalDetachedError(t *testing.T) {
 	term := newRunTerminal()
 	defer term.in.unblock()
-	tr := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonSessionKilled}))}}}
+	tr := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonSessionKilled}))}}}
 	d := &sequenceDialer{trs: []ports.Transport{tr}}
 	err := runTestClient(context.Background(), testDependencies(d, term, realClock{}, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: false})

M internal/usecase/client/clipboard_intercept_test.go +25 -24

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 )
 	allowDetach := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	tr.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-	tr.EXPECT().Send(isType(ports.MsgResize)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgResize)).Return(nil).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgInput)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgInput)).RunAndReturn(func(f wire.Frame) error {
-		in, err := ports.UnmarshalInput(f.Payload)
+		in, err := wire.UnmarshalInput(f.Payload)
 		require.NoError(t, err)
 		gotInput <- append([]byte(nil), in.Data...)
 		if bytes.IndexByte(in.Data, triggerByte) >= 0 {
 		}
 		return nil
 	}).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgImagePush)).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(isType(wire.MsgImagePush)).RunAndReturn(func(f wire.Frame) error {
-		ip, err := ports.UnmarshalImagePush(f.Payload)
+		ip, err := wire.UnmarshalImagePush(f.Payload)
 		require.NoError(t, err)
 		gotImage <- ip
 		return nil
 	}).Maybe()
-	tr.EXPECT().Send(isType(ports.MsgClientNotice)).Return(nil).Maybe()
+	tr.EXPECT().Send(isType(wire.MsgClientNotice)).Return(nil).Maybe()
-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
+	welcome := frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
+	detached := frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
 	recvCh := make(chan recvItem, 1)
 	recvCh <- recvItem{f: welcome}
 	closed := make(chan struct{})
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case it := <-recvCh:
 			return it.f, it.err
 		case <-allowDetach:
 			select {
 			case <-closed:
-				return ports.Frame{}, io.EOF
+				return wire.Frame{}, io.EOF
 			default:
 				close(closed)
 				return detached, nil
 			}
 		case <-closed:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
 	tr.EXPECT().Close().Return(nil).Once()
 }
 type clipboardToastLifecycleTransport struct {
-	recv  chan ports.Frame
+	recv  chan wire.Frame
-	sends chan ports.Frame
+	sends chan wire.Frame
 }
-func (t *clipboardToastLifecycleTransport) Send(f ports.Frame) error {
+func (t *clipboardToastLifecycleTransport) Send(f wire.Frame) error {
 	t.sends <- f
 	return nil
 }
-func (t *clipboardToastLifecycleTransport) Recv() (ports.Frame, error) { return <-t.recv, nil }
+func (t *clipboardToastLifecycleTransport) Recv() (wire.Frame, error) { return <-t.recv, nil }
-func (*clipboardToastLifecycleTransport) Close() error                 { return nil }
+func (*clipboardToastLifecycleTransport) Close() error                { return nil }
 type clipboardToastLifecycleDialer struct{ transport ports.Transport }
 	clipboard := portsmocks.NewMockClipboardReader(t)
 	clipboard.EXPECT().ReadImage(mock.Anything).Return("", nil, errors.New("read failed")).Once()
-	transport := &clipboardToastLifecycleTransport{recv: make(chan ports.Frame, 8), sends: make(chan ports.Frame, 16)}
+	transport := &clipboardToastLifecycleTransport{recv: make(chan wire.Frame, 8), sends: make(chan wire.Frame, 16)}
-	transport.recv <- frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
+	transport.recv <- frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
 	result := make(chan error, 1)
 	go func() {
 	for !gotNotice {
 		select {
 		case sent := <-transport.sends:
-			if sent.Type != ports.MsgClientNotice {
+			if sent.Type != wire.MsgClientNotice {
 				continue
 			}
-			notice, err := ports.UnmarshalClientNotice(sent.Payload)
+			notice, err := wire.UnmarshalClientNotice(sent.Payload)
 			require.NoError(t, err)
 			require.Equal(t, protocol.ClientNoticeClipboardFallback, notice.Action)
 			gotNotice = true
 		}
 	}
 	beforeOutput := out.String()
-	transport.recv <- frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("incremental")}))
+	transport.recv <- frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("incremental")}))
-	transport.recv <- frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
+	transport.recv <- frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
 	select {
 	case err := <-result:

M internal/usecase/client/palette_attach_generation_test.go +14 -13

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // attachPaletteClock deliberately exposes each independently-created timer.
 type attachPaletteTransport struct {
 	mu           sync.Mutex
-	frames       []ports.Frame
+	frames       []wire.Frame
 	themes       []protocol.Theme
 	themeCh      chan protocol.Theme
 	inputCh      chan protocol.Input
-	detached     chan ports.Frame
+	detached     chan wire.Frame
 	themeSendErr error
 	welcomed     bool
 }
 	return &attachPaletteTransport{
 		themeCh:  make(chan protocol.Theme, 16),
 		inputCh:  make(chan protocol.Input, 16),
-		detached: make(chan ports.Frame, 1),
+		detached: make(chan wire.Frame, 1),
 	}
 }
-func (t *attachPaletteTransport) Send(frame ports.Frame) error {
+func (t *attachPaletteTransport) Send(frame wire.Frame) error {
 	t.mu.Lock()
 	t.frames = append(t.frames, frame)
 	themeSendErr := t.themeSendErr
 	t.mu.Unlock()
 	switch frame.Type {
-	case ports.MsgTheme:
+	case wire.MsgTheme:
 		if themeSendErr != nil {
 			return themeSendErr
 		}
-		got, err := ports.UnmarshalTheme(frame.Payload)
+		got, err := wire.UnmarshalTheme(frame.Payload)
 		if err != nil {
 			return err
 		}
 		t.themes = append(t.themes, got)
 		t.mu.Unlock()
 		t.themeCh <- got
-	case ports.MsgInput:
+	case wire.MsgInput:
-		got, err := ports.UnmarshalInput(frame.Payload)
+		got, err := wire.UnmarshalInput(frame.Payload)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
-func (t *attachPaletteTransport) Recv() (ports.Frame, error) {
+func (t *attachPaletteTransport) Recv() (wire.Frame, error) {
 	t.mu.Lock()
 	if !t.welcomed {
 		t.welcomed = true
 		t.mu.Unlock()
-		return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
+		return wire.Frame{Type: wire.MsgWelcome, Payload: wire.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
 	}
 	t.mu.Unlock()
 	return <-t.detached, nil
 }
 func (h *attachPaletteHarness) detach(t *testing.T) {
 	t.Helper()
-	h.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
+	h.transport.detached <- wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
 	result := <-h.done
 	require.NoError(t, result.err)
 	select {
 	// Detach starts reconnect teardown. The residual must already be owned by
 	// the lifecycle reader at the precise point the old claim is revoked.
-	first.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
+	first.transport.detached <- wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
 	require.Equal(t, []byte("\x1b"), <-revoked)
 	release()
 	require.NoError(t, (<-first.done).err)
 	// notification and publish its replacement generation before the scanner
 	// can deliver the old marker from the same terminal Read.
 	events := make(chan paletteGenerationEvent)
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	schemeHandled := make(chan struct{})
 	pump := &stdinPump{
 		ctx:              ctx,

M internal/usecase/client/palette_attach_test.go +9 -8

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type paletteAttachClock struct{}
 type paletteAttachTransport struct {
 	mu       sync.Mutex
-	sent     []ports.Frame
+	sent     []wire.Frame
 	themes   []protocol.Theme
 	finals   int
 	finalSet chan struct{}
 }
-func (t *paletteAttachTransport) Send(frame ports.Frame) error {
+func (t *paletteAttachTransport) Send(frame wire.Frame) error {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	t.sent = append(t.sent, frame)
-	if frame.Type == ports.MsgTheme {
+	if frame.Type == wire.MsgTheme {
-		theme, err := ports.UnmarshalTheme(frame.Payload)
+		theme, err := wire.UnmarshalTheme(frame.Payload)
 		if err != nil {
 			return err
 		}
 	return nil
 }
-func (t *paletteAttachTransport) Recv() (ports.Frame, error) {
+func (t *paletteAttachTransport) Recv() (wire.Frame, error) {
 	t.mu.Lock()
 	first := len(t.sent) == 1
 	t.mu.Unlock()
 	if first {
-		return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
+		return wire.Frame{Type: wire.MsgWelcome, Payload: wire.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
 	}
 	<-t.finalSet
-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}, nil
+	return wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}, nil
 }
 func (*paletteAttachTransport) Close() error { return nil }
 	transport.mu.Lock()
 	defer transport.mu.Unlock()
 	require.Len(t, transport.sent, 3)
-	require.Equal(t, []ports.MsgType{ports.MsgHello, ports.MsgTheme, ports.MsgTheme}, []ports.MsgType{
+	require.Equal(t, []wire.MsgType{wire.MsgHello, wire.MsgTheme, wire.MsgTheme}, []wire.MsgType{
 		transport.sent[0].Type, transport.sent[1].Type, transport.sent[2].Type,
 	}, "the protocol requires Hello before the two palette publications")
 	require.Len(t, transport.themes, 2)

M internal/usecase/client/reconnect_toast_test.go +61 -60

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type reconnectToastTerminalHarness struct {
 	return r.all.String()
 }
-func reconnectToastWelcome(token uint64) ports.Frame {
+func reconnectToastWelcome(token uint64) wire.Frame {
 	return reconnectToastWelcomeNamed("", token)
 }
-func reconnectToastWelcomeNamed(name string, token uint64) ports.Frame {
+func reconnectToastWelcomeNamed(name string, token uint64) wire.Frame {
-	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: name, ResumeToken: token, Capabilities: protocol.CapabilityResume})}
+	return wire.Frame{Type: wire.MsgWelcome, Payload: wire.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: name, ResumeToken: token, Capabilities: protocol.CapabilityResume})}
 }
-func reconnectToastDetach(reason uint8) ports.Frame {
+func reconnectToastDetach(reason uint8) wire.Frame {
-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: reason})}
+	return wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: reason})}
 }
 type reconnectToastRecv struct {
-	frame ports.Frame
+	frame wire.Frame
 	err   error
 }
 type reconnectToastRecordingTransport struct {
 	mu     sync.Mutex
 	recvs  []reconnectToastRecv
-	sends  []ports.Frame
+	sends  []wire.Frame
 	closed bool
 }
 type reconnectToastSentFrames struct {
 	mu      sync.Mutex
-	frames  []ports.Frame
+	frames  []wire.Frame
 	changed chan struct{}
 }
 	return &reconnectToastSentFrames{changed: make(chan struct{}, 1)}
 }
-func (s *reconnectToastSentFrames) record(frame ports.Frame) {
+func (s *reconnectToastSentFrames) record(frame wire.Frame) {
 	s.mu.Lock()
 	s.frames = append(s.frames, frame)
 	s.mu.Unlock()
 	}
 }
-func (s *reconnectToastSentFrames) find(match func(ports.Frame) bool) (ports.Frame, bool) {
+func (s *reconnectToastSentFrames) find(match func(wire.Frame) bool) (wire.Frame, bool) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	for _, frame := range s.frames {
 			return frame, true
 		}
 	}
-	return ports.Frame{}, false
+	return wire.Frame{}, false
 }
 type reconnectToastLinkTransport struct {
 	}
 }
-func (t *reconnectToastLinkTransport) Send(f ports.Frame) error {
+func (t *reconnectToastLinkTransport) Send(f wire.Frame) error {
 	t.sends.record(f)
-	if f.Type != ports.MsgClientNotice {
+	if f.Type != wire.MsgClientNotice {
 		return nil
 	}
-	notice, err := ports.UnmarshalClientNotice(f.Payload)
+	notice, err := wire.UnmarshalClientNotice(f.Payload)
 	if err != nil {
 		return err
 	}
 	return nil
 }
-func (t *reconnectToastLinkTransport) Recv() (ports.Frame, error) {
+func (t *reconnectToastLinkTransport) Recv() (wire.Frame, error) {
 	recv := <-t.recvCh
 	return recv.frame, recv.err
 }
 func (t *reconnectToastLinkTransport) LinkState() ports.LinkState { return t.state }
-func (t *reconnectToastRecordingTransport) Send(f ports.Frame) error {
+func (t *reconnectToastRecordingTransport) Send(f wire.Frame) error {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	t.sends = append(t.sends, f)
 	return nil
 }
-func (t *reconnectToastRecordingTransport) Recv() (ports.Frame, error) {
+func (t *reconnectToastRecordingTransport) Recv() (wire.Frame, error) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if len(t.recvs) == 0 {
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}
 	recv := t.recvs[0]
 	t.recvs = t.recvs[1:]
 	return nil
 }
-func (t *reconnectToastRecordingTransport) sentFrames() []ports.Frame {
+func (t *reconnectToastRecordingTransport) sentFrames() []wire.Frame {
 	t.mu.Lock()
 	defer t.mu.Unlock()
-	return append([]ports.Frame(nil), t.sends...)
+	return append([]wire.Frame(nil), t.sends...)
 }
 func (t *reconnectToastRecordingTransport) wasClosed() bool {
 	t.Helper()
 	frames := tr.sentFrames()
 	require.GreaterOrEqual(t, len(frames), 2)
-	require.Equal(t, ports.MsgHello, frames[0].Type)
+	require.Equal(t, wire.MsgHello, frames[0].Type)
-	require.Equal(t, ports.MsgTheme, frames[1].Type)
+	require.Equal(t, wire.MsgTheme, frames[1].Type)
-	theme, err := ports.UnmarshalTheme(frames[1].Payload)
+	theme, err := wire.UnmarshalTheme(frames[1].Payload)
 	require.NoError(t, err)
 	require.False(t, theme.HasForeground)
 	require.False(t, theme.HasBackground)
 	t.Helper()
 	frames := tr.sentFrames()
 	require.NotEmpty(t, frames)
-	require.Equal(t, ports.MsgHello, frames[0].Type)
+	require.Equal(t, wire.MsgHello, frames[0].Type)
-	hello, err := ports.UnmarshalHello(frames[0].Payload)
+	hello, err := wire.UnmarshalHello(frames[0].Payload)
 	require.NoError(t, err)
 	return hello
 }
 	require.Contains(t, firstToast, "┌")
 	require.Contains(t, firstToast, "probing UDP path")
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 1,
 		Base:  0,
 		New:   2,
 	beforeAwaitingReset := out.String()
 	beforeStatelessFlushes := flushes.Load()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 1,
 		Base:  0,
 		New:   0,
 	}, time.Second, time.Millisecond)
 	afterStateless := out.String()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 1,
 		Base:  2,
 		New:   3,
 	require.Contains(t, out.String(), "intervening incremental")
 	require.Contains(t, afterStateless[len(beforeAwaitingReset):], "stateless side effect")
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  0,
 		New:   4,
 	require.NotContains(t, out.String()[len(beforeAwaitingReset):], strings.Repeat(" ", reconnectToastBoundsFor(term.size, "probing UDP path").Width))
 	beforeIncrementFlushes := flushes.Load()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  4,
 		New:   5,
 		{Epoch: 1, Base: 1, New: 2, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("first skipped increment")},
 		{Epoch: 1, Base: 2, New: 3, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("second skipped increment")},
 	} {
-		tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(output)}}
+		tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(output)}}
 		require.Equal(t, beforeReset, out.String())
 	}
-	requireSentFrame(t, tr.sends, "output reset request", func(frame ports.Frame) bool {
+	requireSentFrame(t, tr.sends, "output reset request", func(frame wire.Frame) bool {
-		return frame.Type == ports.MsgOutputResetRequest
+		return frame.Type == wire.MsgOutputResetRequest
 	})
-	_, sentAck := tr.sends.find(func(frame ports.Frame) bool { return frame.Type == ports.MsgAck })
+	_, sentAck := tr.sends.find(func(frame wire.Frame) bool { return frame.Type == wire.MsgAck })
 	require.False(t, sentAck, "discarded output must not be ACKed")
 	// Handoff cleanup is an ordered terminal side effect, not a replay state.
 	// It must cross the outstanding reset gate, flush before the control handoff,
 	// and must not manufacture an independent ACK.
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Size:  domain.Size{Cols: 1, Rows: 1},
 		Data:  []byte("handoff graphics cleanup"),
 	})}}
 	cleanup := requireReconnectToastOutput(t, out.completed)
 	require.Contains(t, cleanup, "handoff graphics cleanup")
-	_, sentAck = tr.sends.find(func(frame ports.Frame) bool { return frame.Type == ports.MsgAck })
+	_, sentAck = tr.sends.find(func(frame wire.Frame) bool { return frame.Type == wire.MsgAck })
 	require.False(t, sentAck, "state-independent cleanup must not be ACKed")
 	beforeResetFlushes := flushes.Load()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  0,
 		New:   4,
 	requireAckedState(t, tr.sends, 2, 4)
 	beforeIncrementFlushes := flushes.Load()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  4,
 		New:   5,
 	}
 }
-func requireSentFrame(t *testing.T, sends *reconnectToastSentFrames, description string, match func(ports.Frame) bool) ports.Frame {
+func requireSentFrame(t *testing.T, sends *reconnectToastSentFrames, description string, match func(wire.Frame) bool) wire.Frame {
 	t.Helper()
 	timer := time.NewTimer(time.Second)
 	defer timer.Stop()
 		case <-sends.changed:
 		case <-timer.C:
 			t.Fatalf("timed out waiting for %s", description)
-			return ports.Frame{}
+			return wire.Frame{}
 		}
 	}
 }
 func requireResize(t *testing.T, sends *reconnectToastSentFrames) protocol.Resize {
 	t.Helper()
-	frame := requireSentFrame(t, sends, "Resize frame", func(frame ports.Frame) bool {
+	frame := requireSentFrame(t, sends, "Resize frame", func(frame wire.Frame) bool {
-		return frame.Type == ports.MsgResize
+		return frame.Type == wire.MsgResize
 	})
-	resize, err := ports.UnmarshalResize(frame.Payload)
+	resize, err := wire.UnmarshalResize(frame.Payload)
 	require.NoError(t, err)
 	return resize
 }
 func requireAckedState(t *testing.T, sends *reconnectToastSentFrames, epoch, state uint64) {
 	t.Helper()
-	frame := requireSentFrame(t, sends, fmt.Sprintf("ACK for epoch %d state %d", epoch, state), func(frame ports.Frame) bool {
+	frame := requireSentFrame(t, sends, fmt.Sprintf("ACK for epoch %d state %d", epoch, state), func(frame wire.Frame) bool {
-		if frame.Type != ports.MsgAck {
+		if frame.Type != wire.MsgAck {
 			return false
 		}
-		ack, err := ports.UnmarshalAck(frame.Payload)
+		ack, err := wire.UnmarshalAck(frame.Payload)
 		return err == nil && ack.Epoch == epoch && ack.State >= state
 	})
-	ack, err := ports.UnmarshalAck(frame.Payload)
+	ack, err := wire.UnmarshalAck(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, epoch, ack.Epoch)
 	require.GreaterOrEqual(t, ack.State, state)
 	require.Eventually(t, func() bool { return flushes.Load() > beforeStatus }, time.Second, time.Millisecond)
 	beforeOutput := flushes.Load()
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+	tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 1,
 		Base:  0,
 		New:   2,
 			}
 			const output = "local status output remains visible"
-			tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+			tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 				Epoch: 1,
 				Base:  0,
 				New:   2,
 			})}}
 			require.Eventually(t, func() bool { return strings.Contains(out.String(), output) }, time.Second, time.Millisecond)
 			requireAckedState(t, tr.sends, 1, 2)
-			_, sentResize := tr.sends.find(func(frame ports.Frame) bool { return frame.Type == ports.MsgResize })
+			_, sentResize := tr.sends.find(func(frame wire.Frame) bool { return frame.Type == wire.MsgResize })
 			require.False(t, sentResize, "local reconnect status must not request a daemon reset")
 			tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
 			tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}
 			requireReconnectToastOutput(t, out.completed)
 			arm()
-			tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
+			tr.recvCh <- reconnectToastRecv{frame: wire.Frame{Type: wire.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 				Epoch: 1,
 				Base:  0,
 				New:   2,
 	}
 }
-func (t *reconnectResetBlockingTransport) Send(frame ports.Frame) error {
+func (t *reconnectResetBlockingTransport) Send(frame wire.Frame) error {
-	if frame.Type != ports.MsgResize {
+	if frame.Type != wire.MsgResize {
 		return nil
 	}
 	t.enterOnce.Do(func() { close(t.entered) })
 	return io.ErrClosedPipe
 }
-func (t *reconnectResetBlockingTransport) Recv() (ports.Frame, error) {
+func (t *reconnectResetBlockingTransport) Recv() (wire.Frame, error) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if len(t.recvs) == 0 {
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}
 	recv := t.recvs[0]
 	t.recvs = t.recvs[1:]
 type reconnectToastBlockingSendTransport struct {
 	*reconnectToastLinkTransport
 	armed       atomic.Bool
-	blockType   ports.MsgType
+	blockType   wire.MsgType
 	sendErr     error
 	entered     chan struct{}
 	release     chan struct{}
 func newReconnectToastBlockingSendTransport() *reconnectToastBlockingSendTransport {
 	return &reconnectToastBlockingSendTransport{
 		reconnectToastLinkTransport: newReconnectToastLinkTransport(),
-		blockType:                   ports.MsgClientNotice,
+		blockType:                   wire.MsgClientNotice,
 		entered:                     make(chan struct{}),
 		release:                     make(chan struct{}),
 	}
 }
-func (t *reconnectToastBlockingSendTransport) Send(frame ports.Frame) error {
+func (t *reconnectToastBlockingSendTransport) Send(frame wire.Frame) error {
 	if err := t.reconnectToastLinkTransport.Send(frame); err != nil {
 		return err
 	}
 			tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}
 			requireTerminalSizeCalls(t, term, 2)
-			tr.blockType = ports.MsgResize
+			tr.blockType = wire.MsgResize
 			tr.armed.Store(true)
 			term.resizeCh <- domain.Geometry{Size: term.size}
 			select {
 	tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}
 	requireTerminalSizeCalls(t, term, 2)
-	tr.blockType = ports.MsgResize
+	tr.blockType = wire.MsgResize
 	tr.armed.Store(true)
 	term.resizeCh <- domain.Geometry{Size: term.size}
 	select {

M internal/usecase/client/same_peer_switch_test.go +5 -5

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestCloseAndDialAttachTargetSkipsSamePeerSwitch(t *testing.T) {
 		Session: "stopped", Intent: protocol.IntentAttach, ExactTarget: &exact,
 		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}
-	transport.recvCh <- reconnectToastRecv{frame: ports.Frame{
+	transport.recvCh <- reconnectToastRecv{frame: wire.Frame{
-		Type: ports.MsgAttachTarget, Payload: ports.MarshalAttachTarget(target),
+		Type: wire.MsgAttachTarget, Payload: wire.MarshalAttachTarget(target),
 	}}
 	select {
 	case <-time.After(time.Second):
 		t.Fatal("close-and-dial target did not return a handoff")
 	}
-	_, sentSamePeer := transport.sends.find(func(frame ports.Frame) bool {
+	_, sentSamePeer := transport.sends.find(func(frame wire.Frame) bool {
-		return frame.Type == ports.MsgSamePeerSwitchRequest
+		return frame.Type == wire.MsgSamePeerSwitchRequest
 	})
 	require.False(t, sentSamePeer)
 }

M internal/usecase/client/terminal_input_pump_test.go +23 -22

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type lifecycleReader struct {
 	}
 }
-func requireFrame(t *testing.T, ch <-chan ports.Frame, message string) ports.Frame {
+func requireFrame(t *testing.T, ch <-chan wire.Frame, message string) wire.Frame {
 	t.Helper()
 	select {
 	case frame := <-ch:
 		return frame
 	case <-time.After(time.Second):
 		t.Fatal(message)
-		return ports.Frame{}
+		return wire.Frame{}
 	}
 }
 	go func() {
 		(&stdinPump{
 			ctx: cancelledCtx, cancel: cancelCancelled, input: input,
-			out: make(chan ports.Frame, 1), clock: newAttachPaletteClock(),
+			out: make(chan wire.Frame, 1), clock: newAttachPaletteClock(),
 			logger: slog.New(slog.DiscardHandler), paletteEvents: make(chan paletteGenerationEvent),
 			activeGeneration: &activeGeneration,
 		}).run()
 	replacementCtx, cancelReplacement := context.WithCancel(context.Background())
 	defer cancelReplacement()
-	out := make(chan ports.Frame, len(want))
+	out := make(chan wire.Frame, len(want))
 	replacementDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
 	var got []byte
 	for len(got) < len(want) {
 		frame := <-out
-		input, err := ports.UnmarshalInput(frame.Payload)
+		input, err := wire.UnmarshalInput(frame.Payload)
 		require.NoError(t, err)
 		got = append(got, input.Data...)
 	}
 	go func() {
 		(&stdinPump{
 			ctx: ctx, cancel: cancel, input: input, consumer: consumer,
-			out: make(chan ports.Frame, 1), clock: newAttachPaletteClock(),
+			out: make(chan wire.Frame, 1), clock: newAttachPaletteClock(),
 			logger: slog.New(slog.DiscardHandler), paletteEvents: make(chan paletteGenerationEvent),
 			afterInputTake: func() {
 				close(taken)
 	oldDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
-			ctx: oldCtx, cancel: cancelOld, input: input, out: make(chan ports.Frame, 1),
+			ctx: oldCtx, cancel: cancelOld, input: input, out: make(chan wire.Frame, 1),
 			clock: oldClock, logger: slog.New(slog.DiscardHandler), paletteEvents: make(chan paletteGenerationEvent),
 			activeGeneration: &activeGeneration,
 		}).run()
 	newCtx, cancelNew := context.WithCancel(context.Background())
 	defer cancelNew()
 	newClock := newAttachPaletteClock()
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	newDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
 	(<-newClock.timers).fire() // marker ambiguity deadline
 	(<-newClock.timers).fire() // paste coalescer's lone-ESC deadline
 	frame := <-out
-	got, err := ports.UnmarshalInput(frame.Payload)
+	got, err := wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("\x1b"), got.Data)
 	ctx, cancel := context.WithCancel(context.Background())
 	delivered := make(chan struct{})
 	done := make(chan struct{})
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	go func() {
 		(&stdinPump{
 			ctx: ctx, cancel: cancel, input: input, out: out, clock: newAttachPaletteClock(),
 		close(done)
 	}()
 	frame := requireFrame(t, out, "timed out waiting for delivered input prefix")
-	got, err := ports.UnmarshalInput(frame.Payload)
+	got, err := wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("x"), got.Data)
 	requireSignal(t, delivered, "timed out waiting for cancellation after input delivery")
 	requireSignal(t, done, "timed out waiting for cancelled stdin pump")
 	replacementCtx, cancelReplacement := context.WithCancel(context.Background())
-	replacementOut := make(chan ports.Frame, 1)
+	replacementOut := make(chan wire.Frame, 1)
 	replacementDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
 		close(replacementDone)
 	}()
 	frame = requireFrame(t, replacementOut, "timed out waiting for undelivered input suffix")
-	got, err = ports.UnmarshalInput(frame.Payload)
+	got, err = wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("y"), got.Data, "replacement must receive only the undelivered ordinary suffix")
 	input.enqueue(terminalReadResult{data: raw}, 1)
 	var activeGeneration atomic.Uint64
 	ctx, cancel := context.WithCancel(context.Background())
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	done := make(chan struct{})
 	go func() {
 		(&stdinPump{
 		close(done)
 	}()
 	frame := requireFrame(t, out, "timed out waiting for delivered input prefix")
-	got, err := ports.UnmarshalInput(frame.Payload)
+	got, err := wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("x"), got.Data)
 	requireSignal(t, done, "timed out waiting for cancelled stdin pump")
 	replacementCtx, cancelReplacement := context.WithCancel(context.Background())
 	replacementClock := newAttachPaletteClock()
-	replacementOut := make(chan ports.Frame, 1)
+	replacementOut := make(chan wire.Frame, 1)
 	replacementDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
 	}()
 	requireTimer(t, replacementClock.timers, "timed out waiting for paste-prefix ambiguity timer").fire()
 	frame = requireFrame(t, replacementOut, "timed out waiting for coalescer-held suffix")
-	got, err = ports.UnmarshalInput(frame.Payload)
+	got, err = wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, held, got.Data, "replacement must receive the coalescer-held suffix exactly once")
 	ctx, cancel := context.WithCancel(context.Background())
 	delivered := make(chan struct{})
 	done := make(chan struct{})
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	go func() {
 		(&stdinPump{
 			ctx: ctx, cancel: cancel, input: input, out: out, clock: newAttachPaletteClock(),
 		close(done)
 	}()
 	frame := <-out
-	got, err := ports.UnmarshalInput(frame.Payload)
+	got, err := wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("x"), got.Data)
 	<-delivered
 	go func() {
 		(&stdinPump{
 			ctx: firstCtx, cancel: cancelFirst, input: input,
-			out: make(chan ports.Frame), clock: newAttachPaletteClock(),
+			out: make(chan wire.Frame), clock: newAttachPaletteClock(),
 			logger: slog.New(slog.DiscardHandler), paletteEvents: make(chan paletteGenerationEvent),
 			activeGeneration: &activeGeneration,
 		}).run()
 	secondCtx, cancelSecond := context.WithCancel(context.Background())
 	defer cancelSecond()
-	out := make(chan ports.Frame, 1)
+	out := make(chan wire.Frame, 1)
 	secondDone := make(chan struct{})
 	go func() {
 		(&stdinPump{
 	reader.chunks <- []byte("x")
 	frame := <-out
-	got, err := ports.UnmarshalInput(frame.Payload)
+	got, err := wire.UnmarshalInput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, []byte("x"), got.Data)
 	require.Equal(t, 1, reader.maxActive(), "cancelled attempts must not leave competing reads")

M internal/usecase/client/transport_observability_test.go +12 -11

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/client"
 )
 	defer reporter.Close()
 	acked := make(chan struct{})
 	transport := portsmocks.NewMockTransport(t)
-	transport.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	transport.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-	transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	transport.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
-	transport.EXPECT().Send(isType(ports.MsgAck)).Run(func(ports.Frame) { close(acked) }).Return(nil).Once()
+	transport.EXPECT().Send(isType(wire.MsgAck)).Run(func(wire.Frame) { close(acked) }).Return(nil).Once()
 	unblock := scriptRecv(transport,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("flush-before-observe"), New: 3}))},
+		recvItem{f: frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("flush-before-observe"), New: 3}))},
 	)
 	defer unblock()
 	transport.EXPECT().Close().Return(nil).Once()
 	reporter := ports.NewSerializedRuntimeObserver(observer, 64)
 	defer reporter.Close()
 	transport := portsmocks.NewMockTransport(t)
-	transport.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
+	transport.EXPECT().Send(isType(wire.MsgHello)).Return(nil).Once()
-	transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
+	transport.EXPECT().Send(isType(wire.MsgTheme)).Return(nil).Maybe()
 	unblock := scriptRecv(transport,
-		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
+		recvItem{f: frameOf(wire.MsgWelcome, wire.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("unchanged-by-observer"), New: 3}))},
+		recvItem{f: frameOf(wire.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("unchanged-by-observer"), New: 3}))},
-		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
+		recvItem{f: frameOf(wire.MsgDetached, wire.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
 	)
 	defer unblock()
-	transport.EXPECT().Send(isType(ports.MsgAck)).Return(nil).Maybe()
+	transport.EXPECT().Send(isType(wire.MsgAck)).Return(nil).Maybe()
 	transport.EXPECT().Close().Return(nil).Once()
 	err := runTestClient(context.Background(), testDependencies(transportDialer{transport: transport}, term, realClock{}, nil, reporter), client.AttachRequest{Intent: protocol.IntentEphemeral})

M internal/usecase/client/wire_external_test_helpers_test.go +2 -2

 package client_test
 import (
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalOutput(m protocol.Output) []byte {
-	payload, err := ports.MarshalOutput(m)
+	payload, err := wire.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 	}

M internal/usecase/client/wire_test_helpers_test.go +2 -2

 package client
 import (
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalOutput(m protocol.Output) []byte {
-	payload, err := ports.MarshalOutput(m)
+	payload, err := wire.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 	}

M internal/usecase/daemon/attachment_effect_gate.go +2 -1

 	"sync/atomic"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type attachmentEffectPhase uint8
 	g.mu.Unlock()
 }
-func (t *attachmentEffect) sendControl(frame ports.Frame) error {
+func (t *attachmentEffect) sendControl(frame wire.Frame) error {
 	if !t.current() || t.ac == nil || t.transport.transport == nil {
 		return errAttachmentTransition
 	}

M internal/usecase/daemon/attachment_effect_gate_test.go +17 -17

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 )
 	}
 }
-func (t *blockedRenderReplacementTransport) Send(ports.Frame) error {
+func (t *blockedRenderReplacementTransport) Send(wire.Frame) error {
 	t.sendOnce.Do(func() { close(t.sendEntered) })
 	<-t.closed
 	return errors.New("transport closed")
 }
-func (*blockedRenderReplacementTransport) Recv() (ports.Frame, error) {
+func (*blockedRenderReplacementTransport) Recv() (wire.Frame, error) {
-	return ports.Frame{}, io.EOF
+	return wire.Frame{}, io.EOF
 }
 func (t *blockedRenderReplacementTransport) Close() error {
 	return &teardownBlockingTransport{sendEntered: make(chan struct{}), closed: make(chan struct{})}
 }
-func (t *teardownBlockingTransport) Send(ports.Frame) error {
+func (t *teardownBlockingTransport) Send(wire.Frame) error {
 	t.sendOnce.Do(func() { close(t.sendEntered) })
 	<-t.closed
 	return errors.New("transport closed")
 }
-func (*teardownBlockingTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*teardownBlockingTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
 func (t *teardownBlockingTransport) Close() error {
 	t.closeOnce.Do(func() { close(t.closed) })
 	tests := []struct {
 		name   string
 		setup  func(*Daemon, *session, *attachedClient, *transactionalResizePTY)
-		frame  ports.Frame
+		frame  wire.Frame
 		assert func(*testing.T, *attachedClient, *transactionalResizePTY)
 	}{
 		{
 		},
 		{
 			name: "theme",
-			frame: ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(protocol.Theme{
+			frame: wire.Frame{Type: wire.MsgTheme, Payload: wire.MarshalTheme(protocol.Theme{
 				HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 				HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 			})},
 			setup: func(_ *Daemon, _ *session, ac *attachedClient, _ *transactionalResizePTY) {
 				ac.output.next = 3
 			},
-			frame: ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: 1, State: 1})},
+			frame: wire.Frame{Type: wire.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: 1, State: 1})},
 			assert: func(t *testing.T, ac *attachedClient, _ *transactionalResizePTY) {
 				ac.sendMu.Lock()
 				defer ac.sendMu.Unlock()
 		Home:        activeRef,
 		Entries:     []protocol.RecentRouteEntry{testRouteEntry(7, 3, "previous", 7, protocol.RouteKindLocal)},
 	}
-	payload, err := ports.MarshalRecentRouteSnapshot(snapshot)
+	payload, err := wire.MarshalRecentRouteSnapshot(snapshot)
 	require.NoError(t, err)
-	require.False(t, d.handleAttachmentClientFrame(token, ports.Frame{Type: ports.MsgRecentRouteSnapshot, Payload: payload}))
+	require.False(t, d.handleAttachmentClientFrame(token, wire.Frame{Type: wire.MsgRecentRouteSnapshot, Payload: payload}))
 	require.Equal(t, snapshot, ac.routeSnapshotCopy())
 }
 	token := source.captureAttachmentCapability(ac, transport)
 	token.lease = rc.attachmentLease(ac)
 	ac.installTestAttachmentCapability(token)
-	payload, err := ports.MarshalCommandRequest(protocol.CommandRequest{
+	payload, err := wire.MarshalCommandRequest(protocol.CommandRequest{
 		Version: protocol.Version, RequestID: 1, Slug: "back-session", Attached: true,
 	})
 	require.NoError(t, err)
-	require.False(t, d.handleAttachmentClientFrame(token, ports.Frame{Type: ports.MsgCommand, Payload: payload}))
+	require.False(t, d.handleAttachmentClientFrame(token, wire.Frame{Type: wire.MsgCommand, Payload: payload}))
 	require.Same(t, source, ac.currentAttachmentSession())
 	frames := transport.Sends()
 	require.NotEmpty(t, frames)
 	var result protocol.CommandResult
 	for _, frame := range frames {
-		if frame.Type != ports.MsgCommandResult {
+		if frame.Type != wire.MsgCommandResult {
 			continue
 		}
-		result, err = ports.UnmarshalCommandResult(frame.Payload)
+		result, err = wire.UnmarshalCommandResult(frame.Payload)
 		require.NoError(t, err)
 		break
 	}
 	require.True(t, result.OK, result.Text)
 	var action protocol.RouteNavigationAction
 	for _, frame := range frames {
-		if frame.Type != ports.MsgNavigateRecentRoute {
+		if frame.Type != wire.MsgNavigateRecentRoute {
 			continue
 		}
-		action, err = ports.UnmarshalRouteNavigationAction(frame.Payload)
+		action, err = wire.UnmarshalRouteNavigationAction(frame.Payload)
 		require.NoError(t, err)
 	}
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}, action)

M internal/usecase/daemon/attachment_output.go +10 -9

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // attachmentOutput owns the terminal-output dependency chain and emitted
 	return &preparedAttachmentOutput{output: o, ansi: ansi, graphics: preparedGraphics, cursor: cursor, data: data}, nil
 }
-func (p *preparedAttachmentOutput) send(echoAck uint64, send func(ports.Frame) error) error {
+func (p *preparedAttachmentOutput) send(echoAck uint64, send func(wire.Frame) error) error {
 	if p == nil || p.ansi == nil {
 		return nil
 	}
 	sendFrame := send
 	if p.graphics != nil {
-		sendFrame = func(frame ports.Frame) error {
+		sendFrame = func(frame wire.Frame) error {
 			p.graphics.markSendAttempted()
 			return send(frame)
 		}
 	}, nil
 }
-func (p *preparedOutput) send(data []byte, echoAck uint64, send func(ports.Frame) error) error {
+func (p *preparedOutput) send(data []byte, echoAck uint64, send func(wire.Frame) error) error {
 	if p == nil || p.stream == nil || p.attempted {
 		return nil
 	}
 		(p.stream.attachment == nil || p.stream.attachment.lifecycle.generationValue() == p.connectionGeneration)
 }
-func marshalOutputState(data []byte, epoch, base, next, echoAck, viewRevision uint64, size domain.Size, full bool) (ports.Frame, error) {
+func marshalOutputState(data []byte, epoch, base, next, echoAck, viewRevision uint64, size domain.Size, full bool) (wire.Frame, error) {
-	payload, err := ports.MarshalOutput(protocol.Output{
+	payload, err := wire.MarshalOutput(protocol.Output{
 		Epoch: epoch, Base: base, New: next, Echo: echoAck, ViewRevision: viewRevision,
 		Size: size, Full: full, Data: data,
 	})
 	if err != nil {
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
-	return ports.Frame{Type: ports.MsgOutput, Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgOutput, Payload: payload}, nil
 }
 // sideEffect builds an output frame without advancing the state stream. When
 // an attachment is present, callers must hold its sendMu; attachment-bound
 // sends use sideEffectLocked after validating their transport incarnation.
-func (s *attachmentOutput) sideEffect(data []byte, echoAck uint64) (ports.Frame, error) {
+func (s *attachmentOutput) sideEffect(data []byte, echoAck uint64) (wire.Frame, error) {
 	s.lockView()
 	defer s.unlockView()
 	return s.sideEffectLocked(data, echoAck)
 // sideEffectLocked requires the attachment view lock for both frame creation
 // and transport emission. Keeping that lock across the send prevents a view
 // publication from overtaking a frame that was fenced just before it.
-func (s *attachmentOutput) sideEffectLocked(data []byte, echoAck uint64) (ports.Frame, error) {
+func (s *attachmentOutput) sideEffectLocked(data []byte, echoAck uint64) (wire.Frame, error) {
 	_, epoch, viewRevision := s.fenceLocked()
 	size := domain.Size{Cols: 1, Rows: 1}
 	if s != nil && s.attachment != nil {

M internal/usecase/daemon/attachment_output_test.go +32 -31

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/stretchr/testify/require"
 )
 	first, ok, err := drawOutputState(t, stream, firstFrame, nil, true, 7)
 	require.NoError(t, err)
 	require.True(t, ok)
-	firstOut, err := ports.UnmarshalOutput(first.Payload)
+	firstOut, err := wire.UnmarshalOutput(first.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), firstOut.Base)
 	require.Equal(t, uint64(1), firstOut.New)
 	second, ok, err := drawOutputState(t, stream, secondFrame, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false, 8)
 	require.NoError(t, err)
 	require.True(t, ok)
-	secondOut, err := ports.UnmarshalOutput(second.Payload)
+	secondOut, err := wire.UnmarshalOutput(second.Payload)
 	require.NoError(t, err)
 	require.Equal(t, firstOut.New, secondOut.Base)
 	require.Equal(t, uint64(2), secondOut.New)
 	release := make(chan struct{})
 	sendDone := make(chan error, 1)
 	go func() {
-		sendDone <- prepared.send(prepared.data, 0, func(ports.Frame) error {
+		sendDone <- prepared.send(prepared.data, 0, func(wire.Frame) error {
 			close(entered)
 			<-release
 			return nil
 	second := newAttachment()
 	firstPrepared, err := first.prepare(frame, nil, true)
 	require.NoError(t, err)
-	var firstFrame ports.Frame
+	var firstFrame wire.Frame
-	require.NoError(t, firstPrepared.send(firstPrepared.data, 0, func(frame ports.Frame) error {
+	require.NoError(t, firstPrepared.send(firstPrepared.data, 0, func(frame wire.Frame) error {
 		firstFrame = frame
 		return nil
 	}))
-	firstOutput, err := ports.UnmarshalOutput(firstFrame.Payload)
+	firstOutput, err := wire.UnmarshalOutput(firstFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), firstOutput.Epoch)
 	require.Equal(t, uint64(1), firstOutput.New)
 	secondPrepared, err := second.prepare(frame, nil, true)
 	require.NoError(t, err)
-	require.NoError(t, secondPrepared.send(secondPrepared.data, 0, func(ports.Frame) error { return nil }))
+	require.NoError(t, secondPrepared.send(secondPrepared.data, 0, func(wire.Frame) error { return nil }))
 	require.Equal(t, uint64(1), second.epoch)
 	require.Equal(t, uint64(1), second.next)
 	require.Equal(t, uint64(1), first.next)
 	require.Zero(t, first.next)
 	require.Zero(t, first.acked)
 	var staleSent bool
-	require.NoError(t, pending.send(pending.data, 0, func(ports.Frame) error {
+	require.NoError(t, pending.send(pending.data, 0, func(wire.Frame) error {
 		staleSent = true
 		return nil
 	}))
 	reset, err := first.prepare(changed, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false)
 	require.NoError(t, err)
-	var resetFrame ports.Frame
+	var resetFrame wire.Frame
-	require.NoError(t, reset.send(reset.data, 0, func(frame ports.Frame) error {
+	require.NoError(t, reset.send(reset.data, 0, func(frame wire.Frame) error {
 		resetFrame = frame
 		return nil
 	}))
-	resetOutput, err := ports.UnmarshalOutput(resetFrame.Payload)
+	resetOutput, err := wire.UnmarshalOutput(resetFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), resetOutput.Epoch)
 	require.Zero(t, resetOutput.Base)
 			fillOutputStateRows(frame, []string{"abc"})
 			initial, err := stream.prepare(frame, nil, true)
 			require.NoError(t, err)
-			require.NoError(t, initial.send(initial.data, 0, func(ports.Frame) error { return nil }))
+			require.NoError(t, initial.send(initial.data, 0, func(wire.Frame) error { return nil }))
 			changed := frame.Clone()
 			changed.Set(0, 0, renderer.Cell{Rune: 'x', Style: renderer.DefaultStyle()})
 			pending, err := stream.prepare(changed, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false)
 			require.NoError(t, err)
 			tt.change(ac)
 			var sent bool
-			require.NoError(t, pending.send(pending.data, 0, func(ports.Frame) error {
+			require.NoError(t, pending.send(pending.data, 0, func(wire.Frame) error {
 				sent = true
 				return nil
 			}))
 			retry, err := stream.prepare(changed, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false)
 			require.NoError(t, err)
-			require.NoError(t, retry.send(retry.data, 0, func(ports.Frame) error { return nil }))
+			require.NoError(t, retry.send(retry.data, 0, func(wire.Frame) error { return nil }))
 			require.Equal(t, uint64(2), stream.next)
 		})
 	}
 	beforeEpoch, beforeNext, beforeAck := stream.epoch, stream.next, stream.acked
 	frame, err := stream.sideEffect([]byte("pty"), 9)
 	require.NoError(t, err)
-	out, err := ports.UnmarshalOutput(frame.Payload)
+	out, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, beforeEpoch, out.Epoch)
 	require.Zero(t, out.Base)
 	fillOutputStateRows(initial, []string{"abc"})
 	first, err := stream.prepare(initial, nil, true)
 	require.NoError(t, err)
-	require.NoError(t, first.send(first.data, 0, func(ports.Frame) error { return nil }))
+	require.NoError(t, first.send(first.data, 0, func(wire.Frame) error { return nil }))
 	require.Equal(t, uint64(1), stream.next)
 	changed := initial.Clone()
 	require.Empty(t, probe.Bytes(), "preparation must not advance the renderer shadow")
 	sendErr := errors.New("send failed")
-	require.ErrorIs(t, pending.send(pending.data, 0, func(ports.Frame) error { return sendErr }), sendErr)
+	require.ErrorIs(t, pending.send(pending.data, 0, func(wire.Frame) error { return sendErr }), sendErr)
 	require.Equal(t, uint64(1), stream.next, "failed send must not advance the state chain")
 	pending.commitNoSend()
 	probe, err = stream.renderer.Prepare(initial, nil, false)
 	retry, err := stream.prepare(changed, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false)
 	require.NoError(t, err)
-	var sent ports.Frame
+	var sent wire.Frame
-	require.NoError(t, retry.send(retry.data, 0, func(frame ports.Frame) error {
+	require.NoError(t, retry.send(retry.data, 0, func(frame wire.Frame) error {
 		sent = frame
 		return nil
 	}))
-	out, err := ports.UnmarshalOutput(sent.Payload)
+	out, err := wire.UnmarshalOutput(sent.Payload)
 	require.NoError(t, err)
 	require.Zero(t, out.Base, "retry after ambiguous send failure must be dependency-free")
 	require.Equal(t, uint64(2), out.New, "state numbers remain monotonic across rebases")
 	require.Equal(t, uint64(2), stream.next, "successful retry advances the chain exactly once")
-	require.NoError(t, retry.send(retry.data, 0, func(ports.Frame) error {
+	require.NoError(t, retry.send(retry.data, 0, func(wire.Frame) error {
 		t.Fatal("completed output sent twice")
 		return nil
 	}))
 	fillOutputStateRows(frame, []string{"abc"})
 	initial, err := stream.prepare(frame, nil, true)
 	require.NoError(t, err)
-	require.NoError(t, initial.send(initial.data, 0, func(ports.Frame) error { return nil }))
+	require.NoError(t, initial.send(initial.data, 0, func(wire.Frame) error { return nil }))
 	noOp, err := stream.prepare(frame, nil, false)
 	require.NoError(t, err)
 	return prepared.data, nil
 }
-func outputStateFrame(stream *attachmentOutput, data []byte, reset bool, echoAck uint64) ports.Frame {
+func outputStateFrame(stream *attachmentOutput, data []byte, reset bool, echoAck uint64) wire.Frame {
 	stream.next++
 	base := stream.next - 1
 	if reset {
 	return frame
 }
-func drawOutputState(t *testing.T, stream *attachmentOutput, frame renderer.Frame, damage []renderer.Damage, reset bool, echoAck uint64) (ports.Frame, bool, error) {
+func drawOutputState(t *testing.T, stream *attachmentOutput, frame renderer.Frame, damage []renderer.Damage, reset bool, echoAck uint64) (wire.Frame, bool, error) {
 	t.Helper()
 	prepared, err := stream.prepare(frame, damage, reset)
 	if err != nil || len(prepared.data) == 0 {
 		if prepared != nil {
 			prepared.commitNoSend()
 		}
-		return ports.Frame{}, false, err
+		return wire.Frame{}, false, err
 	}
-	var output ports.Frame
+	var output wire.Frame
-	err = prepared.send(prepared.data, echoAck, func(frame ports.Frame) error {
+	err = prepared.send(prepared.data, echoAck, func(frame wire.Frame) error {
 		output = frame
 		return nil
 	})
 	if err != nil {
-		return ports.Frame{}, false, err
+		return wire.Frame{}, false, err
 	}
 	return output, true, nil
 }
 	resized, ok, err := drawOutputState(t, stream, screen.Frame, screen.Damage(), true, 0)
 	require.NoError(t, err)
 	require.True(t, ok)
-	resizeOutput, err := ports.UnmarshalOutput(resized.Payload)
+	resizeOutput, err := wire.UnmarshalOutput(resized.Payload)
 	require.NoError(t, err)
 	require.Zero(t, resizeOutput.Base, "resize must emit the one reset frame")
 	screen.ClearDamage()
 	damaged, ok, err := drawOutputState(t, stream, screen.Frame, []renderer.Damage{{Kind: renderer.DamageText, Width: 1, Height: 1}}, false, 0)
 	require.NoError(t, err)
 	require.True(t, ok)
-	damageOutput, err := ports.UnmarshalOutput(damaged.Payload)
+	damageOutput, err := wire.UnmarshalOutput(damaged.Payload)
 	require.NoError(t, err)
 	require.Equal(t, resizeOutput.New, damageOutput.Base, "later damage must remain incremental")
 }
 	require.NoError(t, err)
 	sendErr := errors.New("send failed")
-	require.ErrorIs(t, prepared.send(0, func(ports.Frame) error { return sendErr }), sendErr)
+	require.ErrorIs(t, prepared.send(0, func(wire.Frame) error { return sendErr }), sendErr)
 	require.Equal(t, cursorOut{valid: true, row: 1, col: 1}, output.lastCursor)
 	require.Empty(t, graphicsState.assets)

M internal/usecase/daemon/attachment_parking_test.go +5 -5

 	"github.com/stretchr/testify/require"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type resumeWelcomeFailureTransport struct {
 	closeTrackingTransport
 }
-func (*resumeWelcomeFailureTransport) Send(ports.Frame) error { return errWelcomeSendFailed }
+func (*resumeWelcomeFailureTransport) Send(wire.Frame) error { return errWelcomeSendFailed }
 var errWelcomeSendFailed = errors.New("welcome send failed")
 	d.clientGone(sess, ac, oldTransport, false)
 	resumedTransport := &closeTrackingTransport{}
-	d.handleHello(resumedTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", oldToken))})
+	d.handleHello(resumedTransport, wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", oldToken))})
 	newToken := ac.resumeToken
 	require.NotEqual(t, oldToken, newToken)
 	d.mu.Lock()
 	require.False(t, oldRetained)
 	require.NotNil(t, newParked)
 	require.NotEmpty(t, resumedTransport.Sends())
-	require.Equal(t, ports.MsgWelcome, resumedTransport.Sends()[0].Type, "Welcome must remain the first server frame after Hello")
+	require.Equal(t, wire.MsgWelcome, resumedTransport.Sends()[0].Type, "Welcome must remain the first server frame after Hello")
 }
 func TestFailedResumeHandshakeKeepsParkedCredential(t *testing.T) {
 	d.clientGone(sess, ac, oldTransport, false)
 	failed := &resumeWelcomeFailureTransport{}
-	d.handleHello(failed, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", token))})
+	d.handleHello(failed, wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", token))})
 	require.Nil(t, ac.transport())
 	d.mu.Lock()
 	parked := d.parked[token]

M internal/usecase/daemon/attachment_registry_test.go +3 -3


@@ -5,7 +5,7 @@ import (
5		"testing"	5		"testing"
6			6
7		"github.com/bnema/vev/internal/domain"	7		"github.com/bnema/vev/internal/domain"
8	-	"github.com/bnema/vev/internal/ports"	8	+	"github.com/bnema/vev/internal/protocol/wire"
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10		)	10		)
11			11

@@ -99,7 +99,7 @@ func TestTabForAttachmentRepairRebasesOutputBeforePublishingRevision(t *testing.
99		require.Greater(t, ac.output.currentEpoch(), beforeEpoch)	99		require.Greater(t, ac.output.currentEpoch(), beforeEpoch)
100		frame, err := ac.output.sideEffect([]byte("x"), 0)	100		frame, err := ac.output.sideEffect([]byte("x"), 0)
101		require.NoError(t, err)	101		require.NoError(t, err)
102	-	output, err := ports.UnmarshalOutput(frame.Payload)	102	+	output, err := wire.UnmarshalOutput(frame.Payload)
103		require.NoError(t, err)	103		require.NoError(t, err)
104		require.Equal(t, after.revision, output.ViewRevision)	104		require.Equal(t, after.revision, output.ViewRevision)
105		require.Equal(t, ac.output.currentEpoch(), output.Epoch)	105		require.Equal(t, ac.output.currentEpoch(), output.Epoch)

@@ -129,7 +129,7 @@ func TestPrepareRemovedTabViewRebasesOutputBeforeSideEffect(t *testing.T) {
129			129
130		frame, err := ac.output.sideEffect([]byte("replacement"), 0)	130		frame, err := ac.output.sideEffect([]byte("replacement"), 0)
131		require.NoError(t, err)	131		require.NoError(t, err)
132	-	output, err := ports.UnmarshalOutput(frame.Payload)	132	+	output, err := wire.UnmarshalOutput(frame.Payload)
133		require.NoError(t, err)	133		require.NoError(t, err)
134		require.Equal(t, after.revision, output.ViewRevision)	134		require.Equal(t, after.revision, output.ViewRevision)
135		require.NotEqual(t, beforeEpoch, output.Epoch)	135		require.NotEqual(t, beforeEpoch, output.Epoch)

M internal/usecase/daemon/attachment_render_test.go +22 -21

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 type blockedAttachmentTransport struct {
 	entered chan struct{}
 	release chan struct{}
-	sends   chan ports.Frame
+	sends   chan wire.Frame
 	blocked atomic.Bool
 	once    sync.Once
 }
-func (t *blockedAttachmentTransport) Send(frame ports.Frame) error {
+func (t *blockedAttachmentTransport) Send(frame wire.Frame) error {
-	if frame.Type == ports.MsgOutput && t.blocked.Load() {
+	if frame.Type == wire.MsgOutput && t.blocked.Load() {
 		t.once.Do(func() { close(t.entered) })
 		<-t.release
 	}
 	t.sends <- frame
 	return nil
 }
-func (*blockedAttachmentTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*blockedAttachmentTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*blockedAttachmentTransport) Close() error               { return nil }
+func (*blockedAttachmentTransport) Close() error              { return nil }
 func TestStaleCapacityReadinessRequeuesWithoutAnotherInvalidation(t *testing.T) {
 	d, sess, ac, sends := newManualSessionWithPTYs(t, nil)
 	ac.output.syncCapacityLocked()
 	ac.sendMu.Unlock()
 	close(releaseRetry)
-	frame := awaitFrame(t, sends, ports.MsgOutput)
+	frame := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(output.Data), "capacity race")
 	awaitTestCompletion(t, fireDone, "initial fire did not finish")
 	defer releasePTY()
 	clock := &signalClock{timers: make(chan *signalTimer, 16)}
 	d := newTestDaemon(t, newFactory(t, pty), clock)
-	oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
+	oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan wire.Frame, 8)}
 	sess, old, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)
 	require.NoError(t, err)
-	newTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
+	newTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan wire.Frame, 8)}
 	_, fresh, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, newTransport)
 	require.NoError(t, err)
 	painted := make(chan bool, 1)
 	go func() { painted <- d.firstPaintForTransition(token) }()
 	frame := awaitTestValue(t, newTransport.sends, "healthy attachment first paint was gated by slow peer")
-	require.Equal(t, ports.MsgOutput, frame.Type)
+	require.Equal(t, wire.MsgOutput, frame.Type)
 	require.True(t, <-painted)
 	close(oldTransport.release)
 }
 	defer releasePTY()
 	clock := &signalClock{timers: make(chan *signalTimer, 16)}
 	d := newTestDaemon(t, newFactory(t, pty), clock)
-	oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
+	oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan wire.Frame, 8)}
 	sess, old, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)
 	require.NoError(t, err)
 	rc := sess.renderCoordinator()
 	awaitTestCompletion(t, oldTransport.entered, "slow attachment did not begin its blocked output")
 	hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}
-	tr, sends, releaseConn := newConn(t, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)})
+	tr, sends, releaseConn := newConn(t, wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(hello)})
 	defer releaseConn()
 	handshakeDone := make(chan struct{})
 	go func() {
 		d.handleConn(tr)
 		close(handshakeDone)
 	}()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	firstPaint := awaitFrame(t, sends, ports.MsgOutput)
+	firstPaint := awaitFrame(t, sends, wire.MsgOutput)
-	require.Equal(t, ports.MsgOutput, firstPaint.Type)
+	require.Equal(t, wire.MsgOutput, firstPaint.Type)
 	releaseConn()
 	awaitTestCompletion(t, handshakeDone, "multi-attachment handshake did not complete after first paint")
 	close(oldTransport.release)
 	pty, releasePTY := newBlockingPTY(t)
 	defer releasePTY()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-	firstTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
+	firstTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan wire.Frame, 8)}
 	sess, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, firstTransport)
 	require.NoError(t, err)
-	secondTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
+	secondTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan wire.Frame, 8)}
 	_, _, err = d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, secondTransport)
 	require.NoError(t, err)
 	rc := sess.renderCoordinator()
 	}
 	select {
 	case frame := <-secondTransport.sends:
-		require.Equal(t, ports.MsgOutput, frame.Type)
+		require.Equal(t, wire.MsgOutput, frame.Type)
-		out, err := ports.UnmarshalOutput(frame.Payload)
+		out, err := wire.UnmarshalOutput(frame.Payload)
 		require.NoError(t, err)
 		require.True(t, out.Full, "fan-out peers must send a fresh first frame even after another attachment acknowledges shared damage")
 	case <-time.After(time.Second):
 	require.True(t, rc.markAttachmentReady(secondLease))
 	resize := func(ac *attachedClient, tr ports.Transport, size domain.Size) {
 		token := sess.captureAttachmentCapability(ac, tr)
-		d.handleAttachmentClientFrame(token, ports.Frame{
+		d.handleAttachmentClientFrame(token, wire.Frame{
-			Type:    ports.MsgResize,
+			Type:    wire.MsgResize,
 			Payload: mustMarshalResize(protocol.Resize{Size: size}),
 		})
 	}

M internal/usecase/daemon/attachment_route_identity_test.go +5 -5

 	"testing"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 	closeTrackingTransport
 }
-func (t *committedIdentityErrorTransport) Send(frame ports.Frame) error {
+func (t *committedIdentityErrorTransport) Send(frame wire.Frame) error {
-	if frame.Type == ports.MsgCommittedRouteIdentity {
+	if frame.Type == wire.MsgCommittedRouteIdentity {
 		return errors.New("committed identity send failed")
 	}
 	return t.closeTrackingTransport.Send(frame)
 	var identity protocol.CommittedRouteIdentity
 	found := false
 	for _, frame := range transport.Sends() {
-		if frame.Type != ports.MsgCommittedRouteIdentity {
+		if frame.Type != wire.MsgCommittedRouteIdentity {
 			continue
 		}
 		var decodeErr error
-		identity, decodeErr = ports.UnmarshalCommittedRouteIdentity(frame.Payload)
+		identity, decodeErr = wire.UnmarshalCommittedRouteIdentity(frame.Payload)
 		require.NoError(t, decodeErr)
 		found = true
 	}

M internal/usecase/daemon/attention_test.go +2 -1

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/ui"
 	trW := portsmocks.NewMockTransport(t)
 	block := make(chan struct{})
 	t.Cleanup(func() { close(block) })
-	trW.EXPECT().Send(mock.Anything).RunAndReturn(func(ports.Frame) error {
+	trW.EXPECT().Send(mock.Anything).RunAndReturn(func(wire.Frame) error {
 		<-block
 		return nil
 	}).Maybe()

M internal/usecase/daemon/client.go +5 -4

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/mouse"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 // sendExpectedTransport writes only when expected is still the attachment's
 // current transport incarnation. It preserves sendMu -> linkMu lock ordering.
-func (ac *attachedClient) sendExpectedTransport(expected transportSnapshot, f ports.Frame) error {
+func (ac *attachedClient) sendExpectedTransport(expected transportSnapshot, f wire.Frame) error {
 	ac.sendMu.Lock()
 	defer ac.sendMu.Unlock()
 	if !ac.transportSnapshotCurrent(expected) {
 	return nil
 }
-func (ac *attachedClient) sendExpectedTransportForAttachment(expected transportSnapshot, f ports.Frame, ticket *attachmentEffect) error {
+func (ac *attachedClient) sendExpectedTransportForAttachment(expected transportSnapshot, f wire.Frame, ticket *attachmentEffect) error {
 	ac.sendMu.Lock()
 	defer ac.sendMu.Unlock()
 	// A attachment-bound send requires a live ticket, and reports every rejection,
 // detachNotifyTimeout, the transport is force-closed, failing the in-flight
 // write. Detach/kill/shutdown paths use this so they are never gated on a
 // client that has stopped draining its socket.
-func (d *Daemon) boundedSend(ac *attachedClient, f ports.Frame) {
+func (d *Daemon) boundedSend(ac *attachedClient, f wire.Frame) {
 	_ = d.boundedSendErr(ac, f)
 }
-func (d *Daemon) boundedSendErr(ac *attachedClient, f ports.Frame) error {
+func (d *Daemon) boundedSendErr(ac *attachedClient, f wire.Frame) error {
 	expected := ac.transportSnapshot()
 	if expected.transport == nil {
 		return errors.New("client transport is nil")

M internal/usecase/daemon/client_frame_routing.go +30 -29

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/command"
 )
 }
 // handleAttachmentClientFrame owns the attached-client protocol.
-func (d *Daemon) handleAttachmentClientFrame(capability attachmentCapability, f ports.Frame) bool {
+func (d *Daemon) handleAttachmentClientFrame(capability attachmentCapability, f wire.Frame) bool {
 	if !capability.current() {
 		return false
 	}
 		d.afterAttachmentEffectAdmitted(effect.capability())
 	}
 	switch f.Type {
-	case ports.MsgInput:
+	case wire.MsgInput:
-		if in, derr := ports.UnmarshalInput(f.Payload); derr == nil {
+		if in, derr := wire.UnmarshalInput(f.Payload); derr == nil {
 			d.handleSequencedInputForAttachment(effect, in.InputSeq, in.Data)
 		}
-	case ports.MsgResize:
+	case wire.MsgResize:
-		if rz, derr := ports.UnmarshalResize(f.Payload); derr == nil && effect.current() {
+		if rz, derr := wire.UnmarshalResize(f.Payload); derr == nil && effect.current() {
 			d.resizeAttachmentGeometryForLease(effect, rz.Geometry())
 		}
-	case ports.MsgTheme:
+	case wire.MsgTheme:
-		if th, derr := ports.UnmarshalTheme(f.Payload); derr == nil {
+		if th, derr := wire.UnmarshalTheme(f.Payload); derr == nil {
 			d.applyThemeForAttachment(effect, th)
 		}
-	case ports.MsgImagePush:
+	case wire.MsgImagePush:
-		if ip, derr := ports.UnmarshalImagePush(f.Payload); derr == nil {
+		if ip, derr := wire.UnmarshalImagePush(f.Payload); derr == nil {
 			d.handleSequencedImagePushForAttachment(effect, ip.InputSeq, ip)
 		}
-	case ports.MsgClientNotice:
+	case wire.MsgClientNotice:
-		if notice, derr := ports.UnmarshalClientNotice(f.Payload); derr == nil {
+		if notice, derr := wire.UnmarshalClientNotice(f.Payload); derr == nil {
 			d.handleClientNoticeForAttachment(effect, notice)
 		} else {
 			d.log.Warn("malformed client notice", "err", derr)
 		}
-	case ports.MsgDetach:
+	case wire.MsgDetach:
 		if effect.current() {
 			d.clientGoneForAttachment(effect, true)
 			return true
 		}
-	case ports.MsgAck:
+	case wire.MsgAck:
-		if ack, derr := ports.UnmarshalAck(f.Payload); derr == nil {
+		if ack, derr := wire.UnmarshalAck(f.Payload); derr == nil {
 			d.ackOutput(effect, ack.Epoch, ack.State)
 		}
-	case ports.MsgOutputResetRequest:
+	case wire.MsgOutputResetRequest:
-		if _, derr := ports.UnmarshalOutputResetRequest(f.Payload); derr == nil {
+		if _, derr := wire.UnmarshalOutputResetRequest(f.Payload); derr == nil {
 			d.resetOutput(effect)
 		}
-	case ports.MsgSamePeerSwitchRequest:
+	case wire.MsgSamePeerSwitchRequest:
-		request, derr := ports.UnmarshalSamePeerSwitchRequest(f.Payload)
+		request, derr := wire.UnmarshalSamePeerSwitchRequest(f.Payload)
 		if derr != nil {
 			d.log.Warn("malformed same-peer switch request", "err", derr)
 			break
 		}
 		d.switchSamePeerForAttachment(effect, request)
-	case ports.MsgParkedRouteRequest:
+	case wire.MsgParkedRouteRequest:
-		request, derr := ports.UnmarshalParkedRouteRequest(f.Payload)
+		request, derr := wire.UnmarshalParkedRouteRequest(f.Payload)
 		if derr != nil {
 			d.log.Warn("malformed parked-route request", "err", derr)
 			break
 		}
 		d.handleParkedRouteRequest(effect, request)
-	case ports.MsgRecentRouteSnapshot:
+	case wire.MsgRecentRouteSnapshot:
-		snapshot, derr := ports.UnmarshalRecentRouteSnapshot(f.Payload)
+		snapshot, derr := wire.UnmarshalRecentRouteSnapshot(f.Payload)
 		if derr != nil {
 			d.log.Warn("malformed recent route snapshot", "err", derr)
 			break
 		if err := d.sendCommittedRouteIdentityForAttachment(effect); err != nil {
 			d.detachOnAttachmentSendError(effect.capability(), effect.transport.transport)
 		}
-	case ports.MsgRouteAttentionSubscription:
+	case wire.MsgRouteAttentionSubscription:
-		subscription, derr := ports.UnmarshalRouteAttentionSubscription(f.Payload)
+		subscription, derr := wire.UnmarshalRouteAttentionSubscription(f.Payload)
 		if derr != nil {
 			d.log.Warn("malformed route attention subscription", "err", derr)
 			break
 		}
 		effect.ac.setRouteAttentionSubscription(subscription)
 		d.invalidateRender(effect.sess, effect.ac, false, "client_frame_routing.go:route-attention")
-	case ports.MsgRouteNavigationFailure:
+	case wire.MsgRouteNavigationFailure:
-		failure, derr := ports.UnmarshalRouteNavigationFailure(f.Payload)
+		failure, derr := wire.UnmarshalRouteNavigationFailure(f.Payload)
 		if derr != nil {
 			d.log.Warn("malformed route navigation failure", "err", derr)
 			break
 			message = "that recent route no longer exists"
 		}
 		d.notify(effect.sess, domain.NoticeWarn, domain.NoticeSessionUnavailable, message, nil)
-	case ports.MsgCommand:
+	case wire.MsgCommand:
-		request, derr := ports.UnmarshalCommandRequest(f.Payload)
+		request, derr := wire.UnmarshalCommandRequest(f.Payload)
 		if derr != nil {
 			return false
 		}
 			return true
 		}
 		resultEffect.End()
-	case ports.MsgPing:
+	case wire.MsgPing:
 		if err := effect.sendControl(framePong()); err != nil {
 			effect.End()
 			d.detachOnAttachmentSendError(effect.capability(), effect.transport.transport)

M internal/usecase/daemon/clipboard_test.go +14 -13

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 )
 	var clipboardOutput string
 	for range 3 {
-		f := awaitFrame(t, sends, ports.MsgOutput)
+		f := awaitFrame(t, sends, wire.MsgOutput)
-		out, err := ports.UnmarshalOutput(f.Payload)
+		out, err := wire.UnmarshalOutput(f.Payload)
 		require.NoError(t, err)
 		clipboardOutput = string(out.Data)
 		if strings.Contains(clipboardOutput, "\x1b]52;c;aGVsbG8=\x07") {
 	select {
 	case f := <-sends:
-		require.NotEqual(t, ports.MsgOutput, f.Type)
+		require.NotEqual(t, wire.MsgOutput, f.Type)
 	default:
 	}
 }
 	select {
 	case f := <-sends:
-		require.NotEqual(t, ports.MsgOutput, f.Type)
+		require.NotEqual(t, wire.MsgOutput, f.Type)
 	default:
 	}
 }
 	sends int
 }
-func (t *staleClipboardErrorTransport) Send(ports.Frame) error {
+func (t *staleClipboardErrorTransport) Send(wire.Frame) error {
 	t.mu.Lock()
 	t.sends++
 	t.mu.Unlock()
 	return errors.New("stale clipboard send")
 }
-func (*staleClipboardErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*staleClipboardErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*staleClipboardErrorTransport) Close() error               { return nil }
+func (*staleClipboardErrorTransport) Close() error              { return nil }
 func (t *staleClipboardErrorTransport) sendCount() int {
 	t.mu.Lock()
 	}
 }
-func (t *movingClipboardErrorTransport) Send(ports.Frame) error {
+func (t *movingClipboardErrorTransport) Send(wire.Frame) error {
 	t.startedOnce.Do(func() { close(t.started) })
 	<-t.release
 	return errors.New("clipboard send failed after pane move")
 }
-func (*movingClipboardErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*movingClipboardErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
 func (t *movingClipboardErrorTransport) Close() error {
 	t.closeOnce.Do(func() { close(t.closed) })
 	}
 }
-func (tr *blockingClipboardTransport) Send(f ports.Frame) error {
+func (tr *blockingClipboardTransport) Send(f wire.Frame) error {
-	out, err := ports.UnmarshalOutput(f.Payload)
+	out, err := wire.UnmarshalOutput(f.Payload)
 	if err != nil {
 		return err
 	}
 	return nil
 }
-func (tr *blockingClipboardTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (tr *blockingClipboardTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (tr *blockingClipboardTransport) Close() error               { return nil }
+func (tr *blockingClipboardTransport) Close() error              { return nil }

M internal/usecase/daemon/config_test.go +5 -5

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 )
 	defer release()
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
 	d.enterPalette(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte("new"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte{0x0e})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	model := ac.overlays.palette
 	cfg := domain.Defaults()
 	cfg.Palette = domain.PaletteConfig{Anchor: domain.AnchorTopLeft, AnchorSet: true}
 	d.ApplyConfig(cfg)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	defer ac.overlays.paletteMu.Unlock()

M internal/usecase/daemon/control.go +7 -6

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 // handleCommand serves one one-shot control request. The leading version is
 // checked before decoding the versioned body so newer layouts fail cleanly.
-func (d *Daemon) handleCommand(tr ports.Transport, f ports.Frame) error {
+func (d *Daemon) handleCommand(tr ports.Transport, f wire.Frame) error {
 	defer func() { _ = tr.Close() }()
-	if version, ok := ports.PeekCommandVersion(f.Payload); !ok || version != protocol.Version {
+	if version, ok := wire.PeekCommandVersion(f.Payload); !ok || version != protocol.Version {
 		return d.sendCommandResult(tr, protocol.CommandResult{Code: protocol.ErrVersionMismatch, Text: "protocol version mismatch"})
 	}
-	request, err := ports.UnmarshalCommandRequest(f.Payload)
+	request, err := wire.UnmarshalCommandRequest(f.Payload)
 	if err != nil {
 		return d.sendCommandResult(tr, protocol.CommandResult{Code: protocol.ErrInternal, Text: "malformed command request"})
 	}
 // boundedControlSend keeps one-shot control handlers from waiting forever on a
 // client that stopped reading. A timeout closes the exact transport so a
 // blocked Send can unwind before the handler returns.
-func (d *Daemon) boundedControlSend(tr ports.Transport, frame ports.Frame) error {
+func (d *Daemon) boundedControlSend(tr ports.Transport, frame wire.Frame) error {
 	_, err := d.boundedSendWith(tr, func() error { return tr.Send(frame) })
 	if errors.Is(err, errSendTimedOut) {
 		_ = tr.Close()
 	return err
 }
-func frameCommandResult(result protocol.CommandResult) ports.Frame {
+func frameCommandResult(result protocol.CommandResult) wire.Frame {
-	return ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(result)}
+	return wire.Frame{Type: wire.MsgCommandResult, Payload: wire.MarshalCommandResult(result)}
 }
 func (d *Daemon) dispatchCommand(ctx context.Context, request protocol.CommandRequest) protocol.CommandResult {

M internal/usecase/daemon/control_test.go +16 -15

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/stretchr/testify/require"
 func TestHandleCommandRejectsVersionBeforeDecodeOrDispatch(t *testing.T) {
 	// The version prefix is valid and mismatched, while the remainder is not a
 	// decodable request. The daemon must still return ErrVersionMismatch.
-	frame := ports.Frame{Type: ports.MsgCommand, Payload: []byte{0, byte(protocol.Version + 1)}}
+	frame := wire.Frame{Type: wire.MsgCommand, Payload: []byte{0, byte(protocol.Version + 1)}}
 	tr, sends, _ := newConn(t, frame)
 	d := newTestDaemon(t, nil, stubClock{})
 func TestHandleConnRoutesCommand(t *testing.T) {
 	d := newTestDaemon(t, nil, stubClock{})
 	request := protocol.CommandRequest{Version: protocol.Version, Slug: "list-sessions"}
-	payload, err := ports.MarshalCommandRequest(request)
+	payload, err := wire.MarshalCommandRequest(request)
 	require.NoError(t, err)
-	frame := ports.Frame{Type: ports.MsgCommand, Payload: payload}
+	frame := wire.Frame{Type: wire.MsgCommand, Payload: payload}
 	tr, sends, _ := newConn(t, frame)
 	d.handleConn(tr)
 		done <- struct{}{}
 	}()
 	close(start)
-	for _, sends := range []chan ports.Frame{leftSends, rightSends} {
+	for _, sends := range []chan wire.Frame{leftSends, rightSends} {
 		select {
 		case <-done:
 			result := awaitCommandResult(t, sends)
 	return sess
 }
-func commandFrame(t *testing.T, request protocol.CommandRequest) ports.Frame {
+func commandFrame(t *testing.T, request protocol.CommandRequest) wire.Frame {
 	t.Helper()
 	if request.Version == 0 {
 		request.Version = protocol.Version
 	}
-	payload, err := ports.MarshalCommandRequest(request)
+	payload, err := wire.MarshalCommandRequest(request)
 	require.NoError(t, err)
-	return ports.Frame{Type: ports.MsgCommand, Payload: payload}
+	return wire.Frame{Type: wire.MsgCommand, Payload: payload}
 }
 func sendCommand(t *testing.T, d *Daemon, request protocol.CommandRequest) protocol.CommandResult {
 	return awaitCommandResult(t, sends)
 }
-func awaitCommandResult(t *testing.T, sends chan ports.Frame) protocol.CommandResult {
+func awaitCommandResult(t *testing.T, sends chan wire.Frame) protocol.CommandResult {
 	t.Helper()
-	reply := awaitFrame(t, sends, ports.MsgCommandResult)
+	reply := awaitFrame(t, sends, wire.MsgCommandResult)
-	result, err := ports.UnmarshalCommandResult(reply.Payload)
+	result, err := wire.UnmarshalCommandResult(reply.Payload)
 	require.NoError(t, err)
 	return result
 }
 	return &blockingControlSendTransport{started: make(chan struct{}), closed: make(chan struct{})}
 }
-func (tr *blockingControlSendTransport) Send(ports.Frame) error {
+func (tr *blockingControlSendTransport) Send(wire.Frame) error {
 	tr.once.Do(func() { close(tr.started) })
 	<-tr.closed
 	return io.ErrClosedPipe
 }
-func (*blockingControlSendTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*blockingControlSendTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
 func (tr *blockingControlSendTransport) Close() error {
 	tr.once.Do(func() { close(tr.started) })
 	select {
 	closed bool
 }
-func (tr *commandSendErrorTransport) Send(ports.Frame) error  { return tr.err }
+func (tr *commandSendErrorTransport) Send(wire.Frame) error  { return tr.err }
-func (*commandSendErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*commandSendErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (tr *commandSendErrorTransport) Close() error            { tr.closed = true; return nil }
+func (tr *commandSendErrorTransport) Close() error           { tr.closed = true; return nil }
 func addControlSession(d *Daemon, name, tabID, paneID string) *session {
 	tb := newTabWithStableID(tabID, paneID, newQuietPTY(), domain.Size{Cols: 80, Rows: 22})

M internal/usecase/daemon/copymode_test.go +72 -71

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/ui"
 	replacement := &closeTrackingTransport{}
 	sendErr := errors.New("owned send failed")
 	ac := &attachedClient{output: newOutputStateStream()}
-	failed := &ownedSwapErrorTransport{ac: ac, replacement: replacement, err: sendErr, sent: make(chan ports.Frame, 1)}
+	failed := &ownedSwapErrorTransport{ac: ac, replacement: replacement, err: sendErr, sent: make(chan wire.Frame, 1)}
 	ac.replaceTransport(failed)
 	sess := &session{sessionCore: sessionCore{name: "work", attachments: map[*attachedClient]struct{}{ac: {}}}}
 	ac.setSession(sess)
 	require.ErrorIs(t, err, sendErr)
 	require.Same(t, failed, used)
 	require.Same(t, replacement, ac.transport())
-	out, decodeErr := ports.UnmarshalOutput((<-failed.sent).Payload)
+	out, decodeErr := wire.UnmarshalOutput((<-failed.sent).Payload)
 	require.NoError(t, decodeErr)
 	require.Equal(t, []byte("copy"), out.Data)
 	d.detachOnSendError(sess, ac, used)
 	err         error
 }
-func (t *swapErrorTransport) Send(ports.Frame) error {
+func (t *swapErrorTransport) Send(wire.Frame) error {
 	t.ac.replaceTransport(t.replacement)
 	return t.err
 }
-func (t *swapErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (t *swapErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (t *swapErrorTransport) Close() error               { return nil }
+func (t *swapErrorTransport) Close() error              { return nil }
 type ownedSwapErrorTransport struct {
 	ac          *attachedClient
 	replacement ports.Transport
 	err         error
-	sent        chan ports.Frame
+	sent        chan wire.Frame
 }
-func (t *ownedSwapErrorTransport) Send(f ports.Frame) error { return t.SendSynchronous(f) }
+func (t *ownedSwapErrorTransport) Send(f wire.Frame) error { return t.SendSynchronous(f) }
-func (t *ownedSwapErrorTransport) SendSynchronous(f ports.Frame) error {
+func (t *ownedSwapErrorTransport) SendSynchronous(f wire.Frame) error {
 	t.sent <- f
 	t.ac.replaceTransport(t.replacement)
 	return t.err
 }
-func (t *ownedSwapErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (t *ownedSwapErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (t *ownedSwapErrorTransport) Close() error               { return nil }
+func (t *ownedSwapErrorTransport) Close() error              { return nil }
 // stubClock returns timers whose channel never fires, so a scheduler under it
 // blocks in its debounce loop until the session context is cancelled. Used by
 	require.NotEqual(t, historyID, liveID)
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	doc := ac.overlays.copyDocument
 	require.Equal(t, 0, doc.FindRowID(historyID))
 	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("VIS\r"))
 	if ac.overlays.copyMode == nil {
 		t.Fatalf("scrollback binding forwarded to PTY: %q", got)
 	default:
 	}
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	if got := string(msg.Data); !strings.Contains(got, "[SCROLL]") || strings.Contains(got, "[SELECT]") || strings.Contains(got, "[COPY]") {
 		t.Fatalf("passive scrollback paint = %q, want [SCROLL] without [SELECT]/[COPY]", got)
 	}
 	d.handleInput(sess, ac, []byte(" "))
-	out = awaitFrame(t, sends, ports.MsgOutput)
+	out = awaitFrame(t, sends, wire.MsgOutput)
-	msg, err = ports.UnmarshalOutput(out.Payload)
+	msg, err = wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	if got := string(msg.Data); !strings.Contains(got, "[SELECT]") || strings.Contains(got, "[SCROLL]") {
 		t.Fatalf("visual selection paint = %q, want [SELECT] without [SCROLL]", got)
 	copy(pane.screen.Frame.Row(1), testRow("beta alpha"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("/alpha\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Nil(t, ac.overlays.copySearch)
 	require.NotNil(t, ac.overlays.copyMode)
 	copy(pane.screen.Frame.Row(2), testRow("gamma"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("/"))
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "Search")
 	require.NotNil(t, ac.overlays.copySearch)
 	d.handleInput(sess, ac, []byte("alpha"))
-	out = awaitFrame(t, sends, ports.MsgOutput)
+	out = awaitFrame(t, sends, wire.MsgOutput)
-	msg, err = ports.UnmarshalOutput(out.Payload)
+	msg, err = wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "/alpha")
 	require.Contains(t, string(msg.Data), "1:1  alpha")
 	require.Contains(t, string(msg.Data), "2:6  beta alpha")
 	d.handleInput(sess, ac, []byte("\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Nil(t, ac.overlays.copySearch)
 	require.Equal(t, 0, ac.overlays.copyMode.Cursor().Row)
 	d.handleInput(sess, ac, []byte("n"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, 1, ac.overlays.copyMode.Cursor().Row)
 	d.handleInput(sess, ac, []byte("N"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, 0, ac.overlays.copyMode.Cursor().Row)
 	select {
 	copy(pane.screen.Frame.Row(2), testRow("gamma"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("/"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("alpha"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.NotNil(t, ac.overlays.copySearch)
 	require.Equal(t, 0, ac.overlays.copyMode.Cursor().Row, "typing a query previews the selected first result behind the modal")
 	d.handleInput(sess, ac, []byte{0x0e})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.NotNil(t, ac.overlays.copySearch)
 	require.Equal(t, 1, ac.overlays.copyMode.Cursor().Row, "moving modal selection previews that result without Enter")
 }
 	copy(pane.screen.Frame.Row(0), testRow("live alpha"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("/alpha"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.NotNil(t, ac.overlays.copySearch)
 	cursor := ac.overlays.copyMode.Cursor().Row
 	require.Equal(t, cursor, ac.overlays.copyMode.Cursor().Row)
 	d.handleInput(sess, ac, []byte("\x1b"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Nil(t, ac.overlays.copySearch)
 	require.NotNil(t, ac.overlays.copyMode)
 	d.handleInput(sess, ac, []byte("q"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Nil(t, ac.overlays.copySearch)
 	require.Nil(t, ac.overlays.copyMode)
 }
 	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte{'g', ' ', 'j', 'y'})
 	select {
 		t.Fatalf("copy-mode navigation forwarded to PTY: %q", got)
 	default:
 	}
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	if got, want := string(msg.Data), "\x1b]52;c;b2xkMQpvbGQy\x07"; got != want {
 		t.Fatalf("OSC52 = %q, want %q", got, want)
 	if ac.overlays.copyMode != nil {
 		t.Fatal("copy mode still active after yank")
 	}
-	live := awaitFrame(t, sends, ports.MsgOutput)
+	live := awaitFrame(t, sends, wire.MsgOutput)
-	liveMsg, err := ports.UnmarshalOutput(live.Payload)
+	liveMsg, err := wire.UnmarshalOutput(live.Payload)
 	require.NoError(t, err)
 	if strings.Contains(string(liveMsg.Data), "[COPY]") || strings.Contains(string(liveMsg.Data), "[SCROLL]") {
 		t.Fatalf("live repaint still contains copy/scroll status: %q", string(liveMsg.Data))
 	}
 	d.paint(sess, ac, true, nil)
-	followup := awaitFrame(t, sends, ports.MsgOutput)
+	followup := awaitFrame(t, sends, wire.MsgOutput)
-	followupMsg, err := ports.UnmarshalOutput(followup.Payload)
+	followupMsg, err := wire.UnmarshalOutput(followup.Payload)
 	require.NoError(t, err)
 	if strings.Contains(string(followupMsg.Data), "copied 9 chars to clipboard") {
 		t.Fatalf("copy feedback persisted after next repaint: %q", string(followupMsg.Data))
 	}
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
 	advanceRender() // initial coordinator invalidation
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	for i := range 12 {
 		reads <- fmt.Appendf(nil, "line-%02d\r\n", i)
 	var payload string
 	require.Eventually(t, func() bool {
-		out := awaitFrame(t, sends, ports.MsgOutput)
+		out := awaitFrame(t, sends, wire.MsgOutput)
-		msg, err := ports.UnmarshalOutput(out.Payload)
+		msg, err := wire.UnmarshalOutput(out.Payload)
 		require.NoError(t, err)
 		payload = string(msg.Data)
 		return strings.HasPrefix(payload, "\x1b]52;c;")
 	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("q"))
 	if ac.overlays.copyMode != nil {
 		t.Fatal("copy mode still active after q")
 	}
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	if strings.Contains(string(msg.Data), "[COPY]") || !strings.Contains(string(msg.Data), "live") {
 		t.Fatalf("exit repaint = %q, want live full repaint without copy status", string(msg.Data))
 			sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 			d.enterCopyMode(sess, ac)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			for _, input := range tc.input {
 				d.handleInput(sess, ac, input)
 			}
 	copy(sess.tabs[0].focusedPane().screen.Frame.Row(0), testRow(longLine))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte{' ', 'y'})
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	if strings.Contains(string(msg.Data), "\x1b]52;") {
 		t.Fatalf("oversized yank emitted OSC52: %q", string(msg.Data))
 	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\x1b"))
 	timer := <-clk.timers
 	ac.overlays.copyMu.Lock()
 	sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\x1b"))
 	timer := <-clk.timers
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.copyMu.Lock()
 	require.Nil(t, ac.overlays.copyESC.timer)
 			sess.tabs[0].focusedPane().screen.Write([]byte("live"))
 			d.enterCopyMode(sess, ac)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			d.handleInput(sess, ac, tc.input)
 			if ac.overlays.copyMode != nil {
 				t.Fatal("copy mode still active after empty yank")
 			}
-			out := awaitFrame(t, sends, ports.MsgOutput)
+			out := awaitFrame(t, sends, wire.MsgOutput)
-			msg, err := ports.UnmarshalOutput(out.Payload)
+			msg, err := wire.UnmarshalOutput(out.Payload)
 			require.NoError(t, err)
 			if strings.Contains(string(msg.Data), "\x1b]52;") {
 				t.Fatalf("empty yank emitted OSC52 clipboard clear: %q", string(msg.Data))
 	pane := testAttachmentTab(sess).focusedPane()
 	pane.screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	pane.mu.Lock()
 	defer pane.mu.Unlock()
 			}
 			d.enterCopyMode(sess, ac)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			ac.overlays.copyMu.Lock()
 			captured := ac.overlays.copyPane
 			ac.overlays.copyMu.Unlock()
 			tb.mu.Unlock()
 			d.handleInput(sess, ac, []byte{'g', ' ', 'j', 'y'})
-			out := awaitFrame(t, sends, ports.MsgOutput)
+			out := awaitFrame(t, sends, wire.MsgOutput)
-			msg, err := ports.UnmarshalOutput(out.Payload)
+			msg, err := wire.UnmarshalOutput(out.Payload)
 			require.NoError(t, err)
 			wantOSC := "\x1b]52;c;" + base64.StdEncoding.EncodeToString([]byte(tc.wantText)) + "\x07"
 			require.Equal(t, wantOSC, string(msg.Data))
 	fp.mu.Unlock()
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, total-1, ac.overlays.copyMode.Cursor().Row)
 	d.copyWheel(sess, ac, -3)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, total-4, ac.overlays.copyMode.Cursor().Row)
 	d.copyWheel(sess, ac, 3)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Nil(t, ac.overlays.copyMode, "wheel down reaching the captured bottom exits copy mode")
 }
 	fp.screen.Write([]byte("live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.copyMu.Lock()
 	viewportTop := ac.overlays.copyMode.ViewportTop
 	ac.overlays.copyMu.Unlock()
 	// offset); clicking a row must select exactly that row.
 	press := fmt.Sprintf("\x1b[<0;%d;%dM", inner.X+3, inner.Y+3)
 	d.handleInput(sess, ac, []byte(press))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, viewportTop+1, ac.overlays.copyMode.Cursor().Row)
 	motion := fmt.Sprintf("\x1b[<32;%d;%dM", inner.X+3, inner.Y+4)
 	d.handleInput(sess, ac, []byte(motion))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	selection := ac.overlays.copyMode.Selection()
 	require.True(t, selection.Enabled)
 	require.Equal(t, viewportTop+1, selection.Anchor.Row)
 	fp.screen.Write([]byte("flt-live"))
 	d.enterCopyMode(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	tb.mu.Lock()
 	generation := tb.floating.generation
 	publishPaneOwner(fp, sess, tb, generation)
 	require.Same(t, pane, captured, "drag entry must capture the copy source pane")
 	d.handleInput(sess, ac, []byte("y"))
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	want := "\x1b]52;c;" + base64.StdEncoding.EncodeToString([]byte("alpha\nb")) + "\x07"
 	require.Equal(t, want, string(msg.Data))

M internal/usecase/daemon/daemon.go +14 -13

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 )
 	defer finishHandshake()
 	defer stopTransport()
-	var first ports.Frame
+	var first wire.Frame
 	err := boundedHandshakeOperation(handshakeCtx, tr, func() error {
 		var recvErr error
 		first, recvErr = tr.Recv()
 		return
 	}
 	switch first.Type {
-	case ports.MsgList:
+	case wire.MsgList:
 		stopTransport()
 		finishHandshake()
 		d.handleList(tr)
-	case ports.MsgCommand:
+	case wire.MsgCommand:
 		stopTransport()
 		finishHandshake()
 		if err := d.handleCommand(tr, first); err != nil {
 			d.log.Warn("command handler failed", "err", err)
 		}
-	case ports.MsgRemotePreviewRequest:
+	case wire.MsgRemotePreviewRequest:
 		stopTransport()
 		finishHandshake()
 		if err := d.handleRemotePreview(tr, first); err != nil {
 			d.log.Warn("remote preview handler failed", "err", err)
 		}
-	case ports.MsgKill:
+	case wire.MsgKill:
 		stopTransport()
 		finishHandshake()
 		d.handleKill(tr, first)
-	case ports.MsgHello:
+	case wire.MsgHello:
 		d.handleHelloWithContext(handshakeCtx, timedOut, stopTransport, finishHandshake, tr, first)
 	default:
 		d.log.Warn("hello rejected", "err", "expected hello", "type", first.Type)
 // handleKill terminates the requested live session or stopped named session,
 // or all sessions, and closes the control connection; the resulting EOF is the
 // client's success signal.
-func (d *Daemon) handleKill(tr ports.Transport, f ports.Frame) {
+func (d *Daemon) handleKill(tr ports.Transport, f wire.Frame) {
 	defer func() { _ = tr.Close() }()
-	k, err := ports.UnmarshalKill(f.Payload)
+	k, err := wire.UnmarshalKill(f.Payload)
 	if err != nil {
 		_ = d.boundedControlSend(tr, frameError(protocol.ErrInternal, "malformed kill request"))
 		return
 // handleHello runs the attach handshake for direct package callers. Accepted
 // connections use handleHelloWithContext so the deadline also covers the first
 // frame read in handleConn.
-func (d *Daemon) handleHello(tr ports.Transport, f ports.Frame) {
+func (d *Daemon) handleHello(tr ports.Transport, f wire.Frame) {
 	handshakeCtx, timedOut, finishHandshake := d.newHandshakeContext(context.Background())
 	stopTransport := watchHandshakeTransport(handshakeCtx, tr)
 	defer finishHandshake()
 // handleHelloWithContext runs the attach handshake: version check, intent
 // routing, Welcome, guaranteed first paint, then the per-connection input loop.
-func (d *Daemon) handleHelloWithContext(handshakeCtx context.Context, timedOut <-chan struct{}, stopHandshakeTransport, finishHandshake func(), tr ports.Transport, f ports.Frame) {
+func (d *Daemon) handleHelloWithContext(handshakeCtx context.Context, timedOut <-chan struct{}, stopHandshakeTransport, finishHandshake func(), tr ports.Transport, f wire.Frame) {
 	if err := handshakeContextError(context.Background(), timedOut, handshakeCtx.Err()); err != nil {
 		_ = tr.Close()
 		return
 	}
-	sendHandshake := func(frame ports.Frame) error {
+	sendHandshake := func(frame wire.Frame) error {
 		err := boundedHandshakeOperation(handshakeCtx, tr, func() error { return tr.Send(frame) })
 		if err != nil {
 			return handshakeContextError(context.Background(), timedOut, err)
 		}
 		return nil
 	}
-	h, err := ports.UnmarshalHello(f.Payload)
+	h, err := wire.UnmarshalHello(f.Payload)
 	if err != nil {
-		if version, ok := ports.PeekHelloVersion(f.Payload); ok && version != protocol.Version {
+		if version, ok := wire.PeekHelloVersion(f.Payload); ok && version != protocol.Version {
 			d.log.Warn("hello rejected", "err", "protocol version mismatch", "version", version, "expected", protocol.Version)
 			_ = sendHandshake(frameError(protocol.ErrVersionMismatch, "protocol version mismatch"))
 		} else {

M internal/usecase/daemon/daemon_test.go +36 -35

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 )
 // newConn scripts a MockTransport: Recv yields first then more (in order),
 // then blocks until the connection is released or Closed (returning io.EOF).
 // Every Send is captured on the returned channel.
-func newConn(t *testing.T, first ports.Frame, more ...ports.Frame) (*portsmocks.MockTransport, chan ports.Frame, func()) {
+func newConn(t *testing.T, first wire.Frame, more ...wire.Frame) (*portsmocks.MockTransport, chan wire.Frame, func()) {
 	t.Helper()
 	tr := portsmocks.NewMockTransport(t)
-	sends := make(chan ports.Frame, 64)
+	sends := make(chan wire.Frame, 64)
-	recvCh := make(chan ports.Frame, 1+len(more))
+	recvCh := make(chan wire.Frame, 1+len(more))
 	recvCh <- first
 	for _, f := range more {
 		recvCh <- f
 	var once sync.Once
 	closeDone := func() { once.Do(func() { close(done) }) }
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case f := <-recvCh:
 			return f, nil
 		case <-done:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
-	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f wire.Frame) error {
 		sends <- f
 		return nil
 	}).Maybe()
 	return tr, sends, closeDone
 }
-func mustHello(intent uint8, name string, sz domain.Size) ports.Frame {
+func mustHello(intent uint8, name string, sz domain.Size) wire.Frame {
-	return ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
+	return wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(protocol.Hello{
 		Version: protocol.Version, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color",
 	})}
 }
-func frameInput(data []byte) ports.Frame {
+func frameInput(data []byte) wire.Frame {
-	return ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: data})}
+	return wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: data})}
 }
 func screenLineText(s *vt.Screen, y int) string {
 }
 // awaitFrame waits for the next frame of type typ on ch, failing on timeout.
-func awaitFrame(t *testing.T, ch chan ports.Frame, typ ports.MsgType) ports.Frame {
+func awaitFrame(t *testing.T, ch chan wire.Frame, typ wire.MsgType) wire.Frame {
 	t.Helper()
 	deadline := time.After(2 * time.Second)
 	for {
 func listSessions(t *testing.T, d *Daemon) protocol.Sessions {
 	t.Helper()
-	tr, sends, _ := newConn(t, ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})})
+	tr, sends, _ := newConn(t, wire.Frame{Type: wire.MsgList, Payload: wire.MarshalList(protocol.List{})})
 	d.handleList(tr)
-	f := awaitFrame(t, sends, ports.MsgSessions)
+	f := awaitFrame(t, sends, wire.MsgSessions)
-	sessions, err := ports.UnmarshalSessions(f.Payload)
+	sessions, err := wire.UnmarshalSessions(f.Payload)
 	require.NoError(t, err)
 	return sessions
 }
 // transport mock while channels make both sides of the wire deterministic.
 type welcomeBlockingTransport struct {
 	tr             *portsmocks.MockTransport
-	sends          chan ports.Frame
+	sends          chan wire.Frame
 	welcomeEntered chan struct{}
 	releaseWelcome chan struct{}
 	recvDone       chan struct{}
 func newWelcomeBlockingTransport(t *testing.T) *welcomeBlockingTransport {
 	t.Helper()
 	b := &welcomeBlockingTransport{
-		sends:          make(chan ports.Frame, 8),
+		sends:          make(chan wire.Frame, 8),
 		welcomeEntered: make(chan struct{}),
 		releaseWelcome: make(chan struct{}),
 		recvDone:       make(chan struct{}),
 	}
 	b.tr = portsmocks.NewMockTransport(t)
-	b.tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f ports.Frame) error {
+	b.tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f wire.Frame) error {
 		b.sends <- f
-		if f.Type == ports.MsgWelcome {
+		if f.Type == wire.MsgWelcome {
 			close(b.welcomeEntered)
 			<-b.releaseWelcome
 		}
 		return nil
 	}).Maybe()
-	b.tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	b.tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		<-b.recvDone
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}).Maybe()
 	b.tr.EXPECT().Close().Return(nil).Maybe()
 	t.Cleanup(b.finish)
 	b.closeOnce.Do(func() { close(b.recvDone) })
 }
-func newCapturingTransport(t testing.TB) (*portsmocks.MockTransport, chan ports.Frame) {
+func newCapturingTransport(t testing.TB) (*portsmocks.MockTransport, chan wire.Frame) {
 	t.Helper()
 	tr := portsmocks.NewMockTransport(t)
-	sends := make(chan ports.Frame, 64)
+	sends := make(chan wire.Frame, 64)
-	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f wire.Frame) error {
 		sends <- f
 		return nil
 	}).Maybe()
 	return tr, sends
 }
-func newManualSessionWithPTYs(t testing.TB, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan ports.Frame) {
+func newManualSessionWithPTYs(t testing.TB, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	return newManualSessionWithPTYsClock(t, stubClock{}, ptys...)
 }
-func newManualSessionWithPTYsClock(t testing.TB, clock ports.Clock, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan ports.Frame) {
+func newManualSessionWithPTYsClock(t testing.TB, clock ports.Clock, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	return newManualSessionWithPTYsClockCleanup(t, clock, true, ptys...)
 }
-func newManualSessionWithPTYsCleanup(t testing.TB, registerCleanup bool, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan ports.Frame) {
+func newManualSessionWithPTYsCleanup(t testing.TB, registerCleanup bool, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	return newManualSessionWithPTYsClockCleanup(t, stubClock{}, registerCleanup, ptys...)
 }
-func newManualSessionWithPTYsClockCleanup(t testing.TB, clock ports.Clock, registerCleanup bool, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan ports.Frame) {
+func newManualSessionWithPTYsClockCleanup(t testing.TB, clock ports.Clock, registerCleanup bool, ptys ...ports.PTY) (*Daemon, *session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	d := newTestDaemonWithCleanup(t, nil, clock, registerCleanup)
 	tr, sends := newCapturingTransport(t)
 	return d, sess, ac, sends
 }
-func newManualTabSession(t *testing.T, n int) (*Daemon, *session, *attachedClient, chan ports.Frame, []func()) {
+func newManualTabSession(t *testing.T, n int) (*Daemon, *session, *attachedClient, chan wire.Frame, []func()) {
 	t.Helper()
 	ptys := make([]ports.PTY, 0, n)
 	releases := make([]func(), 0, n)
 	awaitTestCompletion(t, tr.welcomeEntered, "timed out waiting for Welcome send")
 	handshakeTimer := awaitHandshakeTimer(t, clock)
-	welcome := awaitFrame(t, tr.sends, ports.MsgWelcome)
+	welcome := awaitFrame(t, tr.sends, wire.MsgWelcome)
-	require.Equal(t, ports.MsgWelcome, welcome.Type)
+	require.Equal(t, wire.MsgWelcome, welcome.Type)
 	sess := firstSession(d)
 	sess.mu.Lock()
 	ac := sess.snapshotAttachmentsLocked()[0]
 	requireNoCoordinatorOutputFrame(t, tr.sends)
 	tr.release()
-	output := awaitFrame(t, tr.sends, ports.MsgOutput)
+	output := awaitFrame(t, tr.sends, wire.MsgOutput)
-	first, err := ports.UnmarshalOutput(output.Payload)
+	first, err := wire.UnmarshalOutput(output.Payload)
 	require.NoError(t, err)
 	require.Zero(t, first.Base, "the first post-Welcome frame is full")
 	tr.finish()
 // MsgDetached send until the transport is closed (mirroring a full kernel
 // send buffer: only Close fails the in-flight write). Serve must still tear
-func mustOutputData(t *testing.T, sends chan ports.Frame) []byte {
+func mustOutputData(t *testing.T, sends chan wire.Frame) []byte {
 	t.Helper()
-	f := awaitFrame(t, sends, ports.MsgOutput)
+	f := awaitFrame(t, sends, wire.MsgOutput)
-	out, err := ports.UnmarshalOutput(f.Payload)
+	out, err := wire.UnmarshalOutput(f.Payload)
 	require.NoError(t, err)
 	return out.Data
 }

M internal/usecase/daemon/final_acceptance_test.go +4 -4

 	vt "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/stretchr/testify/require"
 )
 	firstEpoch := first.output.currentEpoch()
 	secondEpoch := second.output.currentEpoch()
-	d.handleAttachmentClientFrame(secondToken, ports.Frame{
+	d.handleAttachmentClientFrame(secondToken, wire.Frame{
-		Type:    ports.MsgOutputResetRequest,
+		Type:    wire.MsgOutputResetRequest,
-		Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{}),
+		Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{}),
 	})
 	require.Greater(t, second.output.currentEpoch(), secondEpoch)
 	require.Equal(t, firstEpoch, first.output.currentEpoch(), "peer output reset crossed attachment boundary")

M internal/usecase/daemon/floating_test.go +6 -5

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 }
 func TestFloatingEOFRepaintsVisibleSlotOnly(t *testing.T) {
-	newCase := func(t *testing.T, state floatingState) (*Daemon, *session, *attachedClient, chan ports.Frame, *tab, *pane, func()) {
+	newCase := func(t *testing.T, state floatingState) (*Daemon, *session, *attachedClient, chan wire.Frame, *tab, *pane, func()) {
 		t.Helper()
 		normalPTY, releaseNormal := newBlockingPTY(t)
 		d, sess, ac, sends := newManualSessionWithPTYs(t, normalPTY)
 		// Establish a renderer shadow first. The EOF repaint must reset it and
 		// redraw the underlying cell rather than depending on popup damage.
 		d.paint(sess, ac, true, nil)
-		baseline := awaitFrame(t, sends, ports.MsgOutput)
+		baseline := awaitFrame(t, sends, wire.MsgOutput)
-		baselineOutput, err := ports.UnmarshalOutput(baseline.Payload)
+		baselineOutput, err := wire.UnmarshalOutput(baseline.Payload)
 		require.NoError(t, err)
 		require.Contains(t, string(baselineOutput.Data), "underlying-cell")
 		require.Equal(t, floatingUninitialized, tb.floating.state)
 		require.Nil(t, tb.floating.pane)
 		tb.mu.Unlock()
-		repaint := awaitFrame(t, sends, ports.MsgOutput)
+		repaint := awaitFrame(t, sends, wire.MsgOutput)
-		output, err := ports.UnmarshalOutput(repaint.Payload)
+		output, err := wire.UnmarshalOutput(repaint.Payload)
 		require.NoError(t, err)
 		require.Zero(t, output.Base, "visible EOF must force a dependency-free full repaint")
 		require.Contains(t, string(output.Data), "underlying-cell", "repaint must restore cells previously covered by the popup")

M internal/usecase/daemon/graphics_output_test.go +12 -11

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/stretchr/testify/require"
 )
 	started     chan struct{}
 	release     chan struct{}
 	finished    chan struct{}
-	sends       chan ports.Frame
+	sends       chan wire.Frame
 	startedOnce sync.Once
 	finishOnce  sync.Once
 }
 		started:  make(chan struct{}),
 		release:  make(chan struct{}),
 		finished: make(chan struct{}),
-		sends:    make(chan ports.Frame, 1),
+		sends:    make(chan wire.Frame, 1),
 	}
 }
-func (t *lateGraphicsCleanupTransport) Send(frame ports.Frame) error {
+func (t *lateGraphicsCleanupTransport) Send(frame wire.Frame) error {
 	t.startedOnce.Do(func() { close(t.started) })
 	<-t.release
 	t.sends <- frame
 	return nil
 }
-func (*lateGraphicsCleanupTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*lateGraphicsCleanupTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*lateGraphicsCleanupTransport) Close() error               { return nil }
+func (*lateGraphicsCleanupTransport) Close() error              { return nil }
 func TestGraphicsOutputReplaysStaticKittenIcatFixture(t *testing.T) {
 	state := newGraphicsOutputState()
 	pane.screen.Write(fixture)
 	d.paint(sess, ac, true, nil)
-	frame := awaitFrame(t, sends, ports.MsgOutput)
+	frame := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(output.Data), "\x1b_Ga=t,i=")
 	require.Contains(t, string(output.Data), ",f=100")
 	require.False(t, ac.output.graphicsUnsupportedWarned.Load(), "replacement terminal must receive its own unsupported-graphics warning")
 	d.paint(sess, ac, true, nil)
-	frame := awaitFrame(t, sends, ports.MsgOutput)
+	frame := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	require.Positive(t, output.New)
 	require.NotContains(t, string(output.Data), "\x1b_Ga=d,d=A", "vev must never globally delete terminal images")
 	require.Nil(t, ac.output.graphicsOutput)
 	sends := transport.Sends()
 	require.Len(t, sends, 1)
-	cleanup, err := ports.UnmarshalOutput(sends[0].Payload)
+	cleanup, err := wire.UnmarshalOutput(sends[0].Payload)
 	require.NoError(t, err)
 	require.Zero(t, cleanup.New, "graphics cleanup is an unacknowledged side-effect frame")
 	close(transport.release)
 	staleFrame := awaitTestValue(t, transport.sends, "late stale cleanup did not execute")
 	awaitTestCompletion(t, transport.finished, "late stale cleanup did not return")
-	staleOutput, err := ports.UnmarshalOutput(staleFrame.Payload)
+	staleOutput, err := wire.UnmarshalOutput(staleFrame.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(staleOutput.Data), "i="+strconv.FormatUint(oldID, 10))
 	require.NotContains(t, string(staleOutput.Data), "i="+strconv.FormatUint(newID, 10), "late cleanup must never target the fresh attachment")

M internal/usecase/daemon/handshake_test.go +6 -6

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type handshakeBlockingTransport struct {
 	}
 }
-func (t *handshakeBlockingTransport) Send(frame ports.Frame) error {
+func (t *handshakeBlockingTransport) Send(frame wire.Frame) error {
-	if t.blockWelcome && frame.Type == ports.MsgWelcome {
+	if t.blockWelcome && frame.Type == wire.MsgWelcome {
 		close(t.welcome)
 		<-t.closed
 		return io.ErrClosedPipe
 	return nil
 }
-func (t *handshakeBlockingTransport) Recv() (ports.Frame, error) {
+func (t *handshakeBlockingTransport) Recv() (wire.Frame, error) {
 	<-t.closed
-	return ports.Frame{}, io.ErrClosedPipe
+	return wire.Frame{}, io.ErrClosedPipe
 }
 func (t *handshakeBlockingTransport) Close() error {
 	resumeTransport := newHandshakeBlockingTransport(true)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(resumeTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, sess.name, token))})
+		d.handleHello(resumeTransport, wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(helloResumeCapable(protocol.IntentResume, sess.name, token))})
 		close(done)
 	}()

M internal/usecase/daemon/input_test.go +29 -29

 	vt "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 	source.screen.Write([]byte("source"))
 	source.mu.Unlock()
 	d.paint(sess, ac, true, nil)
-	first := awaitFrame(t, sends, ports.MsgOutput)
+	first := awaitFrame(t, sends, wire.MsgOutput)
-	firstOutput, err := ports.UnmarshalOutput(first.Payload)
+	firstOutput, err := wire.UnmarshalOutput(first.Payload)
 	require.NoError(t, err)
 	terminal := vt.NewScreen(ac.size.Cols, ac.size.Rows)
 	terminal.Write(firstOutput.Data)
 	daemonKeyHandler{d: d, ac: ac}.Action(keys.ActionSwitchTab2, nil)
 	require.Equal(t, 1, testAttachmentTabIndex(sess))
-	second := awaitFrame(t, sends, ports.MsgOutput)
+	second := awaitFrame(t, sends, wire.MsgOutput)
-	secondOutput, err := ports.UnmarshalOutput(second.Payload)
+	secondOutput, err := wire.UnmarshalOutput(second.Payload)
 	require.NoError(t, err)
 	require.Zero(t, secondOutput.Base, "tab switch must emit the complete target frame first")
 	terminal.Write(secondOutput.Data)
 	// Establish the client shadow while the retained popup is hidden.
 	d.paint(sess, ac, true, nil)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	// Route the real Alt+F binding. Showing a retained pane must paint once.
 	d.handleInput(sess, ac, []byte("\x1bf"))
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	require.Contains(t, strings.Join(frameRows(client.Frame), "\n"), "popup-content")
 	require.Contains(t, strings.Join(frameRows(client.Frame), "\n"), "┌")
 	select {
 	// The second real key must repaint immediately, rather than waiting for
 	// unrelated output, while retaining the existing PTY and context.
 	d.handleInput(sess, ac, []byte("\x1bf"))
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	require.NotContains(t, strings.Join(frameRows(client.Frame), "\n"), "popup-content")
 	tb := testAttachmentTab(sess)
 	tb.mu.Lock()
 	// A third show uses the installed pane; it must not launch or emit a second
 	// resize/start frame.
 	d.handleInput(sess, ac, []byte("\x1bf"))
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	require.Contains(t, strings.Join(frameRows(client.Frame), "\n"), "popup-content")
 	tb.mu.Lock()
 	require.Equal(t, floatingVisible, tb.floating.state)
 func TestOverlayInputPrecedence(t *testing.T) {
 	cases := []struct {
 		name  string
-		setup func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan ports.Frame)
+		setup func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan wire.Frame)
 		input []byte
 		check func(t *testing.T, ac *attachedClient, writes chan []byte)
 	}{
 		{
 			name: "prompt before palette picker copy and normal",
-			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan ports.Frame) {
+			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan wire.Frame) {
 				t.Helper()
 				d.enterCopyMode(sess, ac)
 				d.enterPicker(sess, ac)
 		},
 		{
 			name: "palette before picker copy and normal",
-			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan ports.Frame) {
+			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan wire.Frame) {
 				t.Helper()
 				d.enterCopyMode(sess, ac)
 				d.enterPicker(sess, ac)
 		},
 		{
 			name: "picker before copy and normal",
-			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan ports.Frame) {
+			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan wire.Frame) {
 				t.Helper()
 				d.enterCopyMode(sess, ac)
 				d.enterPicker(sess, ac)
 		},
 		{
 			name: "copy before normal",
-			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan ports.Frame) {
+			setup: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, sends chan wire.Frame) {
 				t.Helper()
 				d.enterCopyMode(sess, ac)
 			},
 	})
 	require.NoError(t, d.backSessionForAttachment(effect))
-	frame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
+	frame := awaitFrame(t, sends, wire.MsgNavigateRecentRoute)
-	action, err := ports.UnmarshalRouteNavigationAction(frame.Payload)
+	action, err := wire.UnmarshalRouteNavigationAction(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 3, Key: 2, Generation: 2}, action)
 }
 	require.Equal(t, uint64(0), ac.routeSnapshotCopy().Generation, "route ownership starts in the client")
 }
-func newRecentNavigationTestSessions(t *testing.T) (*Daemon, *session, *attachedClient, chan ports.Frame, []func()) {
+func newRecentNavigationTestSessions(t *testing.T) (*Daemon, *session, *attachedClient, chan wire.Frame, []func()) {
 	t.Helper()
 	p1, release1 := newBlockingPTY(t)
 	p2, release2 := newBlockingPTY(t)
 	d.handleInput(sess, ac, []byte("DET\r"))
 	require.Empty(t, sess.snapshotAttachments())
-	f := awaitFrame(t, sends, ports.MsgDetached)
+	f := awaitFrame(t, sends, wire.MsgDetached)
-	det, err := ports.UnmarshalDetached(f.Payload)
+	det, err := wire.UnmarshalDetached(f.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ReasonDetach, det.Reason)
 }
 	sess.name = "0"
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("RNS\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.True(t, ac.overlays.promptActive())
 	d.handleInput(sess, ac, []byte("\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.False(t, ac.overlays.promptActive())
 	require.False(t, sess.ephemeral)
 	selectTestAttachmentTab(sess, 1)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("RNT\r"))
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
 	require.True(t, ac.overlays.promptActive())
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "> 2")
 	d.handleInput(sess, ac, []byte("\x7flogs\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.False(t, ac.overlays.promptActive())
 	require.Equal(t, "logs", sess.tabs[1].name)
 	d.handleInput(sess, ac, []byte("y"))
 	var msg protocol.Output
 	require.Eventually(t, func() bool {
-		frame := awaitFrame(t, sends, ports.MsgOutput)
+		frame := awaitFrame(t, sends, wire.MsgOutput)
 		var err error
-		msg, err = ports.UnmarshalOutput(frame.Payload)
+		msg, err = wire.UnmarshalOutput(frame.Payload)
 		return err == nil && string(msg.Data) == string(scopy.OSC52("lph")[0])
 	}, 2*time.Second, 5*time.Millisecond)
 	require.Equal(t, scopy.OSC52("lph")[0], msg.Data)
 	d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Message: "m", Time: time.Unix(1, 0)})
 	d.enterNotices(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.True(t, ac.overlays.noticesActive())
 	// Same coordinates that TestMouseHitTestFocusesPaneAndTranslatesSGRColumns

M internal/usecase/daemon/notice_render_test.go +7 -7


@@ -9,24 +9,24 @@ import (
9			9
10		vt "github.com/bnema/vev-vt"	10		vt "github.com/bnema/vev-vt"
11		"github.com/bnema/vev/internal/domain"	11		"github.com/bnema/vev/internal/domain"
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol/wire"
13		)	13		)
14			14
15		// replayOutputFrames decodes and writes each MsgOutput frame's terminal bytes	15		// replayOutputFrames decodes and writes each MsgOutput frame's terminal bytes
16		// into screen, growing its shadow the same way a real client would.	16		// into screen, growing its shadow the same way a real client would.
17	-	func replayOutputFrames(t testing.T, screen vt.Screen, frames []ports.Frame) {	17	+	func replayOutputFrames(t testing.T, screen vt.Screen, frames []wire.Frame) {
18		t.Helper()	18		t.Helper()
19		for _, f := range frames {	19		for _, f := range frames {
20	-	require.Equal(t, ports.MsgOutput, f.Type)	20	+	require.Equal(t, wire.MsgOutput, f.Type)
21	-	out, err := ports.UnmarshalOutput(f.Payload)	21	+	out, err := wire.UnmarshalOutput(f.Payload)
22		require.NoError(t, err)	22		require.NoError(t, err)
23		screen.Write(out.Data)	23		screen.Write(out.Data)
24		}	24		}
25		}	25		}
26			26
27		// drainAllFrames collects every frame already queued on sends without blocking.	27		// drainAllFrames collects every frame already queued on sends without blocking.
28	-	func drainAllFrames(sends chan ports.Frame) []ports.Frame {	28	+	func drainAllFrames(sends chan wire.Frame) []wire.Frame {
29	-	var out []ports.Frame	29	+	var out []wire.Frame
30		for {	30		for {
31		select {	31		select {
32		case f := <-sends:	32		case f := <-sends:

@@ -96,7 +96,7 @@ func TestPaintComposesNoticeToastTopRightAndExpiresOnTTL(t *testing.T) {
96		awaitToastCount(t, ac, 0)	96		awaitToastCount(t, ac, 0)
97		select {	97		select {
98		case f := <-sends:	98		case f := <-sends:
99	-	replayOutputFrames(t, screen, append([]ports.Frame{f}, drainAllFrames(sends)...))	99	+	replayOutputFrames(t, screen, append([]wire.Frame{f}, drainAllFrames(sends)...))
100		case <-time.After(2 * time.Second):	100		case <-time.After(2 * time.Second):
101		t.Fatal("expiry did not invalidate the render")	101		t.Fatal("expiry did not invalidate the render")
102		}	102		}

M internal/usecase/daemon/notices_overlay_test.go +31 -31


@@ -11,7 +11,7 @@ import (
11			11
12		renderer "github.com/bnema/vev-vt"	12		renderer "github.com/bnema/vev-vt"
13		"github.com/bnema/vev/internal/domain"	13		"github.com/bnema/vev/internal/domain"
14	-	"github.com/bnema/vev/internal/ports"	14	+	"github.com/bnema/vev/internal/protocol/wire"
15		"github.com/bnema/vev/internal/usecase/notices"	15		"github.com/bnema/vev/internal/usecase/notices"
16		themeui "github.com/bnema/vev/internal/usecase/theme"	16		themeui "github.com/bnema/vev/internal/usecase/theme"
17		)	17		)

@@ -47,13 +47,13 @@ func TestNoticesOpenViaPaletteCommandShowsModalWithHistory(t *testing.T) {
47		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Severity: domain.NoticeError, Message: "couldn't open pane", Time: time.Unix(1, 0)})	47		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Severity: domain.NoticeError, Message: "couldn't open pane", Time: time.Unix(1, 0)})
48			48
49		d.enterPalette(sess, ac)	49		d.enterPalette(sess, ac)
50	-	awaitFrame(t, sends, ports.MsgOutput)	50	+	awaitFrame(t, sends, wire.MsgOutput)
51		d.handlePaletteInput(ac, []byte("NTC\r"))	51		d.handlePaletteInput(ac, []byte("NTC\r"))
52	-	out := awaitFrame(t, sends, ports.MsgOutput)	52	+	out := awaitFrame(t, sends, wire.MsgOutput)
53			53
54		require.False(t, ac.overlays.paletteActive())	54		require.False(t, ac.overlays.paletteActive())
55		require.NotNil(t, ac.overlays.noticesOverlay)	55		require.NotNil(t, ac.overlays.noticesOverlay)
56	-	msg, err := ports.UnmarshalOutput(out.Payload)	56	+	msg, err := wire.UnmarshalOutput(out.Payload)
57		require.NoError(t, err)	57		require.NoError(t, err)
58		require.Contains(t, string(msg.Data), "Notifications")	58		require.Contains(t, string(msg.Data), "Notifications")
59		require.Contains(t, string(msg.Data), "pane-spawn")	59		require.Contains(t, string(msg.Data), "pane-spawn")

@@ -69,32 +69,32 @@ func TestNoticesJKNavigatesSelection(t *testing.T) {
69		d.notices.record(domain.Notification{Code: domain.NoticeInternal, Message: "third", Time: time.Unix(3, 0)})	69		d.notices.record(domain.Notification{Code: domain.NoticeInternal, Message: "third", Time: time.Unix(3, 0)})
70			70
71		d.enterNotices(sess, ac)	71		d.enterNotices(sess, ac)
72	-	awaitFrame(t, sends, ports.MsgOutput)	72	+	awaitFrame(t, sends, wire.MsgOutput)
73		selected, ok := ac.overlays.noticesOverlay.Selected()	73		selected, ok := ac.overlays.noticesOverlay.Selected()
74		require.True(t, ok)	74		require.True(t, ok)
75		require.Equal(t, "third", selected.Message)	75		require.Equal(t, "third", selected.Message)
76			76
77		d.handleInput(sess, ac, []byte("j"))	77		d.handleInput(sess, ac, []byte("j"))
78	-	awaitFrame(t, sends, ports.MsgOutput)	78	+	awaitFrame(t, sends, wire.MsgOutput)
79		selected, ok = ac.overlays.noticesOverlay.Selected()	79		selected, ok = ac.overlays.noticesOverlay.Selected()
80		require.True(t, ok)	80		require.True(t, ok)
81		require.Equal(t, "second", selected.Message)	81		require.Equal(t, "second", selected.Message)
82			82
83		d.handleInput(sess, ac, []byte("j"))	83		d.handleInput(sess, ac, []byte("j"))
84	-	awaitFrame(t, sends, ports.MsgOutput)	84	+	awaitFrame(t, sends, wire.MsgOutput)
85		selected, ok = ac.overlays.noticesOverlay.Selected()	85		selected, ok = ac.overlays.noticesOverlay.Selected()
86		require.True(t, ok)	86		require.True(t, ok)
87		require.Equal(t, "first", selected.Message)	87		require.Equal(t, "first", selected.Message)
88			88
89		// One more 'j' at the bottom must clamp rather than wrap.	89		// One more 'j' at the bottom must clamp rather than wrap.
90		d.handleInput(sess, ac, []byte("j"))	90		d.handleInput(sess, ac, []byte("j"))
91	-	awaitFrame(t, sends, ports.MsgOutput)	91	+	awaitFrame(t, sends, wire.MsgOutput)
92		selected, ok = ac.overlays.noticesOverlay.Selected()	92		selected, ok = ac.overlays.noticesOverlay.Selected()
93		require.True(t, ok)	93		require.True(t, ok)
94		require.Equal(t, "first", selected.Message)	94		require.Equal(t, "first", selected.Message)
95			95
96		d.handleInput(sess, ac, []byte("k"))	96		d.handleInput(sess, ac, []byte("k"))
97	-	awaitFrame(t, sends, ports.MsgOutput)	97	+	awaitFrame(t, sends, wire.MsgOutput)
98		selected, ok = ac.overlays.noticesOverlay.Selected()	98		selected, ok = ac.overlays.noticesOverlay.Selected()
99		require.True(t, ok)	99		require.True(t, ok)
100		require.Equal(t, "second", selected.Message)	100		require.Equal(t, "second", selected.Message)

@@ -109,11 +109,11 @@ func TestNoticesQAndCtrlCCloseImmediatelyAndClearState(t *testing.T) {
109		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Message: "m", Time: time.Unix(1, 0)})	109		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Message: "m", Time: time.Unix(1, 0)})
110			110
111		d.enterNotices(sess, ac)	111		d.enterNotices(sess, ac)
112	-	awaitFrame(t, sends, ports.MsgOutput)	112	+	awaitFrame(t, sends, wire.MsgOutput)
113		require.True(t, ac.overlays.noticesActive())	113		require.True(t, ac.overlays.noticesActive())
114			114
115		d.handleInput(sess, ac, []byte{key})	115		d.handleInput(sess, ac, []byte{key})
116	-	awaitFrame(t, sends, ports.MsgOutput)	116	+	awaitFrame(t, sends, wire.MsgOutput)
117			117
118		require.False(t, ac.overlays.noticesActive())	118		require.False(t, ac.overlays.noticesActive())
119		require.Nil(t, ac.overlays.noticesOverlay)	119		require.Nil(t, ac.overlays.noticesOverlay)

@@ -128,7 +128,7 @@ func TestNoticesLoneEscapeClosesAfterDelay(t *testing.T) {
128		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Message: "m", Time: time.Unix(1, 0)})	128		d.notices.record(domain.Notification{Code: domain.NoticePaneSpawn, Message: "m", Time: time.Unix(1, 0)})
129			129
130		d.enterNotices(sess, ac)	130		d.enterNotices(sess, ac)
131	-	awaitFrame(t, sends, ports.MsgOutput)	131	+	awaitFrame(t, sends, wire.MsgOutput)
132			132
133		clk := &signalClock{timers: make(chan *signalTimer, 1)}	133		clk := &signalClock{timers: make(chan *signalTimer, 1)}
134		d.clock = clk	134		d.clock = clk

@@ -138,7 +138,7 @@ func TestNoticesLoneEscapeClosesAfterDelay(t *testing.T) {
138			138
139		timer.ch <- time.Now()	139		timer.ch <- time.Now()
140		require.Eventually(t, func() bool { return !ac.overlays.noticesActive() }, time.Second, 5*time.Millisecond)	140		require.Eventually(t, func() bool { return !ac.overlays.noticesActive() }, time.Second, 5*time.Millisecond)
141	-	awaitFrame(t, sends, ports.MsgOutput)	141	+	awaitFrame(t, sends, wire.MsgOutput)
142		}	142		}
143			143
144		func TestNoticesSplitArrowNavigatesWithoutClosing(t *testing.T) {	144		func TestNoticesSplitArrowNavigatesWithoutClosing(t *testing.T) {

@@ -161,7 +161,7 @@ func TestNoticesSplitArrowNavigatesWithoutClosing(t *testing.T) {
161		d.notices.record(domain.Notification{Code: domain.NoticeTabSpawn, Message: "second", Time: time.Unix(2, 0)})	161		d.notices.record(domain.Notification{Code: domain.NoticeTabSpawn, Message: "second", Time: time.Unix(2, 0)})
162			162
163		d.enterNotices(sess, ac)	163		d.enterNotices(sess, ac)
164	-	awaitFrame(t, sends, ports.MsgOutput)	164	+	awaitFrame(t, sends, wire.MsgOutput)
165		for _, input := range tc.input {	165		for _, input := range tc.input {
166		d.handleInput(sess, ac, input)	166		d.handleInput(sess, ac, input)
167		}	167		}

@@ -343,10 +343,10 @@ func TestNoticesOpenWithEmptyHistoryShowsPlaceholderWithoutPanic(t *testing.T) {
343		defer release()	343		defer release()
344			344
345		require.NotPanics(t, func() { d.enterNotices(sess, ac) })	345		require.NotPanics(t, func() { d.enterNotices(sess, ac) })
346	-	out := awaitFrame(t, sends, ports.MsgOutput)	346	+	out := awaitFrame(t, sends, wire.MsgOutput)
347			347
348		require.NotNil(t, ac.overlays.noticesOverlay)	348		require.NotNil(t, ac.overlays.noticesOverlay)
349	-	msg, err := ports.UnmarshalOutput(out.Payload)	349	+	msg, err := wire.UnmarshalOutput(out.Payload)
350		require.NoError(t, err)	350		require.NoError(t, err)
351		require.Contains(t, string(msg.Data), "Notifications")	351		require.Contains(t, string(msg.Data), "Notifications")
352		require.Contains(t, string(msg.Data), "No notifications")	352		require.Contains(t, string(msg.Data), "No notifications")

@@ -391,11 +391,11 @@ func TestYankLastNotificationCommandCopiesOSC52AndShowsFeedback(t *testing.T) {
391		want := noticeYankPayload(n)	391		want := noticeYankPayload(n)
392			392
393		d.enterPalette(sess, ac)	393		d.enterPalette(sess, ac)
394	-	awaitFrame(t, sends, ports.MsgOutput)	394	+	awaitFrame(t, sends, wire.MsgOutput)
395		d.handlePaletteInput(ac, []byte("YLN\r"))	395		d.handlePaletteInput(ac, []byte("YLN\r"))
396			396
397	-	out := awaitFrame(t, sends, ports.MsgOutput)	397	+	out := awaitFrame(t, sends, wire.MsgOutput)
398	-	msg, err := ports.UnmarshalOutput(out.Payload)	398	+	msg, err := wire.UnmarshalOutput(out.Payload)
399		require.NoError(t, err)	399		require.NoError(t, err)
400		payload := string(msg.Data)	400		payload := string(msg.Data)
401		require.True(t, strings.HasPrefix(payload, "\x1b]52;c;"), "OSC52 payload = %q", payload)	401		require.True(t, strings.HasPrefix(payload, "\x1b]52;c;"), "OSC52 payload = %q", payload)

@@ -404,8 +404,8 @@ func TestYankLastNotificationCommandCopiesOSC52AndShowsFeedback(t *testing.T) {
404		require.NoError(t, err)	404		require.NoError(t, err)
405		require.Equal(t, want, string(decoded))	405		require.Equal(t, want, string(decoded))
406			406
407	-	live := awaitFrame(t, sends, ports.MsgOutput)	407	+	live := awaitFrame(t, sends, wire.MsgOutput)
408	-	liveMsg, err := ports.UnmarshalOutput(live.Payload)	408	+	liveMsg, err := wire.UnmarshalOutput(live.Payload)
409		require.NoError(t, err)	409		require.NoError(t, err)
410		require.Contains(t, string(liveMsg.Data), "copied notification details")	410		require.Contains(t, string(liveMsg.Data), "copied notification details")
411		}	411		}

@@ -416,11 +416,11 @@ func TestYankLastNotificationWithEmptyHistoryShowsWarnToast(t *testing.T) {
416		defer release()	416		defer release()
417			417
418		d.enterPalette(sess, ac)	418		d.enterPalette(sess, ac)
419	-	awaitFrame(t, sends, ports.MsgOutput)	419	+	awaitFrame(t, sends, wire.MsgOutput)
420		d.handlePaletteInput(ac, []byte("YLN\r"))	420		d.handlePaletteInput(ac, []byte("YLN\r"))
421			421
422	-	out := awaitFrame(t, sends, ports.MsgOutput)	422	+	out := awaitFrame(t, sends, wire.MsgOutput)
423	-	msg, err := ports.UnmarshalOutput(out.Payload)	423	+	msg, err := wire.UnmarshalOutput(out.Payload)
424		require.NoError(t, err)	424		require.NoError(t, err)
425		require.Contains(t, string(msg.Data), "no notifications yet")	425		require.Contains(t, string(msg.Data), "no notifications yet")
426			426

@@ -439,7 +439,7 @@ func TestNoticesYKeyYanksSelectedNotification(t *testing.T) {
439		d.notices.record(domain.Notification{Code: domain.NoticeTabSpawn, Severity: domain.NoticeError, Message: "second", Time: time.Unix(2, 0)})	439		d.notices.record(domain.Notification{Code: domain.NoticeTabSpawn, Severity: domain.NoticeError, Message: "second", Time: time.Unix(2, 0)})
440			440
441		d.enterNotices(sess, ac)	441		d.enterNotices(sess, ac)
442	-	awaitFrame(t, sends, ports.MsgOutput)	442	+	awaitFrame(t, sends, wire.MsgOutput)
443		selected, ok := ac.overlays.noticesOverlay.Selected()	443		selected, ok := ac.overlays.noticesOverlay.Selected()
444		require.True(t, ok)	444		require.True(t, ok)
445		require.Equal(t, "second", selected.Message)	445		require.Equal(t, "second", selected.Message)

@@ -447,8 +447,8 @@ func TestNoticesYKeyYanksSelectedNotification(t *testing.T) {
447			447
448		d.handleInput(sess, ac, []byte("y"))	448		d.handleInput(sess, ac, []byte("y"))
449			449
450	-	out := awaitFrame(t, sends, ports.MsgOutput)	450	+	out := awaitFrame(t, sends, wire.MsgOutput)
451	-	msg, err := ports.UnmarshalOutput(out.Payload)	451	+	msg, err := wire.UnmarshalOutput(out.Payload)
452		require.NoError(t, err)	452		require.NoError(t, err)
453		payload := string(msg.Data)	453		payload := string(msg.Data)
454		require.True(t, strings.HasPrefix(payload, "\x1b]52;c;"), "OSC52 payload = %q", payload)	454		require.True(t, strings.HasPrefix(payload, "\x1b]52;c;"), "OSC52 payload = %q", payload)

@@ -481,11 +481,11 @@ func TestNoticesBatchedYankCapturesSelectionAtY(t *testing.T) {
481		d.notices.record(domain.Notification{Code: domain.NoticeInternal, Message: "third", Time: time.Unix(3, 0)})	481		d.notices.record(domain.Notification{Code: domain.NoticeInternal, Message: "third", Time: time.Unix(3, 0)})
482			482
483		d.enterNotices(sess, ac)	483		d.enterNotices(sess, ac)
484	-	awaitFrame(t, sends, ports.MsgOutput)	484	+	awaitFrame(t, sends, wire.MsgOutput)
485		d.handleInput(sess, ac, tt.input)	485		d.handleInput(sess, ac, tt.input)
486			486
487	-	out := awaitFrame(t, sends, ports.MsgOutput)	487	+	out := awaitFrame(t, sends, wire.MsgOutput)
488	-	msg, err := ports.UnmarshalOutput(out.Payload)	488	+	msg, err := wire.UnmarshalOutput(out.Payload)
489		require.NoError(t, err)	489		require.NoError(t, err)
490		payload := strings.TrimSuffix(strings.TrimPrefix(string(msg.Data), "\x1b]52;c;"), "\a")	490		payload := strings.TrimSuffix(strings.TrimPrefix(string(msg.Data), "\x1b]52;c;"), "\a")
491		decoded, err := base64.StdEncoding.DecodeString(payload)	491		decoded, err := base64.StdEncoding.DecodeString(payload)

@@ -505,7 +505,7 @@ func TestNoticesYKeyWithNoSelectionIsNoOp(t *testing.T) {
505		defer release()	505		defer release()
506			506
507		require.NotPanics(t, func() { d.enterNotices(sess, ac) })	507		require.NotPanics(t, func() { d.enterNotices(sess, ac) })
508	-	awaitFrame(t, sends, ports.MsgOutput)	508	+	awaitFrame(t, sends, wire.MsgOutput)
509			509
510		require.NotPanics(t, func() { d.handleInput(sess, ac, []byte("y")) })	510		require.NotPanics(t, func() { d.handleInput(sess, ac, []byte("y")) })
511		require.True(t, ac.overlays.noticesActive())	511		require.True(t, ac.overlays.noticesActive())

M internal/usecase/daemon/notify_test.go +10 -9

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestReportAttachmentErrorPreservesLocalOrNilScope(t *testing.T) {
 	d.attachCoordinator(sess, nil, ac, true)
 	tr, ok := ac.tr.(*portsmocks.MockTransport)
 	require.True(t, ok, "attached client transport must be a MockTransport")
-	frames := []ports.Frame{
+	frames := []wire.Frame{
-		{Type: ports.MsgClientNotice, Payload: []byte{0xff}},
+		{Type: wire.MsgClientNotice, Payload: []byte{0xff}},
-		{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
+		{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})},
 	}
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		frame := frames[0]
 		frames = frames[1:]
 		return frame, nil
 // caller-supplied clock so toast TTLs are deterministic. The session has no
 // render coordinator, so invalidateRender paints directly and every repaint is
 // observable as a frame on the returned channel.
-func newNoticeFixture(t *testing.T, clk ports.Clock) (*Daemon, *session, *attachedClient, chan ports.Frame) {
+func newNoticeFixture(t *testing.T, clk ports.Clock) (*Daemon, *session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	p, _ := newBlockingPTY(t)
 	d := newTestDaemon(t, nil, clk)
 	d.notify(sess, domain.NoticeError, domain.NoticePaneSpawn, "could not open pane", nil)
 	awaitToastCount(t, ac, 1)
-	shown := awaitFrame(t, sends, ports.MsgOutput)
+	shown := awaitFrame(t, sends, wire.MsgOutput)
-	shownOutput, err := ports.UnmarshalOutput(shown.Payload)
+	shownOutput, err := wire.UnmarshalOutput(shown.Payload)
 	require.NoError(t, err)
 	terminal := vt.NewScreen(80, 25)
 	terminal.Write(shownOutput.Data)
 	_, overflow := visibleToasts(ac)
 	require.Zero(t, overflow, "overflow resets once no toast is visible")
-	expired := awaitFrame(t, sends, ports.MsgOutput)
+	expired := awaitFrame(t, sends, wire.MsgOutput)
-	expiredOutput, err := ports.UnmarshalOutput(expired.Payload)
+	expiredOutput, err := wire.UnmarshalOutput(expired.Payload)
 	require.NoError(t, err)
 	terminal.Write(expiredOutput.Data)
 	ac.sendMu.Lock()

M internal/usecase/daemon/output_state_sync_test.go +37 -36

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 type datagramTestTransport struct {
-	sends chan ports.Frame
+	sends chan wire.Frame
-	recv  chan ports.Frame
+	recv  chan wire.Frame
 	once  sync.Once
 }
 type failingOutputTransport struct{}
-func (failingOutputTransport) Send(ports.Frame) error     { return errors.New("send failed") }
+func (failingOutputTransport) Send(wire.Frame) error     { return errors.New("send failed") }
-func (failingOutputTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (failingOutputTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (failingOutputTransport) Close() error               { return nil }
+func (failingOutputTransport) Close() error              { return nil }
 type asyncPaintTransport struct {
-	syncSends  chan ports.Frame
+	syncSends  chan wire.Frame
-	asyncSends chan ports.Frame
+	asyncSends chan wire.Frame
 }
-func (t *asyncPaintTransport) Send(f ports.Frame) error      { t.syncSends <- f; return nil }
+func (t *asyncPaintTransport) Send(f wire.Frame) error      { t.syncSends <- f; return nil }
-func (t *asyncPaintTransport) SendAsync(f ports.Frame) error { t.asyncSends <- f; return nil }
+func (t *asyncPaintTransport) SendAsync(f wire.Frame) error { t.asyncSends <- f; return nil }
-func (t *asyncPaintTransport) Recv() (ports.Frame, error)    { return ports.Frame{}, io.EOF }
+func (t *asyncPaintTransport) Recv() (wire.Frame, error)    { return wire.Frame{}, io.EOF }
-func (t *asyncPaintTransport) Close() error                  { return nil }
+func (t *asyncPaintTransport) Close() error                 { return nil }
 type timedSideEffectTransport struct {
 	closeTrackingTransport
 }
-func (t *timedSideEffectTransport) SendSynchronous(f ports.Frame) error {
+func (t *timedSideEffectTransport) SendSynchronous(f wire.Frame) error {
 	return t.Send(f)
 }
 }
 func newDatagramTestTransport() *datagramTestTransport {
-	return &datagramTestTransport{sends: make(chan ports.Frame, 64), recv: make(chan ports.Frame, 64)}
+	return &datagramTestTransport{sends: make(chan wire.Frame, 64), recv: make(chan wire.Frame, 64)}
 }
-func (t *datagramTestTransport) Send(f ports.Frame) error { t.sends <- f; return nil }
+func (t *datagramTestTransport) Send(f wire.Frame) error { t.sends <- f; return nil }
-func (t *datagramTestTransport) Recv() (ports.Frame, error) {
+func (t *datagramTestTransport) Recv() (wire.Frame, error) {
 	f, ok := <-t.recv
 	if !ok {
-		return ports.Frame{}, io.EOF
+		return wire.Frame{}, io.EOF
 	}
 	return f, nil
 }
 	sess.tabs[0].focusedPane().screen.Write([]byte("A"))
 	d.paint(sess, ac, false, nil)
-	first := awaitFrame(t, tr.sends, ports.MsgOutput)
+	first := awaitFrame(t, tr.sends, wire.MsgOutput)
-	out, err := ports.UnmarshalOutput(first.Payload)
+	out, err := wire.UnmarshalOutput(first.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), out.New)
 	sess.tabs[0].focusedPane().screen.Write([]byte("\rB"))
 	d.paint(sess, ac, false, nil)
-	updated := awaitFrame(t, tr.sends, ports.MsgOutput)
+	updated := awaitFrame(t, tr.sends, wire.MsgOutput)
-	out, err = ports.UnmarshalOutput(updated.Payload)
+	out, err = wire.UnmarshalOutput(updated.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), out.New)
 	// Both states were emitted before the MsgAck; the ordered dependency chain
 	// must therefore remain valid without waiting for renderer acknowledgement.
-	tr.recv <- ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: out.Epoch, State: out.New})}
+	tr.recv <- wire.Frame{Type: wire.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: out.Epoch, State: out.New})}
 	require.NoError(t, tr.Close())
 	d.runConnLoop(ac)
 	p, releasePTY := newBlockingPTY(t)
 	defer releasePTY()
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
-	tr := &asyncPaintTransport{syncSends: make(chan ports.Frame, 1), asyncSends: make(chan ports.Frame, 1)}
+	tr := &asyncPaintTransport{syncSends: make(chan wire.Frame, 1), asyncSends: make(chan wire.Frame, 1)}
 	ac.replaceTransport(tr)
 	sess.tabs[0].focusedPane().screen.Write([]byte("A"))
 	d.paint(sess, ac, false, nil)
-	awaitFrame(t, tr.asyncSends, ports.MsgOutput)
+	awaitFrame(t, tr.asyncSends, wire.MsgOutput)
 	select {
 	case frame := <-tr.syncSends:
 		t.Fatalf("paint used synchronous Send: %+v", frame)
 	pane.screen.ClearDamage()
 	client := vt.NewScreen(80, 25)
 	d.paint(sess, ac, true, nil)
-	first := mustApplyOutput(t, client, awaitFrame(t, tr.sends, ports.MsgOutput))
+	first := mustApplyOutput(t, client, awaitFrame(t, tr.sends, wire.MsgOutput))
 	ac.ackOutputState(first.Epoch, first.New)
 	// Preserve the frame after one scroll while inducing a real VT scroll
 		pane.screen.Write([]byte("\nq"))
 		pane.screen.Frame = desired.Clone()
 		d.paint(sess, ac, false, nil)
-		mustApplyOutput(t, client, awaitFrame(t, tr.sends, ports.MsgOutput))
+		mustApplyOutput(t, client, awaitFrame(t, tr.sends, wire.MsgOutput))
 	}
 	require.Equal(t, 'B', client.Frame.At(0, 1).Rune,
 	return string(runes)
 }
-func mustApplyOutput(t *testing.T, screen *vt.Screen, frame ports.Frame) protocol.Output {
+func mustApplyOutput(t *testing.T, screen *vt.Screen, frame wire.Frame) protocol.Output {
 	t.Helper()
-	out, err := ports.UnmarshalOutput(frame.Payload)
+	out, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	screen.Write(out.Data)
 	return out
 	sess.tabs[0].focusedPane().screen.Write([]byte("A"))
 	d.paint(sess, ac, false, nil)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	// The first paint updates the renderer shadow without waiting for MsgAck.
 	d.paint(sess, ac, false, nil)
 	pane.screen.Write([]byte("A"))
 	d.paint(sess, ac, false, nil)
-	first := awaitFrame(t, sends, ports.MsgOutput)
+	first := awaitFrame(t, sends, wire.MsgOutput)
-	out, err := ports.UnmarshalOutput(first.Payload)
+	out, err := wire.UnmarshalOutput(first.Payload)
 	require.NoError(t, err)
 	pane.screen.Write([]byte("\rB"))
 	d.paint(sess, ac, false, nil)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.ackOutputState(out.Epoch, out.New)
 	d.paint(sess, ac, false, nil)
 	require.Equal(t, uint64(maxUnackedOutputStates), ac.output.outstanding())
 	sends := tr.Sends()
 	require.Len(t, sends, 1)
-	out, err := ports.UnmarshalOutput(sends[0].Payload)
+	out, err := wire.UnmarshalOutput(sends[0].Payload)
 	require.NoError(t, err)
 	require.Zero(t, out.Base)
 	require.Zero(t, out.New)
 			pane.screen.Write([]byte(strings.Repeat("A", 79)))
 			d.paint(sess, ac, true, nil)
 			client := vt.NewScreen(80, 24)
-			initial := mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+			initial := mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 			ac.ackOutputState(initial.Epoch, initial.New)
 			d.sessWg.Add(1)
 			require.Equal(t, 'B', pane.screen.Frame.At(100, 0).Rune, "replay must parse the redraw before commit")
 			client.Resize(120, 24)
-			mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+			mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 			require.Equal(t, 'B', client.Frame.At(100, 1).Rune,
 				"first grown frame exposed stale pre-SIGWINCH pane content")
 			select {
 	done := captureResizeCallbackDone(t, sess.renderCoordinator())
 	timer.ch <- time.Now()
 	awaitTestCompletion(t, done, "resize callback did not complete")
-	frame := awaitFrame(t, sends, ports.MsgOutput)
+	frame := awaitFrame(t, sends, wire.MsgOutput)
 	client := vt.NewScreen(120, 24)
 	out := mustApplyOutput(t, client, frame)
 	require.Zero(t, out.Base)
 	requireNoOutputFrame(t, sends)
 	latest.ch <- time.Now()
 	awaitTestCompletion(t, latestDone, "latest resize callback did not complete")
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.Equal(t, domain.Size{Cols: 120, Rows: 24}, ac.size)
 	require.Equal(t, 120, testAttachmentTab(sess).focusedPane().screen.Frame.Width)
 	requireNoOutputFrame(t, sends)

M internal/usecase/daemon/paint_gate_test.go +3 -3


@@ -4,16 +4,16 @@ import (
4		"testing"	4		"testing"
5		"time"	5		"time"
6			6
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol/wire"
8		)	8		)
9			9
10	-	func requireNoOutputFrame(t *testing.T, sends chan ports.Frame) {	10	+	func requireNoOutputFrame(t *testing.T, sends chan wire.Frame) {
11		t.Helper()	11		t.Helper()
12		deadline := time.After(50 * time.Millisecond)	12		deadline := time.After(50 * time.Millisecond)
13		for {	13		for {
14		select {	14		select {
15		case f := <-sends:	15		case f := <-sends:
16	-	if f.Type == ports.MsgOutput {	16	+	if f.Type == wire.MsgOutput {
17		t.Fatalf("unexpected output frame: %+v", f)	17		t.Fatalf("unexpected output frame: %+v", f)
18		}	18		}
19		case <-deadline:	19		case <-deadline:

M internal/usecase/daemon/palette_test.go +80 -79

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/palette"
 	"github.com/bnema/vev/internal/usecase/picker"
 	d.handleInput(sess, ac, []byte("\x1b "))
 	require.True(t, ac.overlays.paletteActive())
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "Commands")
 	require.False(t, ac.overlays.paletteActive())
 	require.Equal(t, 1, testAttachmentTabIndex(sess))
 	requireFloatingInitialized(t, testAttachmentTab(sess))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\x1b"))
 	require.False(t, ac.overlays.paletteActive())
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 // TestPaletteCommandFailureSurfacesAsNotice drives a palette command whose Run
 	d.ptys = ptys
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("CNT\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	history := d.notices.history()
 	require.NotEmpty(t, history, "failed palette command must record a notice")
 	target.createdAt = 42
 	d.handleInput(current, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(current, ac, []byte("recent\rx"))
 	require.Same(t, target, ac.currentSession(), "Enter must retain the selected session despite trailing frame bytes")
 	require.False(t, ac.overlays.paletteActive(), "trailing input must not prevent the captured selection from closing the palette")
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteSelectedActiveSessionSwitchesWithoutRecordingCommandRecency(t *testing.T) {
 	target.createdAt = 42
 	d.handleInput(current, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(current, ac, []byte("recent\r"))
 	require.Same(t, target, ac.currentSession())
 	require.Contains(t, target.snapshotAttachments(), ac, "canonical handoff reuses the attached client")
 	require.False(t, ac.overlays.paletteActive())
 	require.Empty(t, d.paletteRecent, "session selections are not command recency")
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteStoppedSessionResumeFailureKeepsPaletteAndSourceAttachment(t *testing.T) {
 	d.ptys = ptys
 	d.handleInput(current, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(current, ac, []byte("stopped\r"))
 	require.Same(t, current, ac.currentSession(), "failed resume must retain the source attachment")
 	require.Equal(t, "requested session is unavailable", ac.overlays.paletteFeedback)
 	ac.overlays.paletteMu.Unlock()
 	require.Equal(t, stopped, d.inactive[stopped.name], "failed resume must retain stopped lifecycle metadata")
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteSelectedStoppedSessionResumesAndSwitches(t *testing.T) {
 	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 42, state: protocol.SessionDown}
 	d.handleInput(current, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	generation := ac.lifecycle.generationValue()
 	d.handleInput(current, ac, []byte("stopped\r"))
 	require.Equal(t, true, resumed.attachmentRegistered(ac))
 	require.Greater(t, ac.lifecycle.generationValue(), generation, "stopped-session handoff must publish through the attachment transition")
 	require.False(t, ac.overlays.paletteActive())
-	firstPaint := awaitFrame(t, sends, ports.MsgOutput)
+	firstPaint := awaitFrame(t, sends, wire.MsgOutput)
-	firstOutput, err := ports.UnmarshalOutput(firstPaint.Payload)
+	firstOutput, err := wire.UnmarshalOutput(firstPaint.Payload)
 	require.NoError(t, err)
 	require.Zero(t, firstOutput.Base, "stopped-session first paint must reset moving output state")
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteJRSActivatesOnlyExactContextualHint(t *testing.T) {
 	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1, Active: protocol.RouteRef{Key: 1, Generation: 1}})
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("JRS"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	require.Equal(t, command.ContextHintRecentSessions, ac.overlays.paletteHints.Kind)
 	ac.overlays.paletteMu.Unlock()
 	d.handleInput(sess, ac, []byte("\b\b\bRNS"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	require.Equal(t, command.ContextHintNone, ac.overlays.paletteHints.Kind)
 	ac.overlays.paletteMu.Unlock()
 	d.ApplyConfig(domain.Config{Codes: map[string]string{"jump-recent-session": "RJS"}})
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("RJS"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	require.Equal(t, command.ContextHintRecentSessions, ac.overlays.paletteHints.Kind)
 	ac.overlays.paletteMu.Unlock()
 	d.handleInputForAttachment(token, []byte(" 1\r"))
-	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
+	actionFrame := awaitFrame(t, sends, wire.MsgNavigateRecentRoute)
-	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
+	action, err := wire.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 1, Key: 2, Generation: 1}, action)
 	require.Same(t, current, ac.currentSession())
 	require.False(t, ac.overlays.paletteActive())
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("JRS"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	ac.overlays.paletteMu.Lock()
 	require.Equal(t, command.ContextHintNone, ac.overlays.paletteHints.Kind)
 	ac.overlays.paletteMu.Unlock()
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("work@arch\r"))
-	frame := awaitFrame(t, sends, ports.MsgAttachTarget)
+	frame := awaitFrame(t, sends, wire.MsgAttachTarget)
-	target, err := ports.UnmarshalAttachTarget(frame.Payload)
+	target, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	remoteTarget := domain.RemoteSessionTarget{
 		Endpoint: "user@arch", DisplayOrigin: "arch", LifecycleID: remoteLifecycle,
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("cached@arch\r"))
 	require.Same(t, current, ac.currentAttachmentSession())
 	for {
 		select {
 		case frame := <-sends:
-			require.NotEqual(t, ports.MsgAttachTarget, frame.Type)
+			require.NotEqual(t, wire.MsgAttachTarget, frame.Type)
 		default:
 			return
 		}
 	for {
 		select {
 		case frame := <-sends:
-			require.NotEqual(t, ports.MsgAttachTarget, frame.Type)
+			require.NotEqual(t, wire.MsgAttachTarget, frame.Type)
 		default:
 			return
 		}
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("logs@edge\r"))
-	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
+	actionFrame := awaitFrame(t, sends, wire.MsgNavigateRecentRoute)
-	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
+	action, err := wire.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 9, Key: 8, Generation: 4}, action)
 	require.False(t, ac.overlays.paletteActive())
 	defer releases[1]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("next\r"))
 	require.False(t, ac.overlays.paletteActive())
 	require.Equal(t, 1, testAttachmentTabIndex(sess))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteJRSUsesCapturedRankAfterMRUChanges(t *testing.T) {
 	ac.setRouteSnapshot(testRecentRouteSnapshot())
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	// Reordering live MRU after opening must not shift rank 1 from its capture.
 	d.sessions[domain.SessionID("older")].core().mruAt.Store(100)
 	d.handleInputForAttachment(token, []byte("JRS 1\r"))
-	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
+	actionFrame := awaitFrame(t, sends, wire.MsgNavigateRecentRoute)
-	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
+	action, err := wire.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 1, Key: 2, Generation: 1}, action)
 	require.Same(t, current, ac.currentSession())
 	}
 	token := beginRecentRoutePaletteEffect(t, d, sess, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	inputHandled := make(chan struct{})
 	go func() {
 		d.handleInputForAttachment(token, []byte("JRS 1\r"))
 	close(releaseHandoff)
 	awaitTestCompletion(t, inputHandled, "JRS route-action input did not complete")
-	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
+	actionFrame := awaitFrame(t, sends, wire.MsgNavigateRecentRoute)
-	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
+	action, err := wire.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 7, Key: 9, Generation: 4}, action)
 	require.False(t, ac.overlays.paletteActive())
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("JRS 3\r"))
 	require.Same(t, current, ac.currentSession())
 	require.Equal(t, "JRS 3", ac.overlays.palette.Query())
 	require.Equal(t, "requested recent session is unavailable", ac.overlays.paletteFeedback)
 	ac.overlays.paletteMu.Unlock()
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteJRSMalformedRankFeedback(t *testing.T) {
 	defer releaseAll(releases)
 	d.handleInput(current, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(current, ac, []byte("JRS 0\r"))
 	require.Same(t, current, ac.currentSession())
 	require.Equal(t, "JRS 0", ac.overlays.palette.Query())
 	require.Equal(t, "rank must be one positive decimal", ac.overlays.paletteFeedback)
 	ac.overlays.paletteMu.Unlock()
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteFailureDoesNotOverwriteChangedQueryInSameGeneration(t *testing.T) {
 	ac.overlays.paletteMu.Lock()
 	require.Empty(t, ac.overlays.paletteFeedback)
 	ac.overlays.paletteMu.Unlock()
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteTFPExecutesFloatingToggle(t *testing.T) {
 	installTestFloating(tb, newPane("floating", nil, domain.Size{Cols: 20, Rows: 5}), false)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("TFP\r"))
 	require.False(t, ac.overlays.paletteActive())
 	tb.mu.Lock()
 	require.Equal(t, floatingVisible, tb.floating.state)
 	tb.mu.Unlock()
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteCNSPromptsForSessionNameThenCreatesAndSwitches(t *testing.T) {
 	d.ptys = newFactorySeq(t, p2)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("CNS\r"))
-	promptFrame := awaitFrame(t, sends, ports.MsgOutput)
+	promptFrame := awaitFrame(t, sends, wire.MsgOutput)
-	promptOutput, err := ports.UnmarshalOutput(promptFrame.Payload)
+	promptOutput, err := wire.UnmarshalOutput(promptFrame.Payload)
 	require.NoError(t, err)
 	require.False(t, ac.overlays.paletteActive())
 	require.True(t, ac.overlays.promptActive())
 	// The submit first paints the newly attached session while the prompt is
 	// still open, then handlePromptInput closes the prompt and repaints the
 	// client's current session. The final frame must be for the new session.
-	firstPaint := awaitFrame(t, sends, ports.MsgOutput)
+	firstPaint := awaitFrame(t, sends, wire.MsgOutput)
-	firstOutput, err := ports.UnmarshalOutput(firstPaint.Payload)
+	firstOutput, err := wire.UnmarshalOutput(firstPaint.Payload)
 	require.NoError(t, err)
 	require.Zero(t, firstOutput.Base, "new-session first paint must reset moving output state")
-	finalRepaint := awaitFrame(t, sends, ports.MsgOutput)
+	finalRepaint := awaitFrame(t, sends, wire.MsgOutput)
-	finalOutput, err := ports.UnmarshalOutput(finalRepaint.Payload)
+	finalOutput, err := wire.UnmarshalOutput(finalRepaint.Payload)
 	require.NoError(t, err)
 	require.False(t, ac.overlays.promptActive())
 	require.Equal(t, 2, sessionCount(d))
 			d.ptys = newFactorySeq(t, p2)
 			d.handleInput(sess, ac, []byte("\x1b "))
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			d.handleInput(sess, ac, []byte(tc.input))
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			require.False(t, ac.overlays.paletteActive())
 			require.False(t, ac.overlays.promptActive())
 	defer releases[1]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("NXT\r"))
 	require.False(t, ac.overlays.paletteActive())
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	result, ok := ac.overlays.palette.Selected()
 	require.True(t, ok)
 	cmd, ok := result.Command()
 	defer releases[0]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	paletteFrame := awaitFrame(t, sends, ports.MsgOutput)
+	paletteFrame := awaitFrame(t, sends, wire.MsgOutput)
-	paletteOutput, err := ports.UnmarshalOutput(paletteFrame.Payload)
+	paletteOutput, err := wire.UnmarshalOutput(paletteFrame.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(paletteOutput.Data), "Commands")
 	d.handleInput(sess, ac, []byte("NXT\r"))
 	require.False(t, ac.overlays.paletteActive())
-	repaint := awaitFrame(t, sends, ports.MsgOutput)
+	repaint := awaitFrame(t, sends, wire.MsgOutput)
-	repaintOutput, err := ports.UnmarshalOutput(repaint.Payload)
+	repaintOutput, err := wire.UnmarshalOutput(repaint.Payload)
 	require.NoError(t, err)
 	require.NotContains(t, string(repaintOutput.Data), "Commands")
 }
 	d.ptys = ptys
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("CNT\r"))
 	require.False(t, ac.overlays.paletteActive())
-	repaint := awaitFrame(t, sends, ports.MsgOutput)
+	repaint := awaitFrame(t, sends, wire.MsgOutput)
-	repaintOutput, err := ports.UnmarshalOutput(repaint.Payload)
+	repaintOutput, err := wire.UnmarshalOutput(repaint.Payload)
 	require.NoError(t, err)
 	require.NotContains(t, string(repaintOutput.Data), "Commands")
 	require.Len(t, sess.tabs, 1)
 	defer releases[0]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("zzzz\r"))
 	require.True(t, ac.overlays.paletteActive())
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte{0x1b, '['})
 	require.True(t, ac.overlays.paletteActive())
 	d.handlePaletteInput(ac, []byte{'A'})
 	require.True(t, ac.overlays.paletteActive())
 	require.Empty(t, ac.overlays.palettePending)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPaletteCtrlNAndCtrlPNavigate(t *testing.T) {
 	defer releases[0]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte{0x0e})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	result, ok := ac.overlays.palette.Selected()
 	require.True(t, ok)
 	cmd, ok := result.Command()
 	require.Equal(t, "CNS", cmd.Code)
 	d.handlePaletteInput(ac, []byte{0x10})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	result, ok = ac.overlays.palette.Selected()
 	require.True(t, ok)
 	cmd, ok = result.Command()
 	defer releases[0]()
 	d.handleInput(sess, ac, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte{0xc3})
 	require.Equal(t, []byte{0xc3}, ac.overlays.palettePending)
 	d.handlePaletteInput(ac, []byte{0xa9})

M internal/usecase/daemon/pane_actions_test.go +3 -2

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 			closingPTY.EXPECT().Close().Return(nil).Once()
 			clients := make([]*attachedClient, 2)
-			sends := make([]chan ports.Frame, 2)
+			sends := make([]chan wire.Frame, 2)
 			for i := range clients {
 				tr, sent := newCapturingTransport(t)
 				clients[i] = &attachedClient{tr: tr, output: newOutputStateStream(), size: domain.Size{Cols: 41, Rows: 12}}
 				select {
 				case frame := <-sends[i]:
 					require.True(t, want, "attachment %d unexpectedly repainted: %#v", i, frame)
-					require.Equal(t, ports.MsgOutput, frame.Type)
+					require.Equal(t, wire.MsgOutput, frame.Type)
 				default:
 					require.False(t, want, "attachment %d was not repainted", i)
 				}

M internal/usecase/daemon/parked_route.go +5 -4

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const parkedRouteLeaseTTL = 15 * time.Minute
 	return 0
 }
-func parkedRouteResponseFrame(response protocol.ParkedRouteResponse) (ports.Frame, error) {
+func parkedRouteResponseFrame(response protocol.ParkedRouteResponse) (wire.Frame, error) {
-	payload := ports.MarshalParkedRouteResponse(response)
+	payload := wire.MarshalParkedRouteResponse(response)
 	if payload == nil {
-		return ports.Frame{}, errAttachmentTransition
+		return wire.Frame{}, errAttachmentTransition
 	}
-	return ports.Frame{Type: ports.MsgParkedRouteResponse, Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgParkedRouteResponse, Payload: payload}, nil
 }
 func (d *Daemon) sendParkedRouteResponse(effect *attachmentEffect, response protocol.ParkedRouteResponse) error {

M internal/usecase/daemon/parked_route_test.go +37 -36

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type parkedRouteFailTransport struct{}
-func (parkedRouteFailTransport) Send(ports.Frame) error     { return errors.New("send failed") }
+func (parkedRouteFailTransport) Send(wire.Frame) error     { return errors.New("send failed") }
-func (parkedRouteFailTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (parkedRouteFailTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (parkedRouteFailTransport) Close() error               { return nil }
+func (parkedRouteFailTransport) Close() error              { return nil }
 type parkedRouteExpiryTransport struct {
-	sends  chan ports.Frame
+	sends  chan wire.Frame
 	closed chan struct{}
 	once   sync.Once
 }
-func (t *parkedRouteExpiryTransport) Send(frame ports.Frame) error {
+func (t *parkedRouteExpiryTransport) Send(frame wire.Frame) error {
 	t.sends <- frame
 	return nil
 }
-func (t *parkedRouteExpiryTransport) Recv() (ports.Frame, error) {
+func (t *parkedRouteExpiryTransport) Recv() (wire.Frame, error) {
 	<-t.closed
-	return ports.Frame{}, io.EOF
+	return wire.Frame{}, io.EOF
 }
 func (t *parkedRouteExpiryTransport) Close() error {
 	c.mu.Unlock()
 }
-func armAndPrepareParkedRoute(t *testing.T, d *Daemon, source *session, ac *attachedClient, sends chan ports.Frame) protocol.ParkedRouteLeaseID {
+func armAndPrepareParkedRoute(t *testing.T, d *Daemon, source *session, ac *attachedClient, sends chan wire.Frame) protocol.ParkedRouteLeaseID {
 	t.Helper()
 	ac.navigationCapabilities |= protocol.NavigationCapabilityHomePicker
 	token := source.captureAttachmentCapability(ac, ac.transport())
 	require.True(t, admitted)
 	require.NoError(t, d.sendNavigationActionForAttachment(effect, protocol.NavigationOpenHomePicker))
 	effect.End()
-	directiveFrame := awaitFrame(t, sends, ports.MsgNavigationAction)
+	directiveFrame := awaitFrame(t, sends, wire.MsgNavigationAction)
-	directive, err := ports.UnmarshalNavigationDirective(directiveFrame.Payload)
+	directive, err := wire.UnmarshalNavigationDirective(directiveFrame.Payload)
 	require.NoError(t, err)
 	prepare := protocol.ParkedRouteRequest{RequestID: 1, LeaseID: directive.LeaseID, Action: protocol.ParkedRoutePrepare}
-	require.False(t, d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(prepare)}))
+	require.False(t, d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(prepare)}))
-	readyFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	readyFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	ready, err := ports.UnmarshalParkedRouteResponse(readyFrame.Payload)
+	ready, err := wire.UnmarshalParkedRouteResponse(readyFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady}, ready)
 	return directive.LeaseID
 		SessionName: "target", LiveTabID: domain.TabStableID(target.tabs[0].stableID),
 	}
 	switchRequest := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteSwitch, Target: &targetRequest}
-	require.False(t, d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(switchRequest)}))
+	require.False(t, d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(switchRequest)}))
 	require.Same(t, target, ac.currentAttachmentSession())
 	require.False(t, ac.parkedRouteOutput.Load())
-	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	responseFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
+	response, err := wire.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}, response)
 }
 		SessionName: "target", LiveTabID: domain.TabStableID(target.tabs[0].stableID),
 	}
 	switchRequest := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteSwitch, Target: &targetRequest}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(switchRequest)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(switchRequest)})
 	require.Same(t, target, ac.currentAttachmentSession())
-	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	responseFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
+	response, err := wire.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteSwitched, response.Status)
 }
 		SessionName: "stopped", Stopped: true, StoppedTab: domain.NewStableTabSelector("tab-b"),
 	}
 	switchRequest := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteSwitch, Target: &target}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(switchRequest)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(switchRequest)})
 	restored := ac.currentAttachmentSession()
 	require.NotNil(t, restored)
 		SessionName: "missing", LiveTabID: "tab-1",
 	}
 	switchRequest := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteSwitch, Target: &missing}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(switchRequest)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(switchRequest)})
-	staleFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	staleFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	stale, err := ports.UnmarshalParkedRouteResponse(staleFrame.Payload)
+	stale, err := wire.UnmarshalParkedRouteResponse(staleFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteStaleTarget, stale.Status)
 	require.Same(t, source, ac.currentAttachmentSession())
 	require.True(t, ac.parkedRouteOutput.Load())
 	resume := protocol.ParkedRouteRequest{RequestID: 3, LeaseID: leaseID, Action: protocol.ParkedRouteResume}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(resume)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(resume)})
-	resumedFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	resumedFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	resumed, err := ports.UnmarshalParkedRouteResponse(resumedFrame.Payload)
+	resumed, err := wire.UnmarshalParkedRouteResponse(resumedFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteResumed, resumed.Status)
 	require.False(t, ac.parkedRouteOutput.Load())
-	outputFrame := awaitFrame(t, sends, ports.MsgOutput)
+	outputFrame := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(outputFrame.Payload)
+	output, err := wire.UnmarshalOutput(outputFrame.Payload)
 	require.NoError(t, err)
 	require.True(t, output.Full)
 }
 	}
 	resume := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteResume}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(resume)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(resume)})
-	_ = awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	_ = awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	outputFrame := awaitFrame(t, sends, ports.MsgOutput)
+	outputFrame := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(outputFrame.Payload)
+	output, err := wire.UnmarshalOutput(outputFrame.Payload)
 	require.NoError(t, err)
 	require.True(t, output.Full)
 	require.NotContains(t, string(output.Data), "one-shot effect")
 	ac.parkedRoute.expiresAt = d.clock.Now()
 	ac.parkedRouteMu.Unlock()
 	resume := protocol.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: protocol.ParkedRouteResume}
-	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: ports.MarshalParkedRouteRequest(resume)})
+	d.handleAttachmentClientFrame(source.captureAttachmentCapability(ac, ac.transport()), wire.Frame{Type: wire.MsgParkedRouteRequest, Payload: wire.MarshalParkedRouteRequest(resume)})
-	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
+	responseFrame := awaitFrame(t, sends, wire.MsgParkedRouteResponse)
-	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
+	response, err := wire.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ParkedRouteExpired, response.Status)
 	require.Same(t, source, ac.currentAttachmentSession())
 	clock.EXPECT().Now().Return(time.Time{}).Maybe()
 	clock.EXPECT().NewTimer(mock.Anything).Return(timer).Once()
 	d.clock = clock
-	transport := &parkedRouteExpiryTransport{sends: make(chan ports.Frame, 8), closed: make(chan struct{})}
+	transport := &parkedRouteExpiryTransport{sends: make(chan wire.Frame, 8), closed: make(chan struct{})}
 	ac.replaceTransport(transport)
 	_ = armAndPrepareParkedRoute(t, d, source, ac, transport.sends)

M internal/usecase/daemon/performance_benchmark_test.go +9 -8

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
 )
 func TestCountingOutputTransportCountsOpaquePayloadAndRejectsShortPayload(t *testing.T) {
 	transport := &countingOutputTransport{}
-	err := transport.Send(ports.Frame{Type: ports.MsgOutput, Payload: make([]byte, 23)})
+	err := transport.Send(wire.Frame{Type: wire.MsgOutput, Payload: make([]byte, 23)})
 	require.Error(t, err)
 	require.Equal(t, countingOutputMetrics{}, transport.metrics())
 	payload := append(make([]byte, 24), 0xff, 0x00, 0xfe)
-	require.NoError(t, transport.Send(ports.Frame{Type: ports.MsgOutput, Payload: payload}))
+	require.NoError(t, transport.Send(wire.Frame{Type: wire.MsgOutput, Payload: payload}))
 	require.Equal(t, countingOutputMetrics{frames: 1, bytes: 3, payloadBytes: uint64(len(payload))}, transport.metrics())
 	require.Equal(t, payload, transport.lastPayload())
 func TestRenderStageHooksCountProductionBoundariesOnFailedSend(t *testing.T) {
 	d, sess, ac, sends := newManualSessionWithPTYs(t, nil)
 	d.paint(sess, ac, true, nil)
-	_ = awaitFrame(t, sends, ports.MsgOutput)
+	_ = awaitFrame(t, sends, wire.MsgOutput)
 	var captures, compositions, emissions int
 	ac.renderStages = renderStageHooks{
 		capture: func() { captures++ },
 			}
 			metrics := fixture.metrics()
 			if payload := fixture.output.lastPayload(); payload != nil {
-				if _, err := ports.UnmarshalOutput(payload); err != nil {
+				if _, err := wire.UnmarshalOutput(payload); err != nil {
 					b.Fatalf("decode last output: %v", err)
 				}
 			}
 	last []byte
 }
-func (t *countingOutputTransport) Send(frame ports.Frame) error {
+func (t *countingOutputTransport) Send(frame wire.Frame) error {
-	if frame.Type != ports.MsgOutput {
+	if frame.Type != wire.MsgOutput {
 		return nil
 	}
 	if len(frame.Payload) < outputPayloadHeaderBytes {
 	t.mu.Unlock()
 	return nil
 }
-func (*countingOutputTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*countingOutputTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*countingOutputTransport) Close() error               { return nil }
+func (*countingOutputTransport) Close() error              { return nil }
 func (t *countingOutputTransport) reset() {
 	t.mu.Lock()
 	t.countingOutputMetrics = countingOutputMetrics{}

M internal/usecase/daemon/picker.go +5 -4

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/picker"
 	"github.com/bnema/vev/internal/usecase/ui"
 	// Explicit tab rows already take the direct transition path above, while
 	// stopped sessions have no active target session and retain the fallback.
 	samePeerEligible := guard.allowSamePeer && targetSess != nil && target.TabIndex <= 0
-	payload := ports.MarshalAttachTarget(protocol.AttachTarget{
+	payload := wire.MarshalAttachTarget(protocol.AttachTarget{
 		Session:           sessionName,
 		Intent:            protocol.IntentAttach,
 		ExactTarget:       exactTarget,
 	} else {
 		effect.ac.offerSamePeerTarget(*exactTarget)
 	}
-	if err := effect.sendControl(ports.Frame{Type: ports.MsgAttachTarget, Payload: payload}); err != nil {
+	if err := effect.sendControl(wire.Frame{Type: wire.MsgAttachTarget, Payload: payload}); err != nil {
 		if samePeerEligible {
 			effect.ac.clearSamePeerOffer()
 		}
 		RemoteTarget:      &remoteTarget,
 		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}
-	payload := ports.MarshalAttachTarget(handoff)
+	payload := wire.MarshalAttachTarget(handoff)
 	if payload == nil {
 		return failUnavailable()
 	}
-	if err := effect.sendControl(ports.Frame{Type: ports.MsgAttachTarget, Payload: payload}); err != nil {
+	if err := effect.sendControl(wire.Frame{Type: wire.MsgAttachTarget, Payload: payload}); err != nil {
 		return domain.UserErr(domain.NoticeSessionUnavailable, "couldn't attach to remote session", err)
 	}
 	if guard.closePicker {

M internal/usecase/daemon/picker_test.go +30 -29

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/picker"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 	err error
 }
-func (t *remotePickerSendErrorTransport) Send(ports.Frame) error   { return t.err }
+func (t *remotePickerSendErrorTransport) Send(wire.Frame) error   { return t.err }
-func (*remotePickerSendErrorTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }
+func (*remotePickerSendErrorTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
-func (*remotePickerSendErrorTransport) Close() error               { return nil }
+func (*remotePickerSendErrorTransport) Close() error              { return nil }
 type refusingSnapshotDeleteRepository struct {
 	noOpSnapshotRepository
 			d.mu.Unlock()
 			d.enterPicker(sess, ac)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			// Move off the attached session's active tab: a navigate rebuild snaps
 			// back to it unless the toggle preserves the selection.
 			d.handleInput(sess, ac, tc.navigate)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			ac.overlays.pickerMu.Lock()
 			before, ok := ac.overlays.picker.Selected()
 			ac.overlays.pickerMu.Unlock()
 			}
 			d.handleInput(sess, ac, []byte("s"))
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			require.Equal(t, uint32(pickerSortGrouped), d.pickerSort.Load())
 			require.True(t, ac.overlays.pickerActive())
 			require.Equal(t, " Sessions · grouped ", title)
 			d.handleInput(sess, ac, []byte("s"))
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			require.Equal(t, uint32(pickerSortRecent), d.pickerSort.Load())
 			require.True(t, ac.overlays.pickerActive())
 	d.inactive["work"] = inactiveSession{name: "work", cwd: "/tmp/work", createdAt: 7, tabNames: []string{"shell", "logs"}, record: domain.CatalogueRecord{Name: "work"}, state: protocol.SessionDown}
 	d.resumeStoppedAndSwitch(from, ac, picker.Target{Name: "work", Stopped: true})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	target := ac.currentSession()
 	require.NotNil(t, target)
 	}()
 	d.enterPicker(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("j"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(sess, ac, []byte("\r"))
 	require.Equal(t, 1, testAttachmentTabIndex(sess))
 	requireFloatingInitialized(t, testAttachmentTab(sess))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.enterPicker(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	clk := &signalClock{timers: make(chan *signalTimer, 1)}
 	d.clock = clk
 	d.handleInput(sess, ac, []byte("\x1b"))
 	require.True(t, ac.overlays.pickerActive())
 	timer.ch <- time.Now()
 	require.Eventually(t, func() bool { return !ac.overlays.pickerActive() }, time.Second, 5*time.Millisecond)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestPickerSplitArrowNavigatesWithoutExiting(t *testing.T) {
 			}()
 			d.enterPicker(sess, ac)
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			for _, input := range tc.input {
 				d.handleInput(sess, ac, input)
 			}
 	defer releases[0]()
 	d.enterPicker(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	clk := &signalClock{timers: make(chan *signalTimer, 1)}
 	d.clock = clk
 	d.handleInput(sess, ac, []byte("\x1b"))
 	d.sessions[sess2.id] = sess2
 	d.firstPaint(sess1, ac1)
-	awaitFrame(t, sends1, ports.MsgOutput)
+	awaitFrame(t, sends1, wire.MsgOutput)
 	d.stealClientForTarget(sess1, ac1, sess2, picker.Target{Session: sess2.id})
 	d.firstPaint(sess2, ac1)
-	awaitFrame(t, sends1, ports.MsgOutput)
+	awaitFrame(t, sends1, wire.MsgOutput)
 	require.Same(t, sess2, ac1.currentSession())
 	for len(sends1) > 0 {
 		<-sends1
 	enteredSend := make(chan struct{})
 	releaseSend := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
-	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(ports.Frame) error {
+	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(wire.Frame) error {
 		close(enteredSend)
 		<-releaseSend
 		return nil
 	defer releasePTY()
 	d.enterPicker(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.resize(sess, ac, domain.Size{Cols: 100, Rows: 30})
 	// Picker recomposition is the relevant event here; do not depend on a real
 	// resize-idle timer in this synchronous rendering test.
 	d.paint(sess, ac, false, nil)
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "┌")
 	require.Contains(t, string(msg.Data), "Sessions")
 	d.ptys = ptys
 	d.enterPicker(from, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(from, ac, []byte("j"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(from, ac, []byte("\r"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	history := d.notices.history()
 	require.Len(t, history, 1, "failed stopped-session restore must record exactly one notice")
 	require.NoError(t, d.catalogue.Create(record))
 	d.enterPicker(from, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	// MRU-desc order is from(current), recent, older; "j" moves onto "recent".
 	d.handleInput(from, ac, []byte("j"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(from, ac, []byte("x"))
 	history := d.notices.history()
 	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp/stopped", createdAt: 7, incarnation: record.IncarnationID, record: record}
 	d.enterPicker(from, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(from, ac, []byte("j"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInput(from, ac, []byte("x"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	history := d.notices.history()
 	require.NotEmpty(t, history, "failed persisted-record delete must record a notice")

M internal/usecase/daemon/prompt_test.go +20 -19

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 type failingPTYFactory struct{ err error }
 	defer release()
 	d.enterPrompt(sess, ac, " Rename session ", "0", func(string) error { return nil })
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "Rename session")
 	require.Contains(t, string(msg.Data), "> 0")
 	sess.ephemeral = true
 	d.enterPrompt(sess, ac, " Rename session ", sess.name, func(name string) error { return d.renameSession(sess, name) })
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePromptInput(ac, []byte("work\r"))
-	repaint := awaitFrame(t, sends, ports.MsgOutput)
+	repaint := awaitFrame(t, sends, wire.MsgOutput)
 	require.False(t, ac.overlays.promptActive())
 	require.Equal(t, "0work", sess.name)
 	require.False(t, sess.ephemeral)
-	out, err := ports.UnmarshalOutput(repaint.Payload)
+	out, err := wire.UnmarshalOutput(repaint.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(out.Data), "0work")
 	require.NotContains(t, string(out.Data), "0work*")
 	d.sessions["other"] = &session{sessionCore: sessionCore{id: "other", name: "taken"}, ctx: ctx, cancel: cancel, tabs: []*tab{newTestTabWithContext(p2, ctx, cancel)}}
 	d.enterPrompt(sess, ac, " Rename session ", "", func(name string) error { return d.renameSession(sess, name) })
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePromptInput(ac, []byte("taken\r"))
-	repaint := awaitFrame(t, sends, ports.MsgOutput)
+	repaint := awaitFrame(t, sends, wire.MsgOutput)
 	require.True(t, ac.overlays.promptActive())
 	require.NotEqual(t, "taken", sess.name)
-	out, err := ports.UnmarshalOutput(repaint.Payload)
+	out, err := wire.UnmarshalOutput(repaint.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(out.Data), "name already in use")
 }
 	d.enterPrompt(sess, ac, " Create session ", "", func(name string) error {
 		return d.createSessionAndSwitch(sess, ac, name)
 	})
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePromptInput(ac, []byte("new\r"))
-	repaint := awaitFrame(t, sends, ports.MsgOutput)
+	repaint := awaitFrame(t, sends, wire.MsgOutput)
-	output, err := ports.UnmarshalOutput(repaint.Payload)
+	output, err := wire.UnmarshalOutput(repaint.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(output.Data), "couldn't create session: shell failed to start")
 			d.enterPrompt(sess, ac, " Create session ", "", func(name string) error {
 				return d.createSessionAndSwitch(sess, ac, name)
 			})
-			awaitFrame(t, sends, ports.MsgOutput)
+			awaitFrame(t, sends, wire.MsgOutput)
 			d.handlePromptInput(ac, tt.input)
-			repaint := awaitFrame(t, sends, ports.MsgOutput)
+			repaint := awaitFrame(t, sends, wire.MsgOutput)
-			output, err := ports.UnmarshalOutput(repaint.Payload)
+			output, err := wire.UnmarshalOutput(repaint.Payload)
 			require.NoError(t, err)
 			require.Contains(t, string(output.Data), tt.wantErr.Error())
 	oldName := sess.name
 	d.enterPrompt(sess, ac, " Rename session ", oldName, func(name string) error { return d.renameSession(sess, name) })
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePromptInput(ac, []byte("new\x1b"))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	require.False(t, ac.overlays.promptActive())
 	require.Equal(t, oldName, sess.name)
 	sess.ephemeral = true
 	d.enterPalette(sess, ac)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handlePaletteInput(ac, []byte("RNS\r"))
-	out := awaitFrame(t, sends, ports.MsgOutput)
+	out := awaitFrame(t, sends, wire.MsgOutput)
 	require.False(t, ac.overlays.paletteActive())
 	require.True(t, ac.overlays.promptActive())
-	msg, err := ports.UnmarshalOutput(out.Payload)
+	msg, err := wire.UnmarshalOutput(out.Payload)
 	require.NoError(t, err)
 	require.Contains(t, string(msg.Data), "Rename session")
 	require.Contains(t, string(msg.Data), "> 0")

M internal/usecase/daemon/recent_route_snapshot_test.go +6 -6

 	"testing"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 	ac.installTestAttachmentCapability(token)
 	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
-	payload, err := ports.MarshalRecentRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 2})
+	payload, err := wire.MarshalRecentRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 2})
 	require.NoError(t, err)
-	require.False(t, d.handleAttachmentClientFrame(token, ports.Frame{Type: ports.MsgRecentRouteSnapshot, Payload: payload}))
+	require.False(t, d.handleAttachmentClientFrame(token, wire.Frame{Type: wire.MsgRecentRouteSnapshot, Payload: payload}))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 }
 func TestAttachmentRouteSnapshotCopiesPublishedEntries(t *testing.T) {
 	var action protocol.RouteNavigationAction
 	found := false
 	for _, frame := range frames {
-		if frame.Type != ports.MsgNavigateRecentRoute {
+		if frame.Type != wire.MsgNavigateRecentRoute {
 			continue
 		}
 		var err error
-		action, err = ports.UnmarshalRouteNavigationAction(frame.Payload)
+		action, err = wire.UnmarshalRouteNavigationAction(frame.Payload)
 		require.NoError(t, err)
 		found = true
 	}

M internal/usecase/daemon/remote_attach.go +7 -6

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // routeRemoteTargetWithContext is the exact-target branch for picker handoffs.
 			effect.ac.clearParkedRoute()
 		}
 	}
-	payload := ports.MarshalNavigationDirective(directive)
+	payload := wire.MarshalNavigationDirective(directive)
 	if payload == nil {
 		rollback()
 		return errAttachmentTransition
 	}
-	if err := effect.sendControl(ports.Frame{Type: ports.MsgNavigationAction, Payload: payload}); err != nil {
+	if err := effect.sendControl(wire.Frame{Type: wire.MsgNavigationAction, Payload: payload}); err != nil {
 		rollback()
 		return err
 	}
 }
 func (d *Daemon) sendRecentRouteNavigationActionForAttachment(effect *attachmentEffect, action protocol.RouteNavigationAction) error {
-	payload, err := ports.MarshalRouteNavigationAction(action)
+	payload, err := wire.MarshalRouteNavigationAction(action)
 	if err != nil {
 		return errAttachmentTransition
 	}
-	return effect.sendControl(ports.Frame{Type: ports.MsgNavigateRecentRoute, Payload: payload})
+	return effect.sendControl(wire.Frame{Type: wire.MsgNavigateRecentRoute, Payload: payload})
 }
 func (d *Daemon) sendCommittedRouteIdentityForAttachment(effect *attachmentEffect) error {
 		Ephemeral: effect.sess.ephemeral,
 	}
 	effect.sess.mu.Unlock()
-	payload, err := ports.MarshalCommittedRouteIdentity(identity)
+	payload, err := wire.MarshalCommittedRouteIdentity(identity)
 	if err != nil {
 		return errAttachmentTransition
 	}
-	return effect.sendControl(ports.Frame{Type: ports.MsgCommittedRouteIdentity, Payload: payload})
+	return effect.sendControl(wire.Frame{Type: wire.MsgCommittedRouteIdentity, Payload: payload})
 }
 func (d *Daemon) finishRouteAttach(sess *session, tr ports.Transport, sz domain.Size, h protocol.Hello, routeCreated, purge bool) (*attachedClient, error) {

M internal/usecase/daemon/remote_attach_test.go +8 -7

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/picker"
 )
 	require.NoError(t, d.switchToTargetForAttachment(effect, picker.Target{Session: target.id}, sessionHandoffGuard{allowSamePeer: true}, "picker-select"))
 	frame := receiveRemotePicker(t, sends, "local attach target")
-	got, err := ports.UnmarshalAttachTarget(frame.Payload)
+	got, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	require.Empty(t, got.Endpoint)
 	require.Equal(t, protocol.IntentAttach, got.Intent)
 	}, sessionHandoffGuard{closePicker: true, allowSamePeer: true}, "picker-select"))
 	cleanup := receiveRemotePicker(t, sends, "graphics cleanup")
-	require.Equal(t, ports.MsgOutput, cleanup.Type)
+	require.Equal(t, wire.MsgOutput, cleanup.Type)
 	handoff := receiveRemotePicker(t, sends, "stopped local attach target")
-	require.Equal(t, ports.MsgAttachTarget, handoff.Type)
+	require.Equal(t, wire.MsgAttachTarget, handoff.Type)
-	target, err := ports.UnmarshalAttachTarget(handoff.Payload)
+	target, err := wire.UnmarshalAttachTarget(handoff.Payload)
 	require.NoError(t, err)
 	require.False(t, target.SamePeer)
 	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "stopped"}, target.ExactTarget)
 	target := picker.Target{Session: key.ID(), RemoteKey: &key, RemoteTarget: &remoteTarget, TabID: "tab-1"}
 	require.NoError(t, d.sendRemoteAttachTargetForAttachment(effect, target, sessionHandoffGuard{closePicker: true}, "picker-select"))
 	frame := receiveRemotePicker(t, sends, "rich attach target")
-	got, err := ports.UnmarshalAttachTarget(frame.Payload)
+	got, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	require.NotNil(t, got.RemoteTarget)
 	require.Equal(t, remoteTarget, *got.RemoteTarget)
 			for {
 				select {
 				case frame := <-sends:
-					require.NotEqual(t, ports.MsgAttachTarget, frame.Type)
+					require.NotEqual(t, wire.MsgAttachTarget, frame.Type)
 				default:
 					return
 				}
 	for {
 		select {
 		case frame := <-sends:
-			require.NotEqual(t, ports.MsgAttachTarget, frame.Type, "rejected handoff must not send an attach target")
+			require.NotEqual(t, wire.MsgAttachTarget, frame.Type, "rejected handoff must not send an attach target")
 		default:
 			return
 		}

M internal/usecase/daemon/remote_picker_test.go +9 -8

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/picker"
 )
 	require.NoError(t, d.sendRemoteAttachTargetForAttachment(effect, target, sessionHandoffGuard{closePicker: true}, "picker-select"))
 	frame := receiveRemotePicker(t, sends, "attach target")
-	require.Equal(t, ports.MsgAttachTarget, frame.Type)
+	require.Equal(t, wire.MsgAttachTarget, frame.Type)
-	got, err := ports.UnmarshalAttachTarget(frame.Payload)
+	got, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.AttachTarget{Endpoint: "arch", Session: "work", Intent: protocol.IntentAttach, RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, got)
 	require.Nil(t, ac.currentAttachmentSession())
 	require.NoError(t, local.sendRemoteAttachTargetForAttachment(effect, selected, sessionHandoffGuard{closePicker: true}, "picker-select"))
 	frame := receiveRemotePicker(t, sends, "stopped remote target")
-	handoff, err := ports.UnmarshalAttachTarget(frame.Payload)
+	handoff, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	require.NotNil(t, handoff.RemoteTarget)
 	require.Equal(t, selected.RemoteTarget, handoff.RemoteTarget)
 	require.NoError(t, local.sendRemoteAttachTargetForAttachment(effect, selected, sessionHandoffGuard{closePicker: true}, "picker-select"))
 	frame := receiveRemotePicker(t, sends, "stopped remote target without tab metadata")
-	handoff, err := ports.UnmarshalAttachTarget(frame.Payload)
+	handoff, err := wire.UnmarshalAttachTarget(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, selected.RemoteTarget, handoff.RemoteTarget)
 			defer effect.End()
 			require.NoError(t, d.sendNavigationActionForAttachment(effect, tt.action))
 			frame := receiveRemotePicker(t, sends, "navigation action")
-			require.Equal(t, ports.MsgNavigationAction, frame.Type)
+			require.Equal(t, wire.MsgNavigationAction, frame.Type)
-			directive, err := ports.UnmarshalNavigationDirective(frame.Payload)
+			directive, err := wire.UnmarshalNavigationDirective(frame.Payload)
 			require.NoError(t, err)
 			require.Equal(t, tt.action, directive.Action)
 			if tt.action == protocol.NavigationOpenHomePicker {
 	require.Same(t, sess, ac.currentAttachmentSession())
 }
-func addRemoteRefreshPickerOwner(t *testing.T, d *Daemon, id domain.SessionID, transports ...ports.Transport) (*session, *attachedClient, chan ports.Frame) {
+func addRemoteRefreshPickerOwner(t *testing.T, d *Daemon, id domain.SessionID, transports ...ports.Transport) (*session, *attachedClient, chan wire.Frame) {
 	t.Helper()
 	var tr ports.Transport
-	var sends chan ports.Frame
+	var sends chan wire.Frame
 	if len(transports) != 0 {
 		tr = transports[0]
 	} else {

M internal/usecase/daemon/remote_preview.go +6 -5

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
-func (d *Daemon) handleRemotePreview(tr ports.Transport, frame ports.Frame) error {
+func (d *Daemon) handleRemotePreview(tr ports.Transport, frame wire.Frame) error {
 	defer func() { _ = tr.Close() }()
-	request, err := ports.UnmarshalRemotePreviewRequest(frame.Payload)
+	request, err := wire.UnmarshalRemotePreviewRequest(frame.Payload)
 	if err != nil {
 		return d.sendRemotePreview(tr, protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewMalformed})
 	}
 }
 func (d *Daemon) sendRemotePreview(tr ports.Transport, preview protocol.RemotePreview) error {
-	payload := ports.MarshalRemotePreview(preview)
+	payload := wire.MarshalRemotePreview(preview)
 	if payload == nil {
-		payload = ports.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewMalformed})
+		payload = wire.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewMalformed})
 	}
-	return d.boundedControlSend(tr, ports.Frame{Type: ports.MsgRemotePreviewResponse, Payload: payload})
+	return d.boundedControlSend(tr, wire.Frame{Type: wire.MsgRemotePreviewResponse, Payload: payload})
 }
 var errRemotePreviewNoSuchTarget = errors.New("daemon: remote preview target does not exist")

M internal/usecase/daemon/render_coordinator_handshake_test.go +7 -7


@@ -9,13 +9,13 @@ import (
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10			10
11		"github.com/bnema/vev/internal/domain"	11		"github.com/bnema/vev/internal/domain"
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol/wire"
13		)	13		)
14			14
15		// fanoutBlockingTransport blocks only the first output send. The paired	15		// fanoutBlockingTransport blocks only the first output send. The paired
16		// healthy attachment must still receive its frame while this peer is stuck.	16		// healthy attachment must still receive its frame while this peer is stuck.
17		type fanoutBlockingTransport struct {	17		type fanoutBlockingTransport struct {
18	-	sent chan ports.Frame	18	+	sent chan wire.Frame
19		entered chan struct{}	19		entered chan struct{}
20		release chan struct{}	20		release chan struct{}
21		done chan struct{}	21		done chan struct{}

@@ -26,16 +26,16 @@ type fanoutBlockingTransport struct {
26			26
27		func newFanoutBlockingTransport() *fanoutBlockingTransport {	27		func newFanoutBlockingTransport() *fanoutBlockingTransport {
28		return &fanoutBlockingTransport{	28		return &fanoutBlockingTransport{
29	-	sent: make(chan ports.Frame, 8),	29	+	sent: make(chan wire.Frame, 8),
30		entered: make(chan struct{}),	30		entered: make(chan struct{}),
31		release: make(chan struct{}),	31		release: make(chan struct{}),
32		done: make(chan struct{}),	32		done: make(chan struct{}),
33		}	33		}
34		}	34		}
35			35
36	-	func (t *fanoutBlockingTransport) Send(frame ports.Frame) error {	36	+	func (t *fanoutBlockingTransport) Send(frame wire.Frame) error {
37		t.sent <- frame	37		t.sent <- frame
38	-	if frame.Type == ports.MsgOutput {	38	+	if frame.Type == wire.MsgOutput {
39		t.enteredOne.Do(func() { close(t.entered) })	39		t.enteredOne.Do(func() { close(t.entered) })
40		<-t.release	40		<-t.release
41		}	41		}

@@ -43,7 +43,7 @@ func (t *fanoutBlockingTransport) Send(frame ports.Frame) error {
43		return nil	43		return nil
44		}	44		}
45			45
46	-	func (t *fanoutBlockingTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }	46	+	func (t *fanoutBlockingTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
47			47
48		func (t *fanoutBlockingTransport) Close() error {	48		func (t *fanoutBlockingTransport) Close() error {
49		t.releaseOne.Do(func() { close(t.release) })	49		t.releaseOne.Do(func() { close(t.release) })

@@ -102,7 +102,7 @@ func TestRenderCoordinatorFanoutDoesNotWaitForSlowTransport(t *testing.T) {
102			102
103		select {	103		select {
104		case frame := <-healthySends:	104		case frame := <-healthySends:
105	-	require.Equal(t, ports.MsgOutput, frame.Type, "healthy attachment did not receive output")	105	+	require.Equal(t, wire.MsgOutput, frame.Type, "healthy attachment did not receive output")
106		case <-time.After(2 * time.Second):	106		case <-time.After(2 * time.Second):
107		t.Fatal("healthy attachment remained blocked behind the slow transport")	107		t.Fatal("healthy attachment remained blocked behind the slow transport")
108		}	108		}

M internal/usecase/daemon/render_coordinator_test.go +4 -3

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 	}
 }
-func requireNoCoordinatorOutputFrame(t *testing.T, sends chan ports.Frame) {
+func requireNoCoordinatorOutputFrame(t *testing.T, sends chan wire.Frame) {
 	t.Helper()
 	for {
 		select {
 		case frame := <-sends:
-			if frame.Type == ports.MsgRoutePosition {
+			if frame.Type == wire.MsgRoutePosition {
 				continue
 			}
 			t.Fatalf("unexpected output frame: %+v", frame)
 }
 func TestRenderCoordinatorResizeEpochDispatch(t *testing.T) {
-	newResizeFixture := func(t *testing.T) (*Daemon, *session, *attachedClient, chan ports.Frame, *coordinatorMockClock, chan renderInvalidation) {
+	newResizeFixture := func(t *testing.T) (*Daemon, *session, *attachedClient, chan wire.Frame, *coordinatorMockClock, chan renderInvalidation) {
 		t.Helper()
 		p, releasePTY := newBlockingPTY(t)
 		t.Cleanup(releasePTY)

M internal/usecase/daemon/render_damage_receipt_test.go +3 -2

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/picker"
 	"github.com/stretchr/testify/require"
 			state, composed = captureComposeForReceiptTest(t, sess, ac)
 			require.True(t, d.emitFrame(sess, ac, state, composed))
 			frame := <-sends
-			out, err := ports.UnmarshalOutput(frame.Payload)
+			out, err := wire.UnmarshalOutput(frame.Payload)
 			require.NoError(t, err)
 			require.Contains(t, string(out.Data), "changed", "retry must emit the retained terminal bytes")
 			p.mu.Lock()
 		require.True(t, d.emitFrame(sess, ac, state, composed))
 		require.Len(t, d.notices.history(), want)
 		frame := <-sends
-		require.Equal(t, ports.MsgOutput, frame.Type, "outer failure %d must repaint its notice", want)
+		require.Equal(t, wire.MsgOutput, frame.Type, "outer failure %d must repaint its notice", want)
 		require.False(t, ac.prepareFailureFallback.Load())
 	}
 }

M internal/usecase/daemon/render_pipeline.go +3 -2

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/notices"
 	"github.com/bnema/vev/internal/usecase/palette"
 		}
 		if position.ActiveTabID != "" && position != ac.output.lastRoutePosition {
-			payload, positionMarshalErr := ports.MarshalRoutePosition(position)
+			payload, positionMarshalErr := wire.MarshalRoutePosition(position)
 			if positionMarshalErr != nil {
 				d.log.Error("marshal route position", "err", positionMarshalErr)
 			} else {
 						if async, ok := sendTr.(ports.AsyncTransport); ok {
 							send = async.SendAsync
 						}
-						sendErr = send(ports.Frame{Type: ports.MsgRoutePosition, Payload: payload})
+						sendErr = send(wire.Frame{Type: wire.MsgRoutePosition, Payload: payload})
 					}
 				}
 				if marks.attachmentEffect != nil && interruptible {

M internal/usecase/daemon/render_pipeline_cache_test.go +5 -5


@@ -8,7 +8,7 @@ import (
8			8
9		renderer "github.com/bnema/vev-vt"	9		renderer "github.com/bnema/vev-vt"
10		"github.com/bnema/vev/internal/domain"	10		"github.com/bnema/vev/internal/domain"
11	-	"github.com/bnema/vev/internal/ports"	11	+	"github.com/bnema/vev/internal/protocol/wire"
12		"github.com/bnema/vev/internal/usecase/layout"	12		"github.com/bnema/vev/internal/usecase/layout"
13		themeui "github.com/bnema/vev/internal/usecase/theme"	13		themeui "github.com/bnema/vev/internal/usecase/theme"
14		"github.com/bnema/vev/internal/usecase/ui"	14		"github.com/bnema/vev/internal/usecase/ui"

@@ -17,9 +17,9 @@ import (
17			17
18		type cacheFailTransport struct{}	18		type cacheFailTransport struct{}
19			19
20	-	func (cacheFailTransport) Send(ports.Frame) error { return errors.New("send failed") }	20	+	func (cacheFailTransport) Send(wire.Frame) error { return errors.New("send failed") }
21	-	func (cacheFailTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }	21	+	func (cacheFailTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
22	-	func (cacheFailTransport) Close() error { return nil }	22	+	func (cacheFailTransport) Close() error { return nil }
23			23
24		func TestPipelineCachePublishesOnlyAfterEmission(t *testing.T) {	24		func TestPipelineCachePublishesOnlyAfterEmission(t *testing.T) {
25		for _, failure := range []struct {	25		for _, failure := range []struct {

@@ -69,7 +69,7 @@ func TestPipelineCachePublishesOnlyAfterEmission(t *testing.T) {
69		require.True(t, d.emitFrame(sess, ac, &state, pending))	69		require.True(t, d.emitFrame(sess, ac, &state, pending))
70		require.Equal(t, pending.cache, ac.pipelineCache)	70		require.Equal(t, pending.cache, ac.pipelineCache)
71		frame := <-sends	71		frame := <-sends
72	-	output, err := ports.UnmarshalOutput(frame.Payload)	72	+	output, err := wire.UnmarshalOutput(frame.Payload)
73		require.NoError(t, err)	73		require.NoError(t, err)
74		require.Contains(t, string(output.Data), "next", "the retry must emit state retained after the failed emission")	74		require.Contains(t, string(output.Data), "next", "the retry must emit state retained after the failed emission")
75		})	75		})

M internal/usecase/daemon/render_pipeline_test.go +10 -10


@@ -14,7 +14,7 @@ import (
14		vt "github.com/bnema/vev-vt"	14		vt "github.com/bnema/vev-vt"
15		renderer "github.com/bnema/vev-vt/ansi"	15		renderer "github.com/bnema/vev-vt/ansi"
16		"github.com/bnema/vev/internal/domain"	16		"github.com/bnema/vev/internal/domain"
17	-	"github.com/bnema/vev/internal/ports"	17	+	"github.com/bnema/vev/internal/protocol/wire"
18		"github.com/bnema/vev/internal/testutil/replaytest"	18		"github.com/bnema/vev/internal/testutil/replaytest"
19		scopy "github.com/bnema/vev/internal/usecase/copy"	19		scopy "github.com/bnema/vev/internal/usecase/copy"
20		"github.com/bnema/vev/internal/usecase/layout"	20		"github.com/bnema/vev/internal/usecase/layout"

@@ -32,11 +32,11 @@ import (
32		// assertions must not depend on any adapter's framing implementation.	32		// assertions must not depend on any adapter's framing implementation.
33		type scriptedReplayTransport struct {	33		type scriptedReplayTransport struct {
34		t *testing.T	34		t *testing.T
35	-	frames []ports.Frame	35	+	frames []wire.Frame
36		next int	36		next int
37		}	37		}
38			38
39	-	func (s *scriptedReplayTransport) Send(got ports.Frame) error {	39	+	func (s *scriptedReplayTransport) Send(got wire.Frame) error {
40		s.t.Helper()	40		s.t.Helper()
41		if s.next >= len(s.frames) {	41		if s.next >= len(s.frames) {
42		s.t.Errorf("unexpected frame %#v", got)	42		s.t.Errorf("unexpected frame %#v", got)

@@ -48,8 +48,8 @@ func (s *scriptedReplayTransport) Send(got ports.Frame) error {
48		require.Equal(s.t, want.Payload, got.Payload)	48		require.Equal(s.t, want.Payload, got.Payload)
49		return nil	49		return nil
50		}	50		}
51	-	func (*scriptedReplayTransport) Recv() (ports.Frame, error) { return ports.Frame{}, io.EOF }	51	+	func (*scriptedReplayTransport) Recv() (wire.Frame, error) { return wire.Frame{}, io.EOF }
52	-	func (*scriptedReplayTransport) Close() error { return nil }	52	+	func (*scriptedReplayTransport) Close() error { return nil }
53			53
54		func TestTransportReplayFinalShadowAndTerminalBytes(t *testing.T) {	54		func TestTransportReplayFinalShadowAndTerminalBytes(t *testing.T) {
55		frames := replaytest.Transcript()	55		frames := replaytest.Transcript()

@@ -57,7 +57,7 @@ func TestTransportReplayFinalShadowAndTerminalBytes(t *testing.T) {
57		terminal := vt.NewScreen(8, 3)	57		terminal := vt.NewScreen(8, 3)
58		for _, frame := range frames {	58		for _, frame := range frames {
59		require.NoError(t, transport.Send(frame))	59		require.NoError(t, transport.Send(frame))
60	-	output, err := ports.UnmarshalOutput(frame.Payload)	60	+	output, err := wire.UnmarshalOutput(frame.Payload)
61		require.NoError(t, err)	61		require.NoError(t, err)
62		require.Equal(t, frame.Payload, mustMarshalOutput(output), "output payload must remain byte exact")	62		require.Equal(t, frame.Payload, mustMarshalOutput(output), "output payload must remain byte exact")
63		terminal.Write(output.Data)	63		terminal.Write(output.Data)

@@ -253,7 +253,7 @@ func TestEmitFrameFailedSendDoesNotPublishCursorOrOutputState(t *testing.T) {
253		require.True(t, d.emitFrame(sess, ac, &state, composed))	253		require.True(t, d.emitFrame(sess, ac, &state, composed))
254		require.Equal(t, cursorOut{valid: true, row: 3, col: 4, style: 2, hasStyle: true}, ac.output.lastCursor)	254		require.Equal(t, cursorOut{valid: true, row: 3, col: 4, style: 2, hasStyle: true}, ac.output.lastCursor)
255		require.Equal(t, uint64(1), ac.output.next)	255		require.Equal(t, uint64(1), ac.output.next)
256	-	out, err := ports.UnmarshalOutput((<-sends).Payload)	256	+	out, err := wire.UnmarshalOutput((<-sends).Payload)
257		require.NoError(t, err)	257		require.NoError(t, err)
258		require.Zero(t, out.Base)	258		require.Zero(t, out.Base)
259		require.Equal(t, uint64(1), out.New)	259		require.Equal(t, uint64(1), out.New)

@@ -332,12 +332,12 @@ func TestComposeEmitExactReplayTiledFloatingBarsOverlayAndCursor(t *testing.T) {
332		stream := newOutputStateStream()	332		stream := newOutputStateStream()
333		prepared, err := stream.prepareFrame(nil, &state, composed.frame, composed.damage, composed.reset, composed.cursor)	333		prepared, err := stream.prepareFrame(nil, &state, composed.frame, composed.damage, composed.reset, composed.cursor)
334		require.NoError(t, err)	334		require.NoError(t, err)
335	-	var outputFrame ports.Frame	335	+	var outputFrame wire.Frame
336	-	require.NoError(t, prepared.send(0, func(frame ports.Frame) error {	336	+	require.NoError(t, prepared.send(0, func(frame wire.Frame) error {
337		outputFrame = frame	337		outputFrame = frame
338		return nil	338		return nil
339		}))	339		}))
340	-	output, err := ports.UnmarshalOutput(outputFrame.Payload)	340	+	output, err := wire.UnmarshalOutput(outputFrame.Payload)
341		require.NoError(t, err)	341		require.NoError(t, err)
342		terminalBytes := output.Data	342		terminalBytes := output.Data
343		require.Equal(t, "\x1b[1;1H\x1b[0;7m tab \x1b[0m R\x1b[2;1HAAAAAAAAAAAA\x1b[3;1HBBB┌─fl─┐BBB\x1b[4;1H───Prompt───\x1b[5;1HPROMPT\x1b[K\x1b[B\x1b[2K\x1b[7;1H\x1b[0;7m sess \x1b[0m B\x1b[0m\x1b[?25l", string(terminalBytes))	343		require.Equal(t, "\x1b[1;1H\x1b[0;7m tab \x1b[0m R\x1b[2;1HAAAAAAAAAAAA\x1b[3;1HBBB┌─fl─┐BBB\x1b[4;1H───Prompt───\x1b[5;1HPROMPT\x1b[K\x1b[B\x1b[2K\x1b[7;1H\x1b[0;7m sess \x1b[0m B\x1b[0m\x1b[?25l", string(terminalBytes))

M internal/usecase/daemon/render_test.go +26 -26

 	vt "github.com/bnema/vev-vt"
 	renderer "github.com/bnema/vev-vt/ansi"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	pane.screen.Write([]byte("\x1b[38;2;180;90;30mX"))
 	d.enterCopyMode(sess, ac)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	undimmed := client.Frame.At(0, 1)
 	require.Equal(t, 'X', undimmed.Rune, "fixture must address copy-mode pane content")
 	copyBar := append([]renderer.Cell(nil), client.Frame.Row(client.Frame.Height-1)...)
 	require.Contains(t, rowText(copyBar), "[SCROLL]", "fixture must capture the copy status bar")
 	d.enterPalette(sess, ac)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	dimmed := client.Frame.At(0, 1)
 	require.Equal(t, undimmed.Rune, dimmed.Rune, "palette backdrop must preserve copy content")
 	require.Equal(t, themeui.NewDimmer(theme).Dim(undimmed.Style), dimmed.Style, "palette backdrop must dim the composed copy frame")
 			d.firstPaint(sess, ac)
-			frame := awaitFrame(t, sends, ports.MsgOutput)
+			frame := awaitFrame(t, sends, wire.MsgOutput)
-			output, err := ports.UnmarshalOutput(frame.Payload)
+			output, err := wire.UnmarshalOutput(frame.Payload)
 			require.NoError(t, err)
 			require.Zero(t, output.Base, "first paint must be a mandatory reset")
 			select {
 	pane.screen.Write([]byte("X"))
 	d.enterPicker(sess, ac)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	pickerTitle := client.Frame.At(31, 2)
 	require.Equal(t, 'S', pickerTitle.Rune, "fixture must address the picker title")
 	undimmedPane := client.Frame.At(0, 1)
 	d.enterPalette(sess, ac)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	dimmedPickerTitle := pickerTitle
 	dimmedPickerTitle.Style = themeui.NewDimmer(backdropTheme()).Dim(pickerTitle.Style)
 	require.Equal(t, dimmedPickerTitle, client.Frame.At(31, 2), "the lower-priority picker must be part of the palette backdrop")
 	pane := sess.tabs[0].focusedPane()
 	pane.screen.Write([]byte("X"))
 	d.paint(sess, ac, true, nil)
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	undimmed := client.Frame.At(0, 1)
 	topBar := client.Frame.At(0, 0)
 	bottomBar := client.Frame.At(0, 24)
 	d.handleInput(sess, ac, []byte("\x1b "))
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	dimmed := client.Frame.At(0, 1)
 	require.Equal(t, 'X', dimmed.Rune)
 	require.Equal(t, themeui.NewDimmer(backdropTheme()).Dim(undimmed.Style), dimmed.Style, "open palette must use the theme dim style")
 	require.Equal(t, dimmedBottomBar, client.Frame.At(0, 24), "bottom chrome is part of the complete backdrop")
 	d.handleInput(sess, ac, []byte("\x1b"))
-	mustApplyOutput(t, client, awaitFrame(t, sends, ports.MsgOutput))
+	mustApplyOutput(t, client, awaitFrame(t, sends, wire.MsgOutput))
 	require.Equal(t, undimmed, client.Frame.At(0, 1), "full redraw restores pane rune and style")
 	require.Equal(t, topBar, client.Frame.At(0, 0))
 	require.Equal(t, bottomBar, client.Frame.At(0, 24))
 	<-processed
 }
-func awaitOutputFrameWithoutSleep(t *testing.T, sends <-chan ports.Frame) ports.Frame {
+func awaitOutputFrameWithoutSleep(t *testing.T, sends <-chan wire.Frame) wire.Frame {
 	t.Helper()
 	frame := <-sends
-	require.Equal(t, ports.MsgOutput, frame.Type)
+	require.Equal(t, wire.MsgOutput, frame.Type)
 	return frame
 }
 		awaitPTYReadProcessed(t, inactiveProcessed)
 		fireCoordinatorTimer(t, rc, drainCoordinatorTimers(clock), urgentRenderDeadline)
 		frame := awaitOutputFrameWithoutSleep(t, sends)
-		output, err := ports.UnmarshalOutput(frame.Payload)
+		output, err := wire.UnmarshalOutput(frame.Payload)
 		require.NoError(t, err)
 		require.Contains(t, string(output.Data), "partial complete")
 		requireNoCoordinatorOutputFrame(t, sends)
 		awaitPTYReadProcessed(t, newProcessed)
 		fireCoordinatorTimer(t, rc, drainCoordinatorTimers(clock), minOutputRenderDeadline)
 		frame := awaitOutputFrameWithoutSleep(t, sends)
-		output, err := ports.UnmarshalOutput(frame.Payload)
+		output, err := wire.UnmarshalOutput(frame.Payload)
 		require.NoError(t, err)
 		require.Contains(t, string(output.Data), "newly active")
 		require.NotContains(t, string(output.Data), "old partial")
 }
 func TestNonRenderablePaneDamageRemainsPendingForCapture(t *testing.T) {
-	newFixture := func(t *testing.T) (*Daemon, *session, *tab, *pane, chan ports.Frame) {
+	newFixture := func(t *testing.T) (*Daemon, *session, *tab, *pane, chan wire.Frame) {
 		t.Helper()
 		p, release := newBlockingPTY(t)
 		t.Cleanup(release)
 	d.handleInput(sess, ac, []byte("CLT\r"))
 	require.Equal(t, 0, sessionCount(d))
-	f := awaitFrame(t, sends, ports.MsgDetached)
+	f := awaitFrame(t, sends, wire.MsgDetached)
-	det, err := ports.UnmarshalDetached(f.Payload)
+	det, err := wire.UnmarshalDetached(f.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ReasonSessionKilled, det.Reason)
 }
 	require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2*time.Second, 5*time.Millisecond)
 	require.Equal(t, 1, sessionCount(d))
 	require.Equal(t, 0, testAttachmentTabIndex(sess))
-	f := awaitFrame(t, sends, ports.MsgOutput)
+	f := awaitFrame(t, sends, wire.MsgOutput)
-	out, err := ports.UnmarshalOutput(f.Payload)
+	out, err := wire.UnmarshalOutput(f.Payload)
 	require.NoError(t, err)
 	data := string(out.Data)
 	require.Contains(t, data, "remaining")
 	require.Eventually(t, func() bool { return tabCount(sess) == 1 }, 2*time.Second, 5*time.Millisecond)
 	require.Equal(t, 1, sessionCount(d))
 	require.Equal(t, 0, testAttachmentTabIndex(sess))
-	f := awaitFrame(t, sends, ports.MsgOutput)
+	f := awaitFrame(t, sends, wire.MsgOutput)
-	out, err := ports.UnmarshalOutput(f.Payload)
+	out, err := wire.UnmarshalOutput(f.Payload)
 	require.NoError(t, err)
 	data := string(out.Data)
 	require.Contains(t, data, "active")
 	releases[0]()
 	require.Eventually(t, func() bool { return sessionCount(d) == 0 }, 2*time.Second, 5*time.Millisecond)
-	f := awaitFrame(t, sends, ports.MsgDetached)
+	f := awaitFrame(t, sends, wire.MsgDetached)
-	det, err := ports.UnmarshalDetached(f.Payload)
+	det, err := wire.UnmarshalDetached(f.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ReasonSessionKilled, det.Reason)
 	var gotOutput atomic.Bool
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Close().Return(nil).Maybe()
-	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f wire.Frame) error {
-		if f.Type == ports.MsgOutput {
+		if f.Type == wire.MsgOutput {
 			gotOutput.Store(true)
 		}
 		return nil
 	}
 	select {
 	case f := <-sends:
-		require.NotEqual(t, ports.MsgOutput, f.Type)
+		require.NotEqual(t, wire.MsgOutput, f.Type)
 	default:
 	}
 }

M internal/usecase/daemon/resume_test.go +24 -23

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 type closeTrackingTransport struct {
 	mu     sync.Mutex
 	closed bool
-	sends  []ports.Frame
+	sends  []wire.Frame
 }
-func (t *closeTrackingTransport) Send(f ports.Frame) error {
+func (t *closeTrackingTransport) Send(f wire.Frame) error {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	t.sends = append(t.sends, f)
 	return nil
 }
-func (t *closeTrackingTransport) Recv() (ports.Frame, error) {
+func (t *closeTrackingTransport) Recv() (wire.Frame, error) {
-	return ports.Frame{}, errors.New("closed")
+	return wire.Frame{}, errors.New("closed")
 }
 func (t *closeTrackingTransport) Close() error {
 	t.mu.Lock()
 	return t.closed
 }
-func (t *closeTrackingTransport) Sends() []ports.Frame {
+func (t *closeTrackingTransport) Sends() []wire.Frame {
 	t.mu.Lock()
 	defer t.mu.Unlock()
-	return append([]ports.Frame(nil), t.sends...)
+	return append([]wire.Frame(nil), t.sends...)
 }
 type closeCountingBlockedTransport struct {
 	return &closeCountingBlockedTransport{closed: make(chan struct{})}
 }
-func (t *closeCountingBlockedTransport) Send(ports.Frame) error {
+func (t *closeCountingBlockedTransport) Send(wire.Frame) error {
 	<-t.closed
 	return errors.New("closed")
 }
-func (t *closeCountingBlockedTransport) Recv() (ports.Frame, error) {
+func (t *closeCountingBlockedTransport) Recv() (wire.Frame, error) {
-	return ports.Frame{}, errors.New("closed")
+	return wire.Frame{}, errors.New("closed")
 }
 func (t *closeCountingBlockedTransport) Close() error {
 	done := make(chan struct{})
 	resumeHello := helloResumeCapable(protocol.IntentResume, sess.name, token)
 	go func() {
-		d.handleHello(tr.tr, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(resumeHello)})
+		d.handleHello(tr.tr, wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(resumeHello)})
 		close(done)
 	}()
 	<-tr.welcomeEntered
 	handshakeTimer := awaitHandshakeTimer(t, clock)
 	welcome := <-tr.sends
-	require.Equal(t, ports.MsgWelcome, welcome.Type)
+	require.Equal(t, wire.MsgWelcome, welcome.Type)
 	sess.mu.Lock()
 	resumed := sess.snapshotAttachmentsLocked()[0]
 	sess.mu.Unlock()
 	requireNoCoordinatorOutputFrame(t, tr.sends)
 	tr.release()
-	output := awaitFrame(t, tr.sends, ports.MsgOutput)
+	output := awaitFrame(t, tr.sends, wire.MsgOutput)
-	first, err := ports.UnmarshalOutput(output.Payload)
+	first, err := wire.UnmarshalOutput(output.Payload)
 	require.NoError(t, err)
 	require.Zero(t, first.Base)
 	tr.finish()
 	f := outputStateFrame(ac.output, []byte("incremental while reliable backlog drains"), reset, 0)
 	ac.sendMu.Unlock()
-	out, err := ports.UnmarshalOutput(f.Payload)
+	out, err := wire.UnmarshalOutput(f.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(5), out.Base, "output should remain incremental unless an explicit reset is requested")
 	require.Equal(t, uint64(6), out.New)
 	require.True(t, reset, "explicit reset should still force full repaint")
 	full := outputStateFrame(ac.output, []byte("explicit full repaint"), reset, 0)
 	ac.sendMu.Unlock()
-	fullOut, err := ports.UnmarshalOutput(full.Payload)
+	fullOut, err := wire.UnmarshalOutput(full.Payload)
 	require.NoError(t, err)
 	require.Equal(t, uint64(0), fullOut.Base)
 	require.Equal(t, uint64(7), fullOut.New)
 	require.Same(t, ac, resumedAC)
 	d.paint(resumedSess, resumedAC, true, nil)
-	sends := testFramesOfType(newTr.Sends(), ports.MsgOutput)
+	sends := testFramesOfType(newTr.Sends(), wire.MsgOutput)
 	require.Len(t, sends, 1)
-	first, err := ports.UnmarshalOutput(sends[0].Payload)
+	first, err := wire.UnmarshalOutput(sends[0].Payload)
 	require.NoError(t, err)
 	require.Zero(t, first.Base)
 	require.Equal(t, uint64(1), first.New)
 	resumedSess.tabs[0].focusedPane().screen.Write([]byte("A"))
 	d.paint(resumedSess, resumedAC, false, nil)
-	sends = testFramesOfType(newTr.Sends(), ports.MsgOutput)
+	sends = testFramesOfType(newTr.Sends(), wire.MsgOutput)
 	require.Len(t, sends, 2)
-	second, err := ports.UnmarshalOutput(sends[1].Payload)
+	second, err := wire.UnmarshalOutput(sends[1].Payload)
 	require.NoError(t, err)
 	require.Equal(t, first.New, second.Base)
 }
 	require.True(t, resumedSess.renderCoordinator().markAttachmentReady(resumedSess.renderCoordinator().attachmentLease(resumedAC)))
 	d.firstPaint(resumedSess, resumedAC)
-	sends := testFramesOfType(newTransport.Sends(), ports.MsgOutput)
+	sends := testFramesOfType(newTransport.Sends(), wire.MsgOutput)
 	require.Len(t, sends, 1)
-	output, err := ports.UnmarshalOutput(sends[0].Payload)
+	output, err := wire.UnmarshalOutput(sends[0].Payload)
 	require.NoError(t, err)
 	require.Zero(t, output.Base, "resume must start with a complete frame")
 	terminal := vt.NewScreen(resumedAC.size.Cols, resumedAC.size.Rows)
 	sends := tr.Sends()
 	require.Len(t, sends, 2)
-	first, err := ports.UnmarshalOutput(sends[0].Payload)
+	first, err := wire.UnmarshalOutput(sends[0].Payload)
 	require.NoError(t, err)
-	second, err := ports.UnmarshalOutput(sends[1].Payload)
+	second, err := wire.UnmarshalOutput(sends[1].Payload)
 	require.NoError(t, err)
 	require.Zero(t, first.Base)
 	require.Zero(t, first.New)

M internal/usecase/daemon/route_position_test.go +3 -3

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestRouteAppliesPreferredTabPerAttachment(t *testing.T) {
 	var positions []protocol.RoutePosition
 	for _, frame := range tr.Sends() {
-		if frame.Type != ports.MsgRoutePosition {
+		if frame.Type != wire.MsgRoutePosition {
 			continue
 		}
-		position, err := ports.UnmarshalRoutePosition(frame.Payload)
+		position, err := wire.UnmarshalRoutePosition(frame.Payload)
 		require.NoError(t, err)
 		positions = append(positions, position)
 	}

M internal/usecase/daemon/same_peer_switch.go +3 -3

 import (
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func (ac *attachedClient) offerSamePeerTarget(target protocol.ExactSessionTarget) {
 		}
 		defer sender.End()
 	}
-	payload, err := ports.MarshalSamePeerSwitchFailure(protocol.SamePeerSwitchFailure{RequestID: requestID, Code: code})
+	payload, err := wire.MarshalSamePeerSwitchFailure(protocol.SamePeerSwitchFailure{RequestID: requestID, Code: code})
 	if err != nil {
 		return
 	}
-	if err := sender.sendControl(ports.Frame{Type: ports.MsgSamePeerSwitchFailure, Payload: payload}); err != nil {
+	if err := sender.sendControl(wire.Frame{Type: wire.MsgSamePeerSwitchFailure, Payload: payload}); err != nil {
 		d.detachOnAttachmentSendError(sender.capability(), sender.transport.transport)
 	}
 }

M internal/usecase/daemon/same_peer_switch_test.go +10 -10

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestPaletteSessionSelectionCompletesSamePeerSwitch(t *testing.T) {
 	token := beginRecentRoutePaletteEffect(t, d, source, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	d.handleInputForAttachment(token, []byte("target\r"))
-	targetFrame := awaitFrame(t, sends, ports.MsgAttachTarget)
+	targetFrame := awaitFrame(t, sends, wire.MsgAttachTarget)
-	attachTarget, err := ports.UnmarshalAttachTarget(targetFrame.Payload)
+	attachTarget, err := wire.UnmarshalAttachTarget(targetFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, attachTarget.ExactTarget)
 	})
 	require.Same(t, target, ac.currentAttachmentSession())
-	identityFrame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
+	identityFrame := awaitFrame(t, sends, wire.MsgCommittedRouteIdentity)
-	identity, err := ports.UnmarshalCommittedRouteIdentity(identityFrame.Payload)
+	identity, err := wire.UnmarshalCommittedRouteIdentity(identityFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, attachTarget.ExactTarget, &identity.Target)
 }
 	require.Same(t, target, ac.currentAttachmentSession())
 	require.Equal(t, domain.TabStableID(target.tabs[1].stableID), ac.viewSnapshot().tabID)
-	identityFrame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
+	identityFrame := awaitFrame(t, sends, wire.MsgCommittedRouteIdentity)
-	identity, err := ports.UnmarshalCommittedRouteIdentity(identityFrame.Payload)
+	identity, err := wire.UnmarshalCommittedRouteIdentity(identityFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, identity.Target)
 }
 	})
 	require.Same(t, source, ac.currentAttachmentSession())
-	failureFrame := awaitFrame(t, sends, ports.MsgSamePeerSwitchFailure)
+	failureFrame := awaitFrame(t, sends, wire.MsgSamePeerSwitchFailure)
-	failure, err := ports.UnmarshalSamePeerSwitchFailure(failureFrame.Payload)
+	failure, err := wire.UnmarshalSamePeerSwitchFailure(failureFrame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.SamePeerSwitchFailure{RequestID: 1, Code: protocol.SamePeerSwitchStaleTarget}, failure)
 }

M internal/usecase/daemon/session_back_route_test.go +3 -3

 import (
 	"testing"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 	var action protocol.RouteNavigationAction
 	found := false
 	for _, frame := range frames {
-		if frame.Type != ports.MsgNavigateRecentRoute {
+		if frame.Type != wire.MsgNavigateRecentRoute {
 			continue
 		}
 		var err error
-		action, err = ports.UnmarshalRouteNavigationAction(frame.Payload)
+		action, err = wire.UnmarshalRouteNavigationAction(frame.Payload)
 		require.NoError(t, err)
 		found = true
 	}

M internal/usecase/daemon/session_rename_purge_test.go +7 -7

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestRenamePublishesCommittedRouteIdentityToAttachedClients(t *testing.T) {
 	require.NoError(t, d.renameSession(sess, "vps-infra"))
-	frame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
+	frame := awaitFrame(t, sends, wire.MsgCommittedRouteIdentity)
-	identity, err := ports.UnmarshalCommittedRouteIdentity(frame.Payload)
+	identity, err := wire.UnmarshalCommittedRouteIdentity(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ExactSessionTarget{
 		LifecycleID: domain.IncarnationID{1},
 		ActiveEntry: protocol.RecentRouteEntry{Key: 1, Generation: 1, Target: testRouteTarget("0", 1), Name: "0", Kind: protocol.RouteKindLocal},
 		Home:        activeRef,
 	}
-	payload, err := ports.MarshalRecentRouteSnapshot(snapshot)
+	payload, err := wire.MarshalRecentRouteSnapshot(snapshot)
 	require.NoError(t, err)
-	require.False(t, d.handleAttachmentClientFrame(token, ports.Frame{Type: ports.MsgRecentRouteSnapshot, Payload: payload}))
+	require.False(t, d.handleAttachmentClientFrame(token, wire.Frame{Type: wire.MsgRecentRouteSnapshot, Payload: payload}))
-	frame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
+	frame := awaitFrame(t, sends, wire.MsgCommittedRouteIdentity)
-	identity, err := ports.UnmarshalCommittedRouteIdentity(frame.Payload)
+	identity, err := wire.UnmarshalCommittedRouteIdentity(frame.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ExactSessionTarget{
 		LifecycleID: domain.IncarnationID{1},

M internal/usecase/daemon/session_test.go +46 -45

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/picker"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 )
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	w := awaitFrame(t, sends, ports.MsgWelcome)
+	w := awaitFrame(t, sends, wire.MsgWelcome)
-	welcome, err := ports.UnmarshalWelcome(w.Payload)
+	welcome, err := wire.UnmarshalWelcome(w.Payload)
 	require.NoError(t, err)
 	require.Equal(t, "0", welcome.SessionName)
 	require.True(t, welcome.Ephemeral)
-	awaitFrame(t, sends, ports.MsgOutput) // guaranteed first paint
+	awaitFrame(t, sends, wire.MsgOutput) // guaranteed first paint
 	require.Equal(t, 1, sessionCount(d))
 	releaseConn()
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	w := awaitFrame(t, sends, ports.MsgWelcome)
+	w := awaitFrame(t, sends, wire.MsgWelcome)
-	welcome, err := ports.UnmarshalWelcome(w.Payload)
+	welcome, err := wire.UnmarshalWelcome(w.Payload)
 	require.NoError(t, err)
 	require.Equal(t, "work", welcome.SessionName)
 	require.False(t, welcome.Ephemeral)
 func TestHandshakeVersionMismatch(t *testing.T) {
 	// No Open expectation: the factory must never be asked to spawn a PTY.
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
-	bad := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
+	bad := wire.Frame{Type: wire.MsgHello, Payload: wire.MarshalHello(protocol.Hello{
 		Version: protocol.Version + 99, Intent: protocol.IntentEphemeral, Size: domain.Size{Cols: 80, Rows: 24},
 	})}
 	tr, sends, _ := newConn(t, bad)
 	d.handleConn(tr) // returns after the rejection; no session, no goroutines
-	e := awaitFrame(t, sends, ports.MsgError)
+	e := awaitFrame(t, sends, wire.MsgError)
-	em, err := ports.UnmarshalErrorMsg(e.Payload)
+	em, err := wire.UnmarshalErrorMsg(e.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ErrVersionMismatch, em.Code)
 	require.Equal(t, 0, sessionCount(d))
 		0x00, 0x18,
 		0x00, 0x00,
 	}
-	tr, sends, _ := newConn(t, ports.Frame{Type: ports.MsgHello, Payload: oldLayout})
+	tr, sends, _ := newConn(t, wire.Frame{Type: wire.MsgHello, Payload: oldLayout})
 	d.handleConn(tr)
-	e := awaitFrame(t, sends, ports.MsgError)
+	e := awaitFrame(t, sends, wire.MsgError)
-	em, err := ports.UnmarshalErrorMsg(e.Payload)
+	em, err := wire.UnmarshalErrorMsg(e.Payload)
 	require.NoError(t, err)
 	require.Equal(t, protocol.ErrVersionMismatch, em.Code)
 	require.Equal(t, 0, sessionCount(d))
 	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	d.handleConn(tr)
-	e := awaitFrame(t, sends, ports.MsgError)
+	e := awaitFrame(t, sends, wire.MsgError)
-	em, _ := ports.UnmarshalErrorMsg(e.Payload)
+	em, _ := wire.UnmarshalErrorMsg(e.Payload)
 	require.Equal(t, protocol.ErrNameTaken, em.Code)
 }
 	tr, sends, _ := newConn(t, mustHello(protocol.IntentAttach, "ghost", domain.Size{Cols: 80, Rows: 24}))
 	d.handleConn(tr)
-	e := awaitFrame(t, sends, ports.MsgError)
+	e := awaitFrame(t, sends, wire.MsgError)
-	em, _ := ports.UnmarshalErrorMsg(e.Payload)
+	em, _ := wire.UnmarshalErrorMsg(e.Payload)
 	require.Equal(t, protocol.ErrNoSuchSession, em.Code)
 }
 func TestKillAllEmptyDaemonSignalsShutdown(t *testing.T) {
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
-	tr, _, _ := newConn(t, ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})})
+	tr, _, _ := newConn(t, wire.Frame{Type: wire.MsgKill, Payload: wire.MarshalKill(protocol.Kill{All: true})})
 	d.handleConn(tr)
 	select {
 	tr, sends, releaseConn := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	sess := firstSession(d)
 	require.NotNil(t, sess)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr, sends, _ := newConn(t,
 		mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}),
-		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
+		wire.Frame{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})},
 	)
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgDetached)
+	awaitFrame(t, sends, wire.MsgDetached)
 	hg.Wait()
 	require.Equal(t, 1, sessionCount(d), "ephemeral session survives explicit detach")
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr, sends, _ := newConn(t,
 		mustHello(protocol.IntentNew, "keep", domain.Size{Cols: 80, Rows: 24}),
-		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
+		wire.Frame{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})},
 	)
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgDetached) // ack for explicit detach
+	awaitFrame(t, sends, wire.MsgDetached) // ack for explicit detach
-	hg.Wait()                               // handler returns after detach
+	hg.Wait()                              // handler returns after detach
 	require.Equal(t, 1, sessionCount(d), "named session survives detach")
 	sess := firstSession(d)
 	hg.Go(func() { d.handleConn(tr) })
 	// The client is detached with ReasonSessionKilled when the child exits.
-	det := awaitFrame(t, sends, ports.MsgDetached)
+	det := awaitFrame(t, sends, wire.MsgDetached)
-	dm, _ := ports.UnmarshalDetached(det.Payload)
+	dm, _ := wire.UnmarshalDetached(det.Payload)
 	require.Equal(t, protocol.ReasonSessionKilled, dm.Reason)
 	select {
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(context.Background(), l) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	// Child exits -> session removed -> registry empties -> Serve returns.
 	releasePTY()
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, l) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	cancel() // graceful shutdown
-	det := awaitFrame(t, sends, ports.MsgDetached)
+	det := awaitFrame(t, sends, wire.MsgDetached)
-	dm, _ := ports.UnmarshalDetached(det.Payload)
+	dm, _ := wire.UnmarshalDetached(det.Payload)
 	require.Equal(t, protocol.ReasonServerShutdown, dm.Reason)
 	select {
 	tr1, sends1, release1 := newConn(t, mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr1) })
-	awaitFrame(t, sends1, ports.MsgWelcome)
+	awaitFrame(t, sends1, wire.MsgWelcome)
 	// firstPaint starts the background prewarm asynchronously. It is valid for
 	// this Open to occur before shutdown, so do not mistake it for the racing
 	// Hello's forbidden launch.
-	awaitFrame(t, sends1, ports.MsgOutput)
+	awaitFrame(t, sends1, wire.MsgOutput)
 	select {
 	case <-preShutdownFloatingOpen:
 	case <-time.After(time.Second):
 	} {
 		tr2, sends2, _ := newConn(t, mustHello(intent.intent, intent.sess, domain.Size{Cols: 80, Rows: 24}))
 		d.handleConn(tr2)
-		e := awaitFrame(t, sends2, ports.MsgError)
+		e := awaitFrame(t, sends2, wire.MsgError)
-		em, err := ports.UnmarshalErrorMsg(e.Payload)
+		em, err := wire.UnmarshalErrorMsg(e.Payload)
 		require.NoError(t, err)
 		require.Equal(t, protocol.ErrServerShutdown, em.Code, "%s hello racing shutdown must be rejected", intent.name)
 	}
 	p, _ := newBlockingPTY(t) // Close unblocks the parked reader
 	tr := portsmocks.NewMockTransport(t)
-	sends := make(chan ports.Frame, 64)
+	sends := make(chan wire.Frame, 64)
-	recvCh := make(chan ports.Frame, 1)
+	recvCh := make(chan wire.Frame, 1)
 	recvCh <- mustHello(protocol.IntentNew, "wedge", domain.Size{Cols: 80, Rows: 24})
 	connDone := make(chan struct{})
 	var connOnce sync.Once
 	closeConn := func() { connOnce.Do(func() { close(connDone) }) }
-	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
+	tr.EXPECT().Recv().RunAndReturn(func() (wire.Frame, error) {
 		select {
 		case f := <-recvCh:
 			return f, nil
 		case <-connDone:
-			return ports.Frame{}, io.EOF
+			return wire.Frame{}, io.EOF
 		}
 	}).Maybe()
-	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f ports.Frame) error {
+	tr.EXPECT().Send(mock.Anything).RunAndReturn(func(f wire.Frame) error {
-		if f.Type == ports.MsgDetached {
+		if f.Type == wire.MsgDetached {
 			// Wedged: blocks until the transport is force-closed.
 			<-connDone
 			return io.ErrClosedPipe
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, l) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	awaitFrame(t, sends, ports.MsgOutput)
+	awaitFrame(t, sends, wire.MsgOutput)
 	cancel() // shutdown with the wedged client still attached

M internal/usecase/daemon/snapshot_scheduler_test.go +4 -3

 	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func TestSnapshotCoordinatorQuarantineCancelsPublicationBeforeDelete(t *testing.T) {
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, listener) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
 	sess := firstSession(d)
 	require.NotNil(t, sess)
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, l) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
 	markSnapshotDirty(firstSession(d))
 	d.snapshotWake <- struct{}{}
 	first := <-published
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, l) }()
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
 	markSnapshotDirty(firstSession(d))
 	d.snapshotWake <- struct{}{}
 	select {

M internal/usecase/daemon/status_test.go +6 -6

 	renderer "github.com/bnema/vev-vt/ansi"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/palette"
 		frameInput([]byte("\x1b ")),
 		frameInput([]byte("CNT\r")),
 		frameInput([]byte("\x1b1")),
-		ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 22, Rows: 6}})},
+		wire.Frame{Type: wire.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 22, Rows: 6}})},
 	)
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
-	awaitFrame(t, sends, ports.MsgWelcome)
+	awaitFrame(t, sends, wire.MsgWelcome)
-	first := awaitFrame(t, sends, ports.MsgOutput)
+	first := awaitFrame(t, sends, wire.MsgOutput)
 	require.Eventually(t, func() bool {
 		sessions := listSessions(t, d)
 		return len(sessions.Sessions) == 1 && sessions.Sessions[0].Tabs == 2
 		"timed out awaiting resized output frame",
 	)
-	for _, f := range []ports.Frame{first, resized} {
+	for _, f := range []wire.Frame{first, resized} {
-		out, err := ports.UnmarshalOutput(f.Payload)
+		out, err := wire.UnmarshalOutput(f.Payload)
 		require.NoError(t, err)
 		require.Contains(t, string(out.Data), "work")
 		require.Contains(t, string(out.Data), ";7m", "active status tab should be inverse-highlighted")

M internal/usecase/daemon/test_wait_helpers_test.go +8 -8


@@ -4,13 +4,13 @@ import (
4		"testing"	4		"testing"
5		"time"	5		"time"
6			6
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol/wire"
8		)	8		)
9			9
10		const testWaitTimeout = 2 * time.Second	10		const testWaitTimeout = 2 * time.Second
11			11
12	-	func testFramesOfType(frames []ports.Frame, typ ports.MsgType) []ports.Frame {	12	+	func testFramesOfType(frames []wire.Frame, typ wire.MsgType) []wire.Frame {
13	-	matched := make([]ports.Frame, 0, len(frames))	13	+	matched := make([]wire.Frame, 0, len(frames))
14		for _, frame := range frames {	14		for _, frame := range frames {
15		if frame.Type == typ {	15		if frame.Type == typ {
16		matched = append(matched, frame)	16		matched = append(matched, frame)

@@ -40,21 +40,21 @@ func awaitTestCompletion(t *testing.T, done <-chan struct{}, failure string) {
40			40
41		func awaitCoordinatorOutput(	41		func awaitCoordinatorOutput(
42		t *testing.T,	42		t *testing.T,
43	-	sends <-chan ports.Frame,	43	+	sends <-chan wire.Frame,
44		timers <-chan *coordinatorMockTimer,	44		timers <-chan *coordinatorMockTimer,
45		frameContext string,	45		frameContext string,
46		timeoutFailure string,	46		timeoutFailure string,
47	-	) ports.Frame {	47	+	) wire.Frame {
48		t.Helper()	48		t.Helper()
49		deadline := time.NewTimer(testWaitTimeout)	49		deadline := time.NewTimer(testWaitTimeout)
50		defer deadline.Stop()	50		defer deadline.Stop()
51		for {	51		for {
52		select {	52		select {
53		case frame := <-sends:	53		case frame := <-sends:
54	-	if frame.Type == ports.MsgRoutePosition {	54	+	if frame.Type == wire.MsgRoutePosition {
55		continue	55		continue
56		}	56		}
57	-	if frame.Type != ports.MsgOutput {	57	+	if frame.Type != wire.MsgOutput {
58		t.Fatalf("unexpected frame type %d %s", frame.Type, frameContext)	58		t.Fatalf("unexpected frame type %d %s", frame.Type, frameContext)
59		}	59		}
60		return frame	60		return frame

@@ -62,7 +62,7 @@ func awaitCoordinatorOutput(
62		timer.ch <- time.Time{}	62		timer.ch <- time.Time{}
63		case <-deadline.C:	63		case <-deadline.C:
64		t.Fatal(timeoutFailure)	64		t.Fatal(timeoutFailure)
65	-	return ports.Frame{}	65	+	return wire.Frame{}
66		}	66		}
67		}	67		}
68		}	68		}

M internal/usecase/daemon/transactional_resize_test.go +5 -4

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/ui"
 	"github.com/bnema/vev/internal/usecase/visualsearch"
 	// normal asynchronous client path, proving replay uses processPTYData.
 	var clipboardOutput string
 	for {
-		frame := awaitFrame(t, sends, ports.MsgOutput)
+		frame := awaitFrame(t, sends, wire.MsgOutput)
-		out, err := ports.UnmarshalOutput(frame.Payload)
+		out, err := wire.UnmarshalOutput(frame.Payload)
 		require.NoError(t, err)
 		clipboardOutput = string(out.Data)
 		if strings.Contains(clipboardOutput, "\x1b]52;c;YQ==\a") {
 	// The resize deadline is the only debounce: commit fires its sticky reset
 	// through S2 immediately (subject to ACK/sync gates).
 	frame := <-frames
-	require.Equal(t, ports.MsgOutput, frame.Type, "the committed epoch emits a full frame")
+	require.Equal(t, wire.MsgOutput, frame.Type, "the committed epoch emits a full frame")
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)
 	require.Zero(t, output.Base, "the accepted resize frame must reset the renderer state")
 	select {

M internal/usecase/daemon/transport_observability_test.go +9 -8

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 // This acceptance boundary exercises the attached resize, render, and ACK
 	if !d.resizeForFirstPaint(sess, ac, domain.Size{Cols: 90, Rows: 25}) {
 		t.Fatal("first resize was not accepted")
 	}
-	first := awaitFrame(t, sends, ports.MsgOutput)
+	first := awaitFrame(t, sends, wire.MsgOutput)
-	if first.Type != ports.MsgOutput {
+	if first.Type != wire.MsgOutput {
 		t.Fatalf("first frame = %v, want output", first.Type)
 	}
-	output, err := ports.UnmarshalOutput(first.Payload)
+	output, err := wire.UnmarshalOutput(first.Payload)
 	if err != nil {
 		t.Fatalf("decode first output: %v", err)
 	}
 	}
 	ac.ackOutputState(output.Epoch, output.New)
 	rc.notifyAck()
-	second := awaitFrame(t, sends, ports.MsgOutput)
+	second := awaitFrame(t, sends, wire.MsgOutput)
-	if second.Type != ports.MsgOutput {
+	if second.Type != wire.MsgOutput {
 		t.Fatalf("second frame = %v, want output", second.Type)
 	}
 		close(paintDone)
 	}()
 	awaitDaemonObserver(t, observer.entered, "blocked render observer")
-	frame := awaitFrame(t, sends, ports.MsgOutput) // The frame was emitted before the observer began its I/O.
+	frame := awaitFrame(t, sends, wire.MsgOutput) // The frame was emitted before the observer began its I/O.
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	if err != nil {
 		t.Fatalf("decode emitted output: %v", err)
 	}
 		d.paint(sess, ac, false, nil)
 		close(secondPaint)
 	}()
-	_ = awaitFrame(t, sends, ports.MsgOutput) // The second frame is live even though serialized observer I/O waits.
+	_ = awaitFrame(t, sends, wire.MsgOutput) // The second frame is live even though serialized observer I/O waits.
 	close(observer.release)
 	awaitDaemonObserver(t, paintDone, "first render completion")

M internal/usecase/daemon/wire.go +17 -17

 import (
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
-func frameWelcome(s *session, resumeToken uint64) (ports.Frame, error) {
+func frameWelcome(s *session, resumeToken uint64) (wire.Frame, error) {
 	s.mu.Lock()
 	var identity *protocol.CommittedRouteIdentity
 	if s.incarnation != (domain.SessionLifecycleID{}) {
 	}
 	s.mu.Unlock()
 	w.ResumeToken = resumeToken
-	payload := ports.MarshalWelcome(w)
+	payload := wire.MarshalWelcome(w)
 	if payload == nil {
-		return ports.Frame{}, protocol.ErrInvalidRouteWire
+		return wire.Frame{}, protocol.ErrInvalidRouteWire
 	}
-	return ports.Frame{Type: ports.MsgWelcome, Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgWelcome, Payload: payload}, nil
 }
-func frameError(code uint16, text string) ports.Frame {
+func frameError(code uint16, text string) wire.Frame {
-	return ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Code: code, Text: text})}
+	return wire.Frame{Type: wire.MsgError, Payload: wire.MarshalErrorMsg(protocol.ErrorMsg{Code: code, Text: text})}
 }
-func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64) (ports.Frame, error) {
+func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64) (wire.Frame, error) {
-	payload, err := ports.MarshalOutput(protocol.Output{
+	payload, err := wire.MarshalOutput(protocol.Output{
 		Epoch: 1, Base: baseState, New: state, Echo: echoAck,
 		Size: domain.Size{Cols: 1, Rows: 1}, Full: state != 0 && baseState == 0, Data: b,
 	})
 	if err != nil {
-		return ports.Frame{}, err
+		return wire.Frame{}, err
 	}
-	return ports.Frame{Type: ports.MsgOutput, Payload: payload}, nil
+	return wire.Frame{Type: wire.MsgOutput, Payload: payload}, nil
 }
-func frameDetached(reason uint8) ports.Frame {
+func frameDetached(reason uint8) wire.Frame {
-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: reason})}
+	return wire.Frame{Type: wire.MsgDetached, Payload: wire.MarshalDetached(protocol.Detached{Reason: reason})}
 }
-func framePong() ports.Frame {
+func framePong() wire.Frame {
-	return ports.Frame{Type: ports.MsgPong, Payload: ports.MarshalPong(protocol.Pong{})}
+	return wire.Frame{Type: wire.MsgPong, Payload: wire.MarshalPong(protocol.Pong{})}
 }
-func frameSessions(infos []protocol.SessionInfo) ports.Frame {
+func frameSessions(infos []protocol.SessionInfo) wire.Frame {
-	return ports.Frame{Type: ports.MsgSessions, Payload: ports.MarshalSessions(protocol.Sessions{Sessions: infos})}
+	return wire.Frame{Type: wire.MsgSessions, Payload: wire.MarshalSessions(protocol.Sessions{Sessions: infos})}
 }

M internal/usecase/daemon/wire_metadata_test.go +2 -2


@@ -5,7 +5,7 @@ import (
5		"sync"	5		"sync"
6		"testing"	6		"testing"
7			7
8	-	"github.com/bnema/vev/internal/ports"	8	+	"github.com/bnema/vev/internal/protocol/wire"
9		)	9		)
10			10
11		func TestFrameWelcomeSnapshotsSessionMetadataUnderLock(t *testing.T) {	11		func TestFrameWelcomeSnapshotsSessionMetadataUnderLock(t *testing.T) {

@@ -27,7 +27,7 @@ func TestFrameWelcomeSnapshotsSessionMetadataUnderLock(t *testing.T) {
27		if frameErr != nil {	27		if frameErr != nil {
28		t.Fatalf("frameWelcome() error = %v", frameErr)	28		t.Fatalf("frameWelcome() error = %v", frameErr)
29		}	29		}
30	-	welcome, err := ports.UnmarshalWelcome(frame.Payload)	30	+	welcome, err := wire.UnmarshalWelcome(frame.Payload)
31		if err != nil {	31		if err != nil {
32		t.Fatalf("UnmarshalWelcome() error = %v", err)	32		t.Fatalf("UnmarshalWelcome() error = %v", err)
33		}	33		}

M internal/usecase/daemon/wire_test_helpers_test.go +4 -4

 package daemon
 import (
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 func mustMarshalOutput(m protocol.Output) []byte {
-	payload, err := ports.MarshalOutput(m)
+	payload, err := wire.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 	}
 }
 func mustMarshalAck(m protocol.Ack) []byte {
-	payload, err := ports.MarshalAck(m)
+	payload, err := wire.MarshalAck(m)
 	if err != nil {
 		panic(err)
 	}
 }
 func mustMarshalResize(m protocol.Resize) []byte {
-	payload, err := ports.MarshalResize(m)
+	payload, err := wire.MarshalResize(m)
 	if err != nil {
 		panic(err)
 	}

M scripts/remote-picker-harness/main.go +32 -31

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const (
 }
 type harnessFrame struct {
-	frame ports.Frame
+	frame wire.Frame
 	err   error
 }
 	if hello.EnvironmentPolicy == 0 {
 		hello.EnvironmentPolicy = protocol.EnvironmentPolicyClientOwned
 	}
-	payload := ports.MarshalHello(hello)
+	payload := wire.MarshalHello(hello)
-	if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgHello, Payload: payload}); err != nil {
 		return err
 	}
 	frame, err := receiveWithTimeout(ctx, tr)
 	if err != nil {
 		return err
 	}
-	if frame.Type == ports.MsgError {
+	if frame.Type == wire.MsgError {
-		message, decodeErr := ports.UnmarshalErrorMsg(frame.Payload)
+		message, decodeErr := wire.UnmarshalErrorMsg(frame.Payload)
 		if decodeErr != nil {
 			return decodeErr
 		}
 		return fmt.Errorf("remote error code %d", message.Code)
 	}
-	if frame.Type != ports.MsgWelcome {
+	if frame.Type != wire.MsgWelcome {
 		return fmt.Errorf("welcome frame type %d", frame.Type)
 	}
 	tr.probe.recordControl(probeEventWelcome)
-	if err := tr.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(protocol.Theme{TrueColor: hello.TrueColor, SchemeKnown: true})}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgTheme, Payload: wire.MarshalTheme(protocol.Theme{TrueColor: hello.TrueColor, SchemeKnown: true})}); err != nil {
 		return fmt.Errorf("send initial theme: %w", err)
 	}
 	return nil
 }
 func sendRawInput(tr *harnessTransport, data string) error {
-	return tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(data)})})
+	return tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte(data)})})
 }
-func processOutputFrame(tr *harnessTransport, frame ports.Frame) error {
+func processOutputFrame(tr *harnessTransport, frame wire.Frame) error {
-	output, err := ports.UnmarshalOutput(frame.Payload)
+	output, err := wire.UnmarshalOutput(frame.Payload)
 	if err != nil {
 		return err
 	}
 	result := tr.probe.apply(output)
 	if !result.Accepted {
 		if !tr.probe.resetPending {
-			if err := tr.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}); err != nil {
+			if err := tr.Send(wire.Frame{Type: wire.MsgOutputResetRequest, Payload: wire.MarshalOutputResetRequest(protocol.OutputResetRequest{})}); err != nil {
 				return err
 			}
 			tr.probe.resetPending = true
 	if !result.StateBearing {
 		return nil
 	}
-	payload, err := ports.MarshalAck(result.Ack)
+	payload, err := wire.MarshalAck(result.Ack)
 	if err != nil {
 		return err
 	}
-	if err := tr.Send(ports.Frame{Type: ports.MsgAck, Payload: payload}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgAck, Payload: payload}); err != nil {
 		return err
 	}
 	tr.probe.resetPending = false
 		if err != nil {
 			return err
 		}
-		if frame.Type != ports.MsgOutput {
+		if frame.Type != wire.MsgOutput {
 			continue
 		}
 		if err := processOutputFrame(tr, frame); err != nil {
 		if err != nil {
 			return fmt.Errorf("no rendered remote preview after %d output frames (loading=%t): %w", tr.probe.outputFrames, sawLoading, err)
 		}
-		if frame.Type != ports.MsgOutput {
+		if frame.Type != wire.MsgOutput {
 			continue
 		}
 		if err := processOutputFrame(tr, frame); err != nil {
 }
 func sendInputAndAwait(ctx context.Context, tr *harnessTransport, command, want string) error {
-	if err := tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(command + "\n")})}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgInput, Payload: wire.MarshalInput(protocol.Input{Data: []byte(command + "\n")})}); err != nil {
 		return err
 	}
 	deadline, cancel := context.WithTimeout(ctx, 5*time.Second)
 		if err != nil {
 			return fmt.Errorf("waiting for marker after %d output frames/%d bytes: %w", tr.probe.outputFrames, tr.probe.outputBytes, err)
 		}
-		if frame.Type != ports.MsgOutput {
+		if frame.Type != wire.MsgOutput {
 			continue
 		}
 		if err := processOutputFrame(tr, frame); err != nil {
 		Attached:  true,
 		Slug:      slug,
 	}
-	payload, err := ports.MarshalCommandRequest(request)
+	payload, err := wire.MarshalCommandRequest(request)
 	if err != nil {
 		return err
 	}
-	if err := tr.Send(ports.Frame{Type: ports.MsgCommand, Payload: payload}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgCommand, Payload: payload}); err != nil {
 		return err
 	}
 	deadline, cancel := context.WithTimeout(ctx, 5*time.Second)
 		if err != nil {
 			return err
 		}
-		if frame.Type == ports.MsgOutput {
+		if frame.Type == wire.MsgOutput {
 			if err := processOutputFrame(tr, frame); err != nil {
 				return err
 			}
 			continue
 		}
-		if frame.Type != ports.MsgCommandResult {
+		if frame.Type != wire.MsgCommandResult {
 			continue
 		}
-		result, err := ports.UnmarshalCommandResult(frame.Payload)
+		result, err := wire.UnmarshalCommandResult(frame.Payload)
 		if err != nil {
 			return err
 		}
 }
 func detach(ctx context.Context, tr *harnessTransport) error {
-	if err := tr.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgDetach, Payload: wire.MarshalDetach(protocol.Detach{})}); err != nil {
 		return err
 	}
 	deadline, cancel := context.WithTimeout(ctx, 5*time.Second)
 		if err != nil {
 			return err
 		}
-		if frame.Type == ports.MsgDetached {
+		if frame.Type == wire.MsgDetached {
 			return nil
 		}
 	}
 		RemoteTarget:      &target,
 		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}
-	payload := ports.MarshalHello(hello)
+	payload := wire.MarshalHello(hello)
-	if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {
+	if err := tr.Send(wire.Frame{Type: wire.MsgHello, Payload: payload}); err != nil {
 		return err
 	}
 	frame, err := receiveWithTimeout(ctx, tr)
 	if err != nil {
 		return err
 	}
-	if frame.Type != ports.MsgError {
+	if frame.Type != wire.MsgError {
 		return fmt.Errorf("stale target returned frame type %d", frame.Type)
 	}
-	message, err := ports.UnmarshalErrorMsg(frame.Payload)
+	message, err := wire.UnmarshalErrorMsg(frame.Payload)
 	if err != nil {
 		return err
 	}
 	queued := len(tr.frames)
 	for range queued {
 		outcome := <-tr.frames
-		if outcome.frame.Type == ports.MsgAttachTarget {
+		if outcome.frame.Type == wire.MsgAttachTarget {
 			tr.probe.recordIncoming(outcome.frame)
 		} else {
 			tr.queued = append(tr.queued, outcome)
 	return nil
 }
-func receiveWithTimeout(ctx context.Context, tr *harnessTransport) (ports.Frame, error) {
+func receiveWithTimeout(ctx context.Context, tr *harnessTransport) (wire.Frame, error) {
 	if len(tr.queued) != 0 {
 		outcome := tr.queued[0]
 		tr.queued = tr.queued[1:]
 	}
 	select {
 	case <-ctx.Done():
-		return ports.Frame{}, ctx.Err()
+		return wire.Frame{}, ctx.Err()
 	case outcome := <-tr.frames:
 		if outcome.err == nil {
 			tr.probe.recordIncoming(outcome.frame)

M scripts/remote-picker-harness/main_test.go +4 -4


@@ -5,7 +5,7 @@ import (
5		"strings"	5		"strings"
6		"testing"	6		"testing"
7			7
8	-	"github.com/bnema/vev/internal/ports"	8	+	"github.com/bnema/vev/internal/protocol/wire"
9		)	9		)
10			10
11		func TestBoundedStderrRetainsAtMostDiagnosticLimit(t *testing.T) {	11		func TestBoundedStderrRetainsAtMostDiagnosticLimit(t *testing.T) {

@@ -50,13 +50,13 @@ func TestAssertNoDirectHandoffProcessesInitialFramesAndRetainsOutput(t *testing.
50		probe: &visualProbe{},	50		probe: &visualProbe{},
51		frames: make(chan harnessFrame, 2),	51		frames: make(chan harnessFrame, 2),
52		}	52		}
53	-	tr.frames <- harnessFrame{frame: ports.Frame{Type: ports.MsgOutput}}	53	+	tr.frames <- harnessFrame{frame: wire.Frame{Type: wire.MsgOutput}}
54	-	tr.frames <- harnessFrame{frame: ports.Frame{Type: ports.MsgAttachTarget}}	54	+	tr.frames <- harnessFrame{frame: wire.Frame{Type: wire.MsgAttachTarget}}
55			55
56		if err := assertNoDirectHandoff(tr); err == nil {	56		if err := assertNoDirectHandoff(tr); err == nil {
57		t.Fatal("direct handoff was not rejected")	57		t.Fatal("direct handoff was not rejected")
58		}	58		}
59	-	if len(tr.queued) != 1 \|\| tr.queued[0].frame.Type != ports.MsgOutput {	59	+	if len(tr.queued) != 1 \|\| tr.queued[0].frame.Type != wire.MsgOutput {
60		t.Fatalf("queued frames = %#v, want one retained output", tr.queued)	60		t.Fatalf("queued frames = %#v, want one retained output", tr.queued)
61		}	61		}
62		if tr.probe.unexpectedHandoffs != 1 {	62		if tr.probe.unexpectedHandoffs != 1 {

M scripts/remote-picker-harness/visual_probe.go +3 -3

 	vt "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 )
 const (
 	return strings.Contains(p.text(), want)
 }
-func (p *visualProbe) recordIncoming(frame ports.Frame) {
+func (p *visualProbe) recordIncoming(frame wire.Frame) {
-	if p == nil || frame.Type != ports.MsgAttachTarget {
+	if p == nil || frame.Type != wire.MsgAttachTarget {
 		return
 	}
 	p.unexpectedHandoffs++

M scripts/remote-picker-harness/visual_probe_test.go +11 -11

 	"testing"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/stretchr/testify/require"
 )
 )
 type probeTestTransport struct {
-	sent []ports.Frame
+	sent []wire.Frame
 }
-func (t *probeTestTransport) Send(frame ports.Frame) error {
+func (t *probeTestTransport) Send(frame wire.Frame) error {
 	t.sent = append(t.sent, frame)
 	return nil
 }
-func (*probeTestTransport) Recv() (ports.Frame, error) { return ports.Frame{}, errors.New("not used") }
+func (*probeTestTransport) Recv() (wire.Frame, error) { return wire.Frame{}, errors.New("not used") }
-func (*probeTestTransport) Close() error               { return nil }
+func (*probeTestTransport) Close() error              { return nil }
-func probeTestOutput(t *testing.T, output protocol.Output) ports.Frame {
+func probeTestOutput(t *testing.T, output protocol.Output) wire.Frame {
 	t.Helper()
-	payload, err := ports.MarshalOutput(output)
+	payload, err := wire.MarshalOutput(output)
 	if err != nil {
 		t.Fatalf("marshal output: %v", err)
 	}
-	return ports.Frame{Type: ports.MsgOutput, Payload: payload}
+	return wire.Frame{Type: wire.MsgOutput, Payload: payload}
 }
 func TestVisualProbePersistsFullAndIncrementalOutput(t *testing.T) {
 			var ackCount, resetCount int
 			for _, frame := range transport.sent {
 				switch frame.Type {
-				case ports.MsgAck:
+				case wire.MsgAck:
 					ackCount++
-				case ports.MsgOutputResetRequest:
+				case wire.MsgOutputResetRequest:
 					resetCount++
 				}
 			}
 func TestVisualProbeRecordsUnexpectedAttachTarget(t *testing.T) {
 	probe := newVisualProbe(domain.Size{Cols: probeTestCols, Rows: probeTestRows})
-	probe.recordIncoming(ports.Frame{Type: ports.MsgAttachTarget})
+	probe.recordIncoming(wire.Frame{Type: wire.MsgAttachTarget})
 	if probe.unexpectedHandoffs != 1 {
 		t.Fatalf("unexpected handoffs = %d, want 1", probe.unexpectedHandoffs)

M transport_replay_integration_test.go +6 -5

 	"github.com/bnema/vev/internal/adapters/sshstdio"
 	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
+	"github.com/bnema/vev/internal/protocol/wire"
 	"github.com/bnema/vev/internal/testutil/replaytest"
 	"github.com/stretchr/testify/require"
 )
 		got, err := receiver.Recv()
 		require.NoError(t, err)
 		require.Equal(t, want, got)
-		output, err := ports.UnmarshalOutput(got.Payload)
+		output, err := wire.UnmarshalOutput(got.Payload)
 		require.NoError(t, err)
 		bytes = append(bytes, output.Data...)
 		terminal.Write(output.Data)
 			done := make(chan error, 1)
 			go func() {
 				for _, snapshot := range sequence {
-					if err := sender.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(snapshot)}); err != nil {
+					if err := sender.Send(wire.Frame{Type: wire.MsgTheme, Payload: wire.MarshalTheme(snapshot)}); err != nil {
 						done <- err
 						return
 					}
 			for _, want := range sequence {
 				frame, err := receiver.Recv()
 				require.NoError(t, err)
-				require.Equal(t, ports.MsgTheme, frame.Type)
+				require.Equal(t, wire.MsgTheme, frame.Type)
-				require.Equal(t, ports.MarshalTheme(want), frame.Payload, "theme payload must be preserved byte-for-byte before decode")
+				require.Equal(t, wire.MarshalTheme(want), frame.Payload, "theme payload must be preserved byte-for-byte before decode")
-				got, err := ports.UnmarshalTheme(frame.Payload)
+				got, err := wire.UnmarshalTheme(frame.Payload)
 				require.NoError(t, err)
 				require.Equal(t, want, got)
 			}