be1cf92 refactor(protocol): extract presentation contracts (#227) · vev

M AGENTS.md +1 -1


@@ -61,7 +61,7 @@ Before touching daemon teardown paths, read the lock-ordering notes at the top o
61			61
62		## Wire protocol	62		## Wire protocol
63			63
64	-	Wire payload types/codecs live in `internal/ports/frame.go` and `internal/ports/wire.go`. Connection framing lives in `internal/adapters/ipc/transport.go`.	64	+	Semantic presentation and route values live in `internal/protocol`; session-control values live in `internal/ports/session_control.go`. 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`.
65			65
66		- IPC frames on a connection are 4-byte big-endian length, 1 type byte, then payload.	66		- IPC frames on a connection are 4-byte big-endian length, 1 type byte, then payload.
67		- 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.	67		- 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/network_sim_test.go +4 -3

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 )
 			}
 		}
 		b.mu.Unlock()
-		primer := mustMarshalOutput(ports.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("primer")})
+		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 {
 			t.Fatal(err)
 		}
 			}
 		})
 		for state := 1; state < outputCount; state++ {
-			payload := mustMarshalOutput(ports.Output{
+			payload := mustMarshalOutput(protocol.Output{
 				Epoch: 1,
 				Base:  uint64(state),
 				New:   uint64(state + 1),
 }
 func floodOutputPayload(baseState, mtu int) []byte {
-	return mustMarshalOutput(ports.Output{
+	return mustMarshalOutput(protocol.Output{
 		Epoch: 1,
 		Base:  uint64(baseState),
 		New:   uint64(baseState + 1),

M internal/adapters/dgram/proxy_test.go +2 -1

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type fakeTransport struct {
 			}
 			input := ports.Frame{Type: ports.MsgInput, Payload: []byte("still flowing")}
-			ack := ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(ports.Ack{Epoch: 1, State: 7})}
+			ack := ports.Frame{Type: ports.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} {

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	pdgram "github.com/bnema/vev/pkg/dgram"
 	"github.com/stretchr/testify/require"
 )
 	if err := a.SendAsync(ports.Frame{Type: ports.MsgOutput, Payload: []byte("prime")}); err != nil {
 		t.Fatal(err)
 	}
-	large := mustMarshalOutput(ports.Output{Epoch: 1, Base: 1, New: 2, Size: domain.Size{Cols: 1, Rows: 1}, Data: make([]byte, 24*a.mtu)})
+	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 {
 			t.Fatal(err)
 	}
 	a.mu.Unlock()
 	go a.resendPending()
-	sideEffect := ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(ports.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: make([]byte, 100*1024)})}
+	sideEffect := ports.Frame{Type: ports.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) }()
 		frame ports.Frame
 	}{
 		{name: "control", frame: ports.Frame{Type: ports.MsgPing}},
-		{name: "terminal side effect", frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(ports.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("osc")})}},
+		{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")})}},
 	}
 	for _, tt := range frames {
 		t.Run(tt.name, func(t *testing.T) {

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

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

M internal/adapters/ipc/transport_test.go +2 -1

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestTransportSendRecvBothDirections(t *testing.T) {
 	}
 	// Vary a couple to prove ordering and content are both preserved.
 	frames[7] = ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("hop")})}
-	frames[150] = ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(ports.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}
+	frames[150] = ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}
 	var wg sync.WaitGroup
 	wg.Go(func() {

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

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

M internal/adapters/remote/preview.go +15 -14

 	"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"
 )
 const (
 	return &PreviewClient{command: exec.CommandContext}
 }
-func (c *PreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (ports.RemotePreview, error) {
+func (c *PreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error) {
-	request := ports.RemotePreviewRequest{Version: ports.RemotePreviewSchemaVersion, Target: target, Width: width, Height: height}
+	request := protocol.RemotePreviewRequest{Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: width, Height: height}
 	payload := ports.MarshalRemotePreviewRequest(request)
 	if payload == nil {
-		return ports.RemotePreview{}, ports.ErrInvalidRemotePreviewRequest
+		return protocol.RemotePreview{}, protocol.ErrInvalidRemotePreviewRequest
 	}
 	runCtx, cancel := context.WithTimeout(ctx, c.previewTimeout())
 	defer cancel()
 	encoded := base64.RawURLEncoding.EncodeToString(payload)
 	spec := sshstdio.BuildCommandForRemoteCommand(target.Endpoint, "vev", "_remote-preview", encoded)
 	cmd := command(runCtx, spec.Path, spec.Args...)
-	stdout := boundedBuffer{limit: ports.RemotePreviewMaxBytes}
+	stdout := boundedBuffer{limit: protocol.RemotePreviewMaxBytes}
 	stderr := boundedBuffer{limit: remotePreviewMaxDiagnostic}
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	if err := cmd.Run(); err != nil {
 		if ctxErr := runCtx.Err(); ctxErr != nil {
 			if parentErr := ctx.Err(); parentErr != nil {
-				return ports.RemotePreview{}, parentErr
+				return protocol.RemotePreview{}, parentErr
 			}
-			return ports.RemotePreview{}, ports.ErrRemotePreviewTimeout
+			return protocol.RemotePreview{}, protocol.ErrRemotePreviewTimeout
 		}
 		if stdout.overflow || stderr.overflow {
-			return ports.RemotePreview{}, errRemotePreviewTooLarge
+			return protocol.RemotePreview{}, errRemotePreviewTooLarge
 		}
 		if diagnostic := sanitizeCatalogDiagnostic(string(stderr.Bytes())); diagnostic != "" {
-			return ports.RemotePreview{}, fmt.Errorf("%w: %v: %s", errRemotePreviewSSH, err, diagnostic)
+			return protocol.RemotePreview{}, fmt.Errorf("%w: %v: %s", errRemotePreviewSSH, err, diagnostic)
 		}
-		return ports.RemotePreview{}, fmt.Errorf("%w: %v", errRemotePreviewSSH, err)
+		return protocol.RemotePreview{}, fmt.Errorf("%w: %v", errRemotePreviewSSH, err)
 	}
 	if stdout.overflow || stderr.overflow {
-		return ports.RemotePreview{}, errRemotePreviewTooLarge
+		return protocol.RemotePreview{}, errRemotePreviewTooLarge
 	}
 	preview, err := ports.UnmarshalRemotePreview(stdout.Bytes())
 	if err != nil {
-		return ports.RemotePreview{}, err
+		return protocol.RemotePreview{}, err
 	}
-	if preview.Status != ports.RemotePreviewOK {
+	if preview.Status != protocol.RemotePreviewOK {
-		return ports.RemotePreview{}, fmt.Errorf("remote preview unavailable: status %d", preview.Status)
+		return protocol.RemotePreview{}, fmt.Errorf("remote preview unavailable: status %d", preview.Status)
 	}
 	if preview.LifecycleID != target.LifecycleID || preview.TabID != target.LiveTabID {
-		return ports.RemotePreview{}, errRemotePreviewIdentity
+		return protocol.RemotePreview{}, errRemotePreviewIdentity
 	}
 	return preview, nil
 }

M internal/adapters/remote/preview_test.go +10 -9

 	"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"
 )
 func previewClientTargetForTest() domain.RemoteSessionTarget {
 		Endpoint: "build@mule", DisplayOrigin: "mule", LifecycleID: lifecycle,
 		SessionName: "work", LiveTabID: "tab-1",
 	}
-	want := ports.RemotePreview{
+	want := protocol.RemotePreview{
-		Version: ports.RemotePreviewSchemaVersion, Status: ports.RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: lifecycle, TabID: target.LiveTabID, Revision: 7, Width: 1, Height: 1,
 		Cells: []renderer.Cell{{Rune: 'x', Style: renderer.DefaultStyle()}},
 	}
 	target := previewClientTargetForTest()
 	var otherLifecycle domain.SessionLifecycleID
 	otherLifecycle[0] = 2
-	valid := ports.RemotePreview{
+	valid := protocol.RemotePreview{
-		Version: ports.RemotePreviewSchemaVersion, Status: ports.RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: target.LifecycleID, TabID: target.LiveTabID, Revision: 1, Width: 1, Height: 1,
 		Cells: []renderer.Cell{{Rune: 'x', Style: renderer.DefaultStyle()}},
 	}
 	tests := []struct {
 		name   string
-		mutate func(*ports.RemotePreview)
+		mutate func(*protocol.RemotePreview)
 	}{
-		{name: "lifecycle ID", mutate: func(preview *ports.RemotePreview) { preview.LifecycleID = otherLifecycle }},
+		{name: "lifecycle ID", mutate: func(preview *protocol.RemotePreview) { preview.LifecycleID = otherLifecycle }},
-		{name: "tab ID", mutate: func(preview *ports.RemotePreview) { preview.TabID = "tab-2" }},
+		{name: "tab ID", mutate: func(preview *protocol.RemotePreview) { preview.TabID = "tab-2" }},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 func TestRemotePreviewClientRejectsOversizedOutput(t *testing.T) {
 	client := &PreviewClient{command: func(ctx context.Context, _ string, _ ...string) *exec.Cmd {
-		return exec.CommandContext(ctx, "sh", "-c", fmt.Sprintf("head -c %d /dev/zero", ports.RemotePreviewMaxBytes+1))
+		return exec.CommandContext(ctx, "sh", "-c", fmt.Sprintf("head -c %d /dev/zero", protocol.RemotePreviewMaxBytes+1))
 	}}
 	target := previewClientTargetForTest()
 	_, err := client.Preview(context.Background(), target, 1, 1)
 		},
 	}
 	_, err := client.Preview(context.Background(), previewClientTargetForTest(), 1, 1)
-	require.ErrorIs(t, err, ports.ErrRemotePreviewTimeout)
+	require.ErrorIs(t, err, protocol.ErrRemotePreviewTimeout)
 }
 func TestRemotePreviewClientReturnsCallerCancellation(t *testing.T) {

M internal/app/final_acceptance_test.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/usecase/daemon"
 	"github.com/stretchr/testify/require"
 )
 	return result
 }
-func awaitAcceptanceOutput(t *testing.T, p *pump, predicate func(ports.Output) bool) ports.Output {
+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 {
 		output, err := ports.UnmarshalOutput(frame.Payload)
 	// 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(ports.Resize{Size: domain.Size{Cols: 100, Rows: 30}})
+	resizePayload, err := ports.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}))
-	resized := awaitAcceptanceOutput(t, firstPump, func(output ports.Output) bool { return output.Size == (domain.Size{Cols: 100, Rows: 30}) })
+	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(ports.OutputResetRequest{})}))
-	reset := awaitAcceptanceOutput(t, firstPump, func(output ports.Output) bool { return output.Base == 0 && output.Full })
+	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")
 drained:
 	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}))
-	awaitAcceptanceOutput(t, firstPump, func(output ports.Output) bool { return output.Full && output.Base == 0 })
+	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 +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"
 	"github.com/bnema/vev/internal/usecase/client"
 	"github.com/stretchr/testify/require"
 )
 		if outputs != nil {
 			outputs <- string(data)
 		}
-		payload, err := ports.MarshalOutput(ports.Output{
+		payload, err := ports.MarshalOutput(protocol.Output{
 			Epoch: 1, New: 1, Full: true, Size: domain.Size{Cols: 80, Rows: 24}, Data: data,
 		})
 		if err != nil {
 	welcome, err := wireTransport.Recv()
 	require.NoError(t, err)
 	require.Equal(t, ports.MsgWelcome, welcome.Type)
-	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(ports.Theme{})}))
+	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(protocol.Theme{})}))
 	attachTarget, err := wireTransport.Recv()
 	require.NoError(t, err)
 	target, err := ports.UnmarshalAttachTarget(attachTarget.Payload)

M internal/app/remote_preview.go +4 -3

 	"github.com/bnema/vev/internal/adapters/ipc"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // runRemotePreview is the hidden SSH-side carriage. The request is encoded in
 		if ctxErr := ctx.Err(); ctxErr != nil {
 			return ctxErr
 		}
-		return writeRemotePreviewStatus(ports.RemotePreviewUnavailable)
+		return writeRemotePreviewStatus(protocol.RemotePreviewUnavailable)
 	}
 	defer func() { _ = transport.Close() }()
 	if err := transport.Send(ports.Frame{Type: ports.MsgRemotePreviewRequest, Payload: request}); err != nil {
 	}
 }
-func writeRemotePreviewStatus(status ports.RemotePreviewStatus) error {
+func writeRemotePreviewStatus(status protocol.RemotePreviewStatus) error {
-	payload := ports.MarshalRemotePreview(ports.RemotePreview{Version: ports.RemotePreviewSchemaVersion, Status: status})
+	payload := ports.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: status})
 	if payload == nil {
 		return errors.New("vev: failed to encode remote preview status")
 	}

M internal/app/run.go +8 -7

 	"github.com/bnema/vev/internal/persist"
 	"github.com/bnema/vev/internal/platform"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/client"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/bnema/vev/internal/usecase/recovery"
 	var remoteSelection *domain.RemoteSessionTarget
 	var remoteEnvironmentPolicy ports.EnvironmentPolicy
 	remoteDisplayOrigin := domain.RemoteDisplayOrigin(remoteTarget)
-	routeOrigin := ports.RouteOriginLocal
+	routeOrigin := protocol.RouteOriginLocal
 	routeOriginKey := "local"
 	if remoteTarget != "" {
-		routeOrigin = ports.RouteOriginRemote
+		routeOrigin = protocol.RouteOriginRemote
 		routeOriginKey = remoteTarget
 		if modeErr != nil {
 			return modeErr
 			Intent:            target.Intent,
 			SessionName:       target.Session,
 			Remote:            true,
-			Origin:            ports.RouteOriginDiscovery,
+			Origin:            protocol.RouteOriginDiscovery,
 			OriginKey:         target.Endpoint,
 			RemoteTarget:      selection,
 			HostLabel:         displayOrigin,
 				RemoteHostLearner: attachRememberLearner(deps, remoteTarget, log),
 				AttachHandoff:     handoff,
 				Remote:            true,
-				Origin:            ports.RouteOriginRemote,
+				Origin:            protocol.RouteOriginRemote,
 				OriginKey:         remoteTarget,
 			}, client.AttachRequest{
 				Intent:            intent,
 				RuntimeObserver: deps.runtimeObserver,
 				AttachHandoff:   handoff,
 				Remote:          false,
-				Origin:          ports.RouteOriginLocal,
+				Origin:          protocol.RouteOriginLocal,
 				OriginKey:       "local",
-			}, client.AttachRequest{Intent: intent, SessionName: name, Origin: ports.RouteOriginLocal, OriginKey: "local"})
+			}, client.AttachRequest{Intent: intent, SessionName: name, Origin: protocol.RouteOriginLocal, OriginKey: "local"})
 		}
 		var handoffErr *client.AttachTargetError
 		handoffAttempts++
 		remoteTarget = handoffErr.Target.Endpoint
 		remoteDisplayOrigin = domain.RemoteDisplayOrigin(remoteTarget)
-		routeOrigin = ports.RouteOriginDiscovery
+		routeOrigin = protocol.RouteOriginDiscovery
 		routeOriginKey = remoteTarget
 		name = handoffErr.Target.Session
 		intent = handoffErr.Target.Intent

M internal/app/run_test.go +3 -2

 	"github.com/bnema/vev/internal/persist"
 	"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/usecase/client"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/bnema/vev/pkg/kv"
 		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {
 			if deps.Remote {
 				remoteCalls++
-				require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "picked", Remote: true, Origin: ports.RouteOriginDiscovery, OriginKey: "selected.example", HostLabel: "selected.example", EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}, request)
+				require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "picked", Remote: true, Origin: protocol.RouteOriginDiscovery, OriginKey: "selected.example", HostLabel: "selected.example", EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}, request)
 				return nil
 			}
 			localCalls++
-			require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work", Origin: ports.RouteOriginLocal, OriginKey: "local"}, request)
+			require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local"}, request)
 			return &client.AttachTargetError{Target: ports.AttachTarget{Endpoint: "selected.example", Session: "picked", Intent: ports.IntentAttach}}
 		},
 	})

M internal/ports/frame.go +11 -147

@@ -1,27 +1,9 @@
1		package ports	1		package ports
2			2
3	-	import (
4	-	"time"
5	-
6	-	renderer "github.com/bnema/vev-vt"
7	-	"github.com/bnema/vev/internal/domain"
8	-	)
9	-
10	-	// HandshakeTimeout bounds every transport handshake from connect through the
11	-	// first committed publication.
12	-	const HandshakeTimeout = 15 * time.Second
13	-
14	-	// ProtocolVersion is the current vev IPC wire protocol version.
15	-	const ProtocolVersion uint16 = 37
16	-
17		// MaxFrameLen is the largest permitted frame length, including the type byte	3		// MaxFrameLen is the largest permitted frame length, including the type byte
18		// and excluding the four-byte length prefix.	4		// and excluding the four-byte length prefix.
19		const MaxFrameLen = 16 << 20	5		const MaxFrameLen = 16 << 20
20			6
21	-	// MaxOutputDataLen is the largest decoded terminal byte stream that fits in
22	-	// one Output frame after its type byte and wire metadata.
23	-	const MaxOutputDataLen = MaxFrameLen - 1 - outputPayloadOverhead
24	-
25		// MsgType identifies the kind of payload carried by a Frame.	7		// MsgType identifies the kind of payload carried by a Frame.
26		type MsgType uint8	8		type MsgType uint8
27			9

@@ -48,18 +30,16 @@ const (
48		MsgSamePeerSwitchRequest MsgType = 33	30		MsgSamePeerSwitchRequest MsgType = 33
49		MsgParkedRouteRequest MsgType = 35	31		MsgParkedRouteRequest MsgType = 35
50			32
51	-	MsgWelcome MsgType = 16	33	+	MsgWelcome MsgType = 16
52	-	MsgError MsgType = 17	34	+	MsgError MsgType = 17
53	-	MsgOutput MsgType = 18	35	+	MsgOutput MsgType = 18
54	-	MsgDetached MsgType = 19	36	+	MsgDetached MsgType = 19
55	-	MsgPong MsgType = 20	37	+	MsgPong MsgType = 20
56	-	MsgSessions MsgType = 21	38	+	MsgSessions MsgType = 21
57	-	MsgCommandResult MsgType = 22	39	+	MsgCommandResult MsgType = 22
58	-	MsgNavigationAction MsgType = 23	40	+	MsgNavigationAction MsgType = 23
59	-	MsgAttachTarget MsgType = 25	41	+	MsgAttachTarget MsgType = 25
60	-	MsgRemotePreviewResponse MsgType = 26	42	+	MsgRemotePreviewResponse MsgType = 26
61	-	// Route navigation metadata/control frames occupy the post-26 server range;
62	-	// 14 and 24 remain reserved for compatibility with older peers.
63		MsgCommittedRouteIdentity MsgType = 27	43		MsgCommittedRouteIdentity MsgType = 27
64		MsgRecentRouteSnapshot MsgType = 28	44		MsgRecentRouteSnapshot MsgType = 28
65		MsgNavigateRecentRoute MsgType = 29	45		MsgNavigateRecentRoute MsgType = 29

@@ -70,124 +50,8 @@ const (
70		)	50		)
71			51
72		// Frame is the unit of exchange over a Transport: a typed, length-delimited	52		// Frame is the unit of exchange over a Transport: a typed, length-delimited
73	-	// message. It lives in ports (rather than an ipc adapter) so usecases and	53	+	// message.
74	-	// adapters can share it without either depending on a concrete transport
75	-	// implementation.
76		type Frame struct {	54		type Frame struct {
77		Type MsgType	55		Type MsgType
78		Payload []byte	56		Payload []byte
79		}	57		}
80	-
81	-	// NavigationCapabilities advertises the bounded client routes available to a
82	-	// directly attached daemon.
83	-	type NavigationCapabilities uint8
84	-
85	-	const (
86	-	NavigationCapabilityHomePicker NavigationCapabilities = 1 << iota
87	-	NavigationCapabilityBack
88	-	)
89	-
90	-	// StartupOverlay selects the one startup overlay opened by a navigation route.
91	-	type StartupOverlay uint8
92	-
93	-	const (
94	-	StartupOverlayNone StartupOverlay = iota
95	-	StartupOverlaySessionPicker
96	-	)
97	-
98	-	// NavigationAction is a server request for one bounded client route transition.
99	-	type NavigationAction uint8
100	-
101	-	const (
102	-	NavigationOpenHomePicker NavigationAction = 1
103	-	NavigationBack NavigationAction = 2
104	-	)
105	-
106	-	// ParkedRouteLeaseID is an opaque capability minted by the attached daemon for
107	-	// one home-picker excursion. It is bound server-side to the exact connection
108	-	// generation and transport that received the navigation directive.
109	-	type ParkedRouteLeaseID [16]byte
110	-
111	-	func (id ParkedRouteLeaseID) IsZero() bool { return id == ParkedRouteLeaseID{} }
112	-
113	-	// NavigationDirective requests one client-owned route transition. Opening the
114	-	// home picker always carries a fresh lease; Back is sent by the transient home
115	-	// route and therefore carries no lease.
116	-	type NavigationDirective struct {
117	-	Action NavigationAction
118	-	LeaseID ParkedRouteLeaseID
119	-	}
120	-
121	-	// ParkedRouteAction advances one retained route through its one-shot lease.
122	-	type ParkedRouteAction uint8
123	-
124	-	const (
125	-	ParkedRoutePrepare ParkedRouteAction = iota + 1
126	-	ParkedRouteResume
127	-	ParkedRouteSwitch
128	-	)
129	-
130	-	// ParkedRouteRequest prepares, resumes, or switches the retained authenticated
131	-	// route. Target is present only for Switch and retains exact lifecycle/tab
132	-	// authority from the home picker's remote catalogue row.
133	-	type ParkedRouteRequest struct {
134	-	RequestID uint64
135	-	LeaseID ParkedRouteLeaseID
136	-	Action ParkedRouteAction
137	-	Target *domain.RemoteSessionTarget
138	-	}
139	-
140	-	// ParkedRouteStatus is the explicit outcome for a retained-route request.
141	-	type ParkedRouteStatus uint8
142	-
143	-	const (
144	-	ParkedRouteReady ParkedRouteStatus = iota + 1
145	-	ParkedRouteResumed
146	-	ParkedRouteSwitched
147	-	ParkedRouteRejected
148	-	ParkedRouteExpired
149	-	ParkedRouteStaleTarget
150	-	)
151	-
152	-	// ParkedRouteResponse correlates one retained-route request with its outcome.
153	-	type ParkedRouteResponse struct {
154	-	RequestID uint64
155	-	Status ParkedRouteStatus
156	-	}
157	-
158	-	// RemotePreviewSchemaVersion is independent from the attachment IPC version.
159	-	const RemotePreviewSchemaVersion uint16 = 1
160	-
161	-	// RemotePreviewStatus is a closed response taxonomy. Terminal contents are
162	-	// never carried in an error response.
163	-	type RemotePreviewStatus uint8
164	-
165	-	const (
166	-	RemotePreviewOK RemotePreviewStatus = iota
167	-	RemotePreviewUnavailable
168	-	RemotePreviewNoSuchTarget
169	-	RemotePreviewStale
170	-	RemotePreviewMalformed
171	-	RemotePreviewTooLarge
172	-	)
173	-
174	-	// RemotePreviewRequest asks the owning daemon for an in-memory live viewport.
175	-	type RemotePreviewRequest struct {
176	-	Version uint16
177	-	Target domain.RemoteSessionTarget
178	-	Width uint16
179	-	Height uint16
180	-	}
181	-
182	-	// RemotePreview is a bounded row-major styled-cell viewport. It is a
183	-	// process-memory DTO and is never persisted, logged, or traced.
184	-	type RemotePreview struct {
185	-	Version uint16
186	-	Status RemotePreviewStatus
187	-	LifecycleID domain.SessionLifecycleID
188	-	TabID domain.TabStableID
189	-	Revision uint64
190	-	Width uint16
191	-	Height uint16
192	-	Cells []renderer.Cell
193	-	}

M internal/ports/frame_test.go +3 -1

@@ -1,6 +1,8 @@
1		package ports	1		package ports
2			2
3	-	import "testing"	3	+	import (
			4	+	"testing"
			5	+	)
4			6
5		func TestProtocolVersion(t *testing.T) {	7		func TestProtocolVersion(t *testing.T) {
6		if ProtocolVersion != 37 {	8		if ProtocolVersion != 37 {

M internal/ports/mocks/remote_mock.go +8 -7

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	mock "github.com/stretchr/testify/mock"
 )
 }
 // Preview provides a mock function for the type MockRemotePreviewClient
-func (_mock *MockRemotePreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (ports.RemotePreview, error) {
+func (_mock *MockRemotePreviewClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (protocol.RemotePreview, error) {
 	ret := _mock.Called(ctx, target, width, height)
 	if len(ret) == 0 {
 		panic("no return value specified for Preview")
 	}
-	var r0 ports.RemotePreview
+	var r0 protocol.RemotePreview
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) (ports.RemotePreview, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) (protocol.RemotePreview, error)); ok {
 		return returnFunc(ctx, target, width, height)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) ports.RemotePreview); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) protocol.RemotePreview); ok {
 		r0 = returnFunc(ctx, target, width, height)
 	} else {
-		r0 = ret.Get(0).(ports.RemotePreview)
+		r0 = ret.Get(0).(protocol.RemotePreview)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.RemoteSessionTarget, uint16, uint16) error); ok {
 		r1 = returnFunc(ctx, target, width, height)
 	return _c
 }
-func (_c *MockRemotePreviewClient_Preview_Call) Return(remotePreview ports.RemotePreview, err error) *MockRemotePreviewClient_Preview_Call {
+func (_c *MockRemotePreviewClient_Preview_Call) Return(remotePreview protocol.RemotePreview, err error) *MockRemotePreviewClient_Preview_Call {
 	_c.Call.Return(remotePreview, err)
 	return _c
 }
-func (_c *MockRemotePreviewClient_Preview_Call) RunAndReturn(run func(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (ports.RemotePreview, error)) *MockRemotePreviewClient_Preview_Call {
+func (_c *MockRemotePreviewClient_Preview_Call) RunAndReturn(run func(ctx context.Context, target domain.RemoteSessionTarget, width uint16, height uint16) (protocol.RemotePreview, error)) *MockRemotePreviewClient_Preview_Call {
 	_c.Call.Return(run)
 	return _c
 }

M internal/ports/navigation_test.go +45 -44


@@ -5,22 +5,23 @@ 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/protocol"
8		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
9		)	10		)
10			11
11		func TestNavigationDirectiveWireTable(t *testing.T) {	12		func TestNavigationDirectiveWireTable(t *testing.T) {
12	-	lease := ParkedRouteLeaseID{1, 2, 3}	13	+	lease := protocol.ParkedRouteLeaseID{1, 2, 3}
13		tests := []struct {	14		tests := []struct {
14		name string	15		name string
15	-	directive NavigationDirective	16	+	directive protocol.NavigationDirective
16		valid bool	17		valid bool
17		}{	18		}{
18	-	{name: "open home", directive: NavigationDirective{Action: NavigationOpenHomePicker, LeaseID: lease}, valid: true},	19	+	{name: "open home", directive: protocol.NavigationDirective{Action: protocol.NavigationOpenHomePicker, LeaseID: lease}, valid: true},
19	-	{name: "back", directive: NavigationDirective{Action: NavigationBack}, valid: true},	20	+	{name: "back", directive: protocol.NavigationDirective{Action: protocol.NavigationBack}, valid: true},
20	-	{name: "open home without lease", directive: NavigationDirective{Action: NavigationOpenHomePicker}},	21	+	{name: "open home without lease", directive: protocol.NavigationDirective{Action: protocol.NavigationOpenHomePicker}},
21	-	{name: "back with lease", directive: NavigationDirective{Action: NavigationBack, LeaseID: lease}},	22	+	{name: "back with lease", directive: protocol.NavigationDirective{Action: protocol.NavigationBack, LeaseID: lease}},
22	-	{name: "zero", directive: NavigationDirective{}},	23	+	{name: "zero", directive: protocol.NavigationDirective{}},
23	-	{name: "unknown", directive: NavigationDirective{Action: 3}},	24	+	{name: "unknown", directive: protocol.NavigationDirective{Action: 3}},
24		}	25		}
25			26
26		for _, tt := range tests {	27		for _, tt := range tests {

@@ -35,25 +36,25 @@ func TestNavigationDirectiveWireTable(t *testing.T) {
35		require.Equal(t, tt.directive, decoded)	36		require.Equal(t, tt.directive, decoded)
36		assertAllPrefixesFail(t, got, UnmarshalNavigationDirective)	37		assertAllPrefixesFail(t, got, UnmarshalNavigationDirective)
37		_, err = UnmarshalNavigationDirective(append(append([]byte(nil), got...), 0))	38		_, err = UnmarshalNavigationDirective(append(append([]byte(nil), got...), 0))
38	-	require.ErrorIs(t, err, ErrInvalidNavigation)	39	+	require.ErrorIs(t, err, protocol.ErrInvalidNavigation)
39		})	40		})
40		}	41		}
41		}	42		}
42			43
43		func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {	44		func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {
44	-	lease := ParkedRouteLeaseID{1, 2, 3}	45	+	lease := protocol.ParkedRouteLeaseID{1, 2, 3}
45		target := &domain.RemoteSessionTarget{	46		target := &domain.RemoteSessionTarget{
46		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: domain.SessionLifecycleID{4},	47		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: domain.SessionLifecycleID{4},
47		SessionName: "work", LiveTabID: "tab-1",	48		SessionName: "work", LiveTabID: "tab-1",
48		}	49		}
49		requests := []struct {	50		requests := []struct {
50		name string	51		name string
51	-	value ParkedRouteRequest	52	+	value protocol.ParkedRouteRequest
52		golden string	53		golden string
53		}{	54		}{
54	-	{name: "prepare", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: ParkedRoutePrepare}, golden: "0000000000000001" + "01020300000000000000000000000000" + "010001"},	55	+	{name: "prepare", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: protocol.ParkedRoutePrepare}, golden: "0000000000000001" + "01020300000000000000000000000000" + "010001"},
55	-	{name: "resume", value: ParkedRouteRequest{RequestID: 2, LeaseID: lease, Action: ParkedRouteResume}},	56	+	{name: "resume", value: protocol.ParkedRouteRequest{RequestID: 2, LeaseID: lease, Action: protocol.ParkedRouteResume}},
56	-	{name: "switch", value: ParkedRouteRequest{RequestID: 3, LeaseID: lease, Action: ParkedRouteSwitch, Target: target}},	57	+	{name: "switch", value: protocol.ParkedRouteRequest{RequestID: 3, LeaseID: lease, Action: protocol.ParkedRouteSwitch, Target: target}},
57		}	58		}
58		for _, tt := range requests {	59		for _, tt := range requests {
59		t.Run("request "+tt.name, func(t *testing.T) {	60		t.Run("request "+tt.name, func(t *testing.T) {

@@ -74,15 +75,15 @@ func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {
74			75
75		responses := []struct {	76		responses := []struct {
76		name string	77		name string
77	-	value ParkedRouteResponse	78	+	value protocol.ParkedRouteResponse
78		golden string	79		golden string
79		}{	80		}{
80	-	{name: "ready", value: ParkedRouteResponse{RequestID: 1, Status: ParkedRouteReady}, golden: "000000000000000101"},	81	+	{name: "ready", value: protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady}, golden: "000000000000000101"},
81	-	{name: "resumed", value: ParkedRouteResponse{RequestID: 2, Status: ParkedRouteResumed}},	82	+	{name: "resumed", value: protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed}},
82	-	{name: "switched", value: ParkedRouteResponse{RequestID: 3, Status: ParkedRouteSwitched}},	83	+	{name: "switched", value: protocol.ParkedRouteResponse{RequestID: 3, Status: protocol.ParkedRouteSwitched}},
83	-	{name: "rejected", value: ParkedRouteResponse{RequestID: 4, Status: ParkedRouteRejected}},	84	+	{name: "rejected", value: protocol.ParkedRouteResponse{RequestID: 4, Status: protocol.ParkedRouteRejected}},
84	-	{name: "expired", value: ParkedRouteResponse{RequestID: 5, Status: ParkedRouteExpired}},	85	+	{name: "expired", value: protocol.ParkedRouteResponse{RequestID: 5, Status: protocol.ParkedRouteExpired}},
85	-	{name: "stale target", value: ParkedRouteResponse{RequestID: 6, Status: ParkedRouteStaleTarget}},	86	+	{name: "stale target", value: protocol.ParkedRouteResponse{RequestID: 6, Status: protocol.ParkedRouteStaleTarget}},
86		}	87		}
87		for _, tt := range responses {	88		for _, tt := range responses {
88		t.Run("response "+tt.name, func(t *testing.T) {	89		t.Run("response "+tt.name, func(t *testing.T) {

@@ -102,15 +103,15 @@ func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {
102			103
103		invalidRequests := []struct {	104		invalidRequests := []struct {
104		name string	105		name string
105	-	value ParkedRouteRequest	106	+	value protocol.ParkedRouteRequest
106		}{	107		}{
107	-	{name: "zero request ID", value: ParkedRouteRequest{LeaseID: lease, Action: ParkedRoutePrepare}},	108	+	{name: "zero request ID", value: protocol.ParkedRouteRequest{LeaseID: lease, Action: protocol.ParkedRoutePrepare}},
108	-	{name: "zero lease", value: ParkedRouteRequest{RequestID: 1, Action: ParkedRoutePrepare}},	109	+	{name: "zero lease", value: protocol.ParkedRouteRequest{RequestID: 1, Action: protocol.ParkedRoutePrepare}},
109	-	{name: "unknown action", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: 99}},	110	+	{name: "unknown action", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: 99}},
110	-	{name: "prepare target", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: ParkedRoutePrepare, Target: target}},	111	+	{name: "prepare target", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: protocol.ParkedRoutePrepare, Target: target}},
111	-	{name: "resume target", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: ParkedRouteResume, Target: target}},	112	+	{name: "resume target", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: protocol.ParkedRouteResume, Target: target}},
112	-	{name: "missing switch target", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: ParkedRouteSwitch}},	113	+	{name: "missing switch target", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: protocol.ParkedRouteSwitch}},
113	-	{name: "invalid switch target", value: ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: ParkedRouteSwitch, Target: &domain.RemoteSessionTarget{}}},	114	+	{name: "invalid switch target", value: protocol.ParkedRouteRequest{RequestID: 1, LeaseID: lease, Action: protocol.ParkedRouteSwitch, Target: &domain.RemoteSessionTarget{}}},
114		}	115		}
115		for _, tt := range invalidRequests {	116		for _, tt := range invalidRequests {
116		t.Run("invalid request "+tt.name, func(t *testing.T) {	117		t.Run("invalid request "+tt.name, func(t *testing.T) {

@@ -119,11 +120,11 @@ func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {
119		}	120		}
120		for _, tt := range []struct {	121		for _, tt := range []struct {
121		name string	122		name string
122	-	value ParkedRouteResponse	123	+	value protocol.ParkedRouteResponse
123		}{	124		}{
124	-	{name: "zero request ID", value: ParkedRouteResponse{Status: ParkedRouteReady}},	125	+	{name: "zero request ID", value: protocol.ParkedRouteResponse{Status: protocol.ParkedRouteReady}},
125	-	{name: "zero status", value: ParkedRouteResponse{RequestID: 1}},	126	+	{name: "zero status", value: protocol.ParkedRouteResponse{RequestID: 1}},
126	-	{name: "unknown status", value: ParkedRouteResponse{RequestID: 1, Status: 99}},	127	+	{name: "unknown status", value: protocol.ParkedRouteResponse{RequestID: 1, Status: 99}},
127		} {	128		} {
128		t.Run("invalid response "+tt.name, func(t *testing.T) {	129		t.Run("invalid response "+tt.name, func(t *testing.T) {
129		require.Nil(t, MarshalParkedRouteResponse(tt.value))	130		require.Nil(t, MarshalParkedRouteResponse(tt.value))

@@ -141,22 +142,22 @@ func TestHelloNavigationValidationTable(t *testing.T) {
141		name string	142		name string
142		hello Hello	143		hello Hello
143		valid bool	144		valid bool
144	-	capability NavigationCapabilities	145	+	capability protocol.NavigationCapabilities
145	-	overlay StartupOverlay	146	+	overlay protocol.StartupOverlay
146		wantPayload string	147		wantPayload string
147		}{	148		}{
148		{name: "ordinary", hello: base, valid: true},	149		{name: "ordinary", hello: base, valid: true},
149		{name: "resume route", hello: Hello{Version: ProtocolVersion, Intent: IntentResume, Size: domain.Size{Cols: 80, Rows: 24}}, valid: true},	150		{name: "resume route", hello: Hello{Version: ProtocolVersion, Intent: IntentResume, Size: domain.Size{Cols: 80, Rows: 24}}, valid: true},
150	-	{name: "daemon-owned home picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityHomePicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: true, capability: NavigationCapabilityHomePicker},	151	+	{name: "daemon-owned home picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityHomePicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: true, capability: protocol.NavigationCapabilityHomePicker},
151	-	{name: "remote-target home picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: NavigationCapabilityHomePicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: true, capability: NavigationCapabilityHomePicker},	152	+	{name: "remote-target home picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: protocol.NavigationCapabilityHomePicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: true, capability: protocol.NavigationCapabilityHomePicker},
152	-	{name: "client-owned home picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityHomePicker}, valid: false},	153	+	{name: "client-owned home picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}, valid: false},
153	-	{name: "daemon-owned back picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityBack, StartupOverlay: StartupOverlaySessionPicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: false},	154	+	{name: "daemon-owned back picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: false},
154	-	{name: "remote-target back picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: NavigationCapabilityBack, StartupOverlay: StartupOverlaySessionPicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: false},	155	+	{name: "remote-target back picker rejected", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}, valid: false},
155	-	{name: "back with startup picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityBack, StartupOverlay: StartupOverlaySessionPicker}, valid: true, capability: NavigationCapabilityBack, overlay: StartupOverlaySessionPicker, wantPayload: "002502" + "00000000000000000000000000000000" + "0000000000000000" + "0000" + "00500018" + "00000000" + "0000" + "0000" + "00" + "00" + "00000000" + "00" + "00" + "00" + "0000" + "02010000"},	156	+	{name: "back with startup picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: true, capability: protocol.NavigationCapabilityBack, overlay: protocol.StartupOverlaySessionPicker, wantPayload: "002502" + "00000000000000000000000000000000" + "0000000000000000" + "0000" + "00500018" + "00000000" + "0000" + "0000" + "00" + "00" + "00000000" + "00" + "00" + "00" + "0000" + "02010000"},
156	-	{name: "new rejects navigation", hello: Hello{Version: ProtocolVersion, Intent: IntentNew, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityBack, StartupOverlay: StartupOverlaySessionPicker}, valid: false},	157	+	{name: "new rejects navigation", hello: Hello{Version: ProtocolVersion, Intent: IntentNew, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: false},
157		{name: "unknown capability", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: 4}, valid: false},	158		{name: "unknown capability", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: 4}, valid: false},
158	-	{name: "back without picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: NavigationCapabilityBack}, valid: false},	159	+	{name: "back without picker", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack}, valid: false},
159	-	{name: "picker without back", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, StartupOverlay: StartupOverlaySessionPicker}, valid: false},	160	+	{name: "picker without back", hello: Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: false},
160		}	161		}
161			162
162		for _, tt := range tests {	163		for _, tt := range tests {

M internal/ports/output_compression_test.go +6 -5

 	"testing"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestOutputCompression(t *testing.T) {
-	full := Output{
+	full := protocol.Output{
 		Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 120, Rows: 40}, Full: true,
 		Data: bytes.Repeat([]byte("\x1b[38;2;120;180;240mstyled viewport row\x1b[0m\r\n"), 128),
 	}
 	for _, tt := range []struct {
 		name     string
-		output   Output
+		output   protocol.Output
 		wantKind byte
 	}{
 		{name: "large full snapshot", output: full, wantKind: outputCompressionZlib},
 		{name: "incremental output", output: incremental, wantKind: outputCompressionNone},
-		{name: "small full snapshot", output: Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("small")}, wantKind: outputCompressionNone},
+		{name: "small full snapshot", output: protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("small")}, wantKind: outputCompressionNone},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			payload, err := MarshalOutput(tt.output)
 }
 func TestCompressedOutputRejectsMalformedPayloads(t *testing.T) {
-	output := Output{
+	output := protocol.Output{
 		Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 120, Rows: 40}, Full: true,
 		Data: bytes.Repeat([]byte("\x1b[31mcompressed\x1b[0m\r\n"), 256),
 	}
 }
 func BenchmarkMarshalOutput(b *testing.B) {
-	fixtures := map[string]Output{
+	fixtures := map[string]protocol.Output{
 		"empty-120x40": {
 			Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 120, Rows: 40}, Full: true,
 			Data: bytes.Repeat([]byte(" "), 120*40),

M internal/ports/remote.go +2 -1

 	"unicode/utf8"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 // RemoteTransportMode selects the transport used for remote attach after CLI parsing.
 // RemotePreviewClient fetches one bounded, exact-target viewport without
 // attaching to or mutating the remote session.
 type RemotePreviewClient interface {
-	Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (RemotePreview, error)
+	Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error)
 }
 const (

M internal/ports/remote_preview_hardening_test.go +15 -14

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 const (
 	if err != nil {
 		t.Fatalf("UnmarshalRemotePreview() error = %v", err)
 	}
-	if got.Version != RemotePreviewSchemaVersion || got.Status != RemotePreviewOK {
+	if got.Version != protocol.RemotePreviewSchemaVersion || got.Status != protocol.RemotePreviewOK {
-		t.Fatalf("header = (%d, %d), want (%d, %d)", got.Version, got.Status, RemotePreviewSchemaVersion, RemotePreviewOK)
+		t.Fatalf("header = (%d, %d), want (%d, %d)", got.Version, got.Status, protocol.RemotePreviewSchemaVersion, protocol.RemotePreviewOK)
 	}
 	var wantLifecycle domain.SessionLifecycleID
 	for i := range wantLifecycle {
 func TestRemotePreviewCodecRejectsWideCellBoundaryAndInvalidIDs(t *testing.T) {
 	var lifecycle domain.SessionLifecycleID
 	lifecycle[0] = 1
-	valid := RemotePreview{
+	valid := protocol.RemotePreview{
-		Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 1,
 		Cells: []renderer.Cell{{Rune: '界'}, {Continuation: true}},
 	}
 	if MarshalRemotePreview(valid) == nil {
 		t.Fatal("valid wide-cell preview did not marshal")
 	}
-	for _, malformed := range []RemotePreview{
+	for _, malformed := range []protocol.RemotePreview{
-		{Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 1, Height: 1, Cells: []renderer.Cell{{Rune: '界'}}},
+		{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 1, Height: 1, Cells: []renderer.Cell{{Rune: '界'}}},
-		{Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 1, Cells: []renderer.Cell{{Continuation: true}, {Rune: 'x'}}},
+		{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 1, Cells: []renderer.Cell{{Continuation: true}, {Rune: 'x'}}},
-		{Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 1, Cells: []renderer.Cell{{Rune: '界'}, {Continuation: true, Rune: 'x'}}},
+		{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 1, Cells: []renderer.Cell{{Rune: '界'}, {Continuation: true, Rune: 'x'}}},
-		{Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 2, Cells: []renderer.Cell{{Rune: 'x'}, {Rune: '界'}, {Continuation: true}, {Rune: 'y'}}},
+		{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK, LifecycleID: lifecycle, TabID: "tab-1", Revision: 1, Width: 2, Height: 2, Cells: []renderer.Cell{{Rune: 'x'}, {Rune: '界'}, {Continuation: true}, {Rune: 'y'}}},
 	} {
 		if MarshalRemotePreview(malformed) != nil {
 			t.Fatalf("malformed wide-cell preview marshaled: %#v", malformed.Cells)
 }
 func TestRemotePreviewRejectsControlRunes(t *testing.T) {
-	valid := RemotePreview{
+	valid := protocol.RemotePreview{
-		Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: previewTargetForTest().LifecycleID, TabID: "tab-1", Revision: 1, Width: 1, Height: 1,
 		Cells: []renderer.Cell{{Rune: 'x'}},
 	}
 	for _, control := range []rune{'\x01', '\x1b', '\x7f', '\u0085'} {
 		preview := valid
 		preview.Cells = []renderer.Cell{{Rune: control}}
-		if err := ValidateRemotePreview(preview); err != ErrInvalidRemotePreview {
+		if err := protocol.ValidateRemotePreview(preview); err != protocol.ErrInvalidRemotePreview {
-			t.Fatalf("control rune %U: ValidateRemotePreview() error = %v, want %v", control, err, ErrInvalidRemotePreview)
+			t.Fatalf("control rune %U: ValidateRemotePreview() error = %v, want %v", control, err, protocol.ErrInvalidRemotePreview)
 		}
 		if MarshalRemotePreview(preview) != nil {
 			t.Fatalf("control rune %U was marshaled", control)
 func TestRemotePreviewRequestRejectsOversizedNestedRouteData(t *testing.T) {
 	target := previewTargetForTest()
 	target.Endpoint = strings.Repeat("h", math.MaxUint16+1)
-	request := RemotePreviewRequest{Version: RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}
+	request := protocol.RemotePreviewRequest{Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}
 	if MarshalRemotePreviewRequest(request) != nil {
 		t.Fatal("oversized endpoint was truncated and marshaled")
 	}

M internal/ports/remote_preview_test.go +7 -6

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 func previewTargetForTest() domain.RemoteSessionTarget {
 	style.Attrs = renderer.AttrUnderline
 	style.HasForegroundRGB = true
 	style.ForegroundRGB = renderer.RGB{R: 1, G: 2, B: 3}
-	preview := RemotePreview{
+	preview := protocol.RemotePreview{
-		Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: previewTargetForTest().LifecycleID, TabID: "tab-1", Revision: 4, Width: 3, Height: 1,
 		Cells: []renderer.Cell{{Rune: '界', Style: style}, {Continuation: true, Style: style}, {Rune: 'x', Style: style}},
 	}
 }
 func TestRemotePreviewCodecRejectsMalformedBoundsAndGarbage(t *testing.T) {
-	preview := RemotePreview{Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK, LifecycleID: previewTargetForTest().LifecycleID, TabID: "tab-1", Revision: 1, Width: 1, Height: 1, Cells: []renderer.Cell{{Rune: 'x'}}}
+	preview := protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK, LifecycleID: previewTargetForTest().LifecycleID, TabID: "tab-1", Revision: 1, Width: 1, Height: 1, Cells: []renderer.Cell{{Rune: 'x'}}}
 	payload := MarshalRemotePreview(preview)
 	for i := 0; i < len(payload); i++ {
 		if _, err := UnmarshalRemotePreview(payload[:i]); err == nil {
 		t.Fatal("trailing garbage unexpectedly decoded")
 	}
 	bad := preview
-	bad.Width = RemotePreviewMaxWidth + 1
+	bad.Width = protocol.RemotePreviewMaxWidth + 1
 	if MarshalRemotePreview(bad) != nil {
 		t.Fatal("oversized preview marshaled")
 	}
 func TestRemotePreviewRequestRejectsStoppedAndInvalidTargets(t *testing.T) {
 	target := previewTargetForTest()
-	request := RemotePreviewRequest{Version: RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}
+	request := protocol.RemotePreviewRequest{Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}
 	if MarshalRemotePreviewRequest(request) == nil {
 		t.Fatal("valid preview request did not marshal")
 	}
 	target.Stopped = true
 	target.LiveTabID = ""
 	target.StoppedTab = domain.NewOrdinalTabSelector(0, "", 1)
-	if MarshalRemotePreviewRequest(RemotePreviewRequest{Version: RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}) != nil {
+	if MarshalRemotePreviewRequest(protocol.RemotePreviewRequest{Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: 20, Height: 5}) != nil {
 		t.Fatal("stopped preview request marshaled")
 	}
 }

M internal/ports/routes_test.go +52 -46

 	"testing"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
-func testExactTarget() ExactSessionTarget {
+func testExactTarget() protocol.ExactSessionTarget {
-	return ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1, 2, 3}, SessionName: "work"}
+	return protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1, 2, 3}, SessionName: "work"}
 }
 func TestExactSessionTargetCodecIsStrict(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, want, got)
-	_, err = MarshalExactSessionTarget(ExactSessionTarget{SessionName: "work"})
+	_, err = MarshalExactSessionTarget(protocol.ExactSessionTarget{SessionName: "work"})
-	require.ErrorIs(t, err, ErrInvalidRouteWire)
+	require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
 }
 func TestHelloExactTargetRoundTrip(t *testing.T) {
 }
 func TestRoutePositionCodecIsStrict(t *testing.T) {
-	want := RoutePosition{Target: testExactTarget(), ActiveTabID: "tab-2"}
+	want := protocol.RoutePosition{Target: testExactTarget(), ActiveTabID: "tab-2"}
 	encoded, err := MarshalRoutePosition(want)
 	require.NoError(t, err)
 	require.Equal(t, "010203000000000000000000000000000004776f726b00057461622d32", hex.EncodeToString(encoded))
 	require.NoError(t, err)
 	require.Equal(t, want, got)
-	_, err = MarshalRoutePosition(RoutePosition{Target: testExactTarget()})
+	_, err = MarshalRoutePosition(protocol.RoutePosition{Target: testExactTarget()})
-	require.ErrorIs(t, err, ErrInvalidRouteWire)
+	require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
-	_, err = MarshalRoutePosition(RoutePosition{Target: testExactTarget(), ActiveTabID: "bad tab"})
+	_, err = MarshalRoutePosition(protocol.RoutePosition{Target: testExactTarget(), ActiveTabID: "bad tab"})
-	require.ErrorIs(t, err, ErrInvalidRouteWire)
+	require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
 }
 func TestWelcomeCarriesCommittedRouteIdentity(t *testing.T) {
-	identity := &CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}
+	identity := &protocol.CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}
 	want := Welcome{SessionID: "daemon-session", SessionName: "work", Ephemeral: true, CommittedIdentity: identity}
 	got, err := UnmarshalWelcome(MarshalWelcome(want))
 }
 func TestWelcomeRejectsMismatchedCommittedIdentity(t *testing.T) {
-	identity := &CommittedRouteIdentity{Target: testExactTarget()}
+	identity := &protocol.CommittedRouteIdentity{Target: testExactTarget()}
 	payload := MarshalWelcome(Welcome{SessionID: "daemon-session", SessionName: "other", CommittedIdentity: identity})
 	require.Nil(t, payload)
 }
 func TestCommittedRouteIdentityCodec(t *testing.T) {
-	want := CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}
+	want := protocol.CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}
 	encoded, err := MarshalCommittedRouteIdentity(want)
 	require.NoError(t, err)
 	require.Error(t, err)
 }
-func testRouteSnapshot() RecentRouteSnapshot {
+func testRouteSnapshot() protocol.RecentRouteSnapshot {
 	activeTarget := testExactTarget()
-	logsTarget := ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{4, 5, 6}, SessionName: "logs"}
+	logsTarget := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{4, 5, 6}, SessionName: "logs"}
-	return RecentRouteSnapshot{
+	return protocol.RecentRouteSnapshot{
 		Generation:  9,
-		Active:      RouteRef{Key: 11, Generation: 3},
+		Active:      protocol.RouteRef{Key: 11, Generation: 3},
-		ActiveEntry: RecentRouteEntry{Key: 11, Generation: 3, Target: activeTarget, Name: "work", Kind: RouteKindLocal, Reachability: RouteReachabilityUnknown},
+		ActiveEntry: protocol.RecentRouteEntry{Key: 11, Generation: 3, Target: activeTarget, Name: "work", Kind: protocol.RouteKindLocal, Reachability: protocol.RouteReachabilityUnknown},
-		Previous:    RouteRef{Key: 12, Generation: 4},
+		Previous:    protocol.RouteRef{Key: 12, Generation: 4},
-		Home:        RouteRef{Key: 11, Generation: 3},
+		Home:        protocol.RouteRef{Key: 11, Generation: 3},
-		Entries: []RecentRouteEntry{
+		Entries: []protocol.RecentRouteEntry{
-			{Key: 12, Generation: 4, Target: logsTarget, Name: "logs", HostLabel: "edge", Kind: RouteKindRemote, Attention: true, Reachability: RouteReachabilityUnknown},
+			{Key: 12, Generation: 4, Target: logsTarget, Name: "logs", HostLabel: "edge", Kind: protocol.RouteKindRemote, Attention: true, Reachability: protocol.RouteReachabilityUnknown},
 		},
 	}
 }
 	invalidCases := []struct {
 		name   string
-		mutate func(*RecentRouteSnapshot)
+		mutate func(*protocol.RecentRouteSnapshot)
 	}{
-		{name: "missing previous reference", mutate: func(snapshot *RecentRouteSnapshot) { snapshot.Previous = RouteRef{Key: 99, Generation: 99} }},
+		{name: "missing previous reference", mutate: func(snapshot *protocol.RecentRouteSnapshot) {
-		{name: "missing active presentation", mutate: func(snapshot *RecentRouteSnapshot) { snapshot.ActiveEntry = RecentRouteEntry{} }},
+			snapshot.Previous = protocol.RouteRef{Key: 99, Generation: 99}
-		{name: "route name differs from lifecycle target", mutate: func(snapshot *RecentRouteSnapshot) { snapshot.Entries[0].Name = "other" }},
+		}},
-		{name: "entry is active", mutate: func(snapshot *RecentRouteSnapshot) {
+		{name: "missing active presentation", mutate: func(snapshot *protocol.RecentRouteSnapshot) { snapshot.ActiveEntry = protocol.RecentRouteEntry{} }},
+		{name: "route name differs from lifecycle target", mutate: func(snapshot *protocol.RecentRouteSnapshot) { snapshot.Entries[0].Name = "other" }},
+		{name: "entry is active", mutate: func(snapshot *protocol.RecentRouteSnapshot) {
 			snapshot.Entries = append(snapshot.Entries, snapshot.ActiveEntry)
 		}},
-		{name: "duplicate entry", mutate: func(snapshot *RecentRouteSnapshot) { snapshot.Entries = append(snapshot.Entries, snapshot.Entries[0]) }},
+		{name: "duplicate entry", mutate: func(snapshot *protocol.RecentRouteSnapshot) {
-		{name: "too many entries", mutate: func(snapshot *RecentRouteSnapshot) {
+			snapshot.Entries = append(snapshot.Entries, snapshot.Entries[0])
-			snapshot.Entries = make([]RecentRouteEntry, RouteSnapshotMaxEntries+1)
+		}},
+		{name: "too many entries", mutate: func(snapshot *protocol.RecentRouteSnapshot) {
+			snapshot.Entries = make([]protocol.RecentRouteEntry, protocol.RouteSnapshotMaxEntries+1)
 			for i := range snapshot.Entries {
-				target := ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{byte(i + 1)}, SessionName: "x"}
+				target := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{byte(i + 1)}, SessionName: "x"}
-				snapshot.Entries[i] = RecentRouteEntry{Key: uint64(i + 1), Generation: uint64(i + 1), Target: target, Name: "x", Kind: RouteKindLocal}
+				snapshot.Entries[i] = protocol.RecentRouteEntry{Key: uint64(i + 1), Generation: uint64(i + 1), Target: target, Name: "x", Kind: protocol.RouteKindLocal}
 			}
 		}},
 	}
 	for _, tc := range invalidCases {
 		t.Run(tc.name, func(t *testing.T) {
 			invalid := want
+			invalid.Entries = append([]protocol.RecentRouteEntry(nil), want.Entries...)
 			tc.mutate(&invalid)
 			_, err := MarshalRecentRouteSnapshot(invalid)
-			require.ErrorIs(t, err, ErrInvalidRouteWire)
+			require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
 		})
 	}
 }
 func TestRouteAttentionSubscriptionCodecIsStrict(t *testing.T) {
-	want := RouteAttentionSubscription{Targets: []RouteAttentionTarget{{
+	want := protocol.RouteAttentionSubscription{Targets: []protocol.RouteAttentionTarget{{
-		Ref:    RouteRef{Key: 7, Generation: 3},
+		Ref:    protocol.RouteRef{Key: 7, Generation: 3},
 		Target: testExactTarget(),
 	}}}
 	encoded, err := MarshalRouteAttentionSubscription(want)
 	require.NoError(t, err)
 	require.Equal(t, want, got)
-	_, err = MarshalRouteAttentionSubscription(RouteAttentionSubscription{Targets: []RouteAttentionTarget{
+	_, err = MarshalRouteAttentionSubscription(protocol.RouteAttentionSubscription{Targets: []protocol.RouteAttentionTarget{
 		want.Targets[0], want.Targets[0],
 	}})
-	require.ErrorIs(t, err, ErrInvalidRouteWire)
+	require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
 }
 func TestRecentRouteSnapshotRejectsOversizedFrameBeforeParsing(t *testing.T) {
 	_, err := UnmarshalRecentRouteSnapshot(make([]byte, MaxFrameLen))
-	require.ErrorIs(t, err, ErrInvalidRouteWire)
+	require.ErrorIs(t, err, protocol.ErrInvalidRouteWire)
 }
 func TestRouteLabelBoundsMatchRemoteDisplayOrigin(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := ValidateRouteLabel(strings.Repeat("a", tt.length), false)
+			err := protocol.ValidateRouteLabel(strings.Repeat("a", tt.length), false)
 			if tt.wantErr {
 				require.Error(t, err)
 				return
 	values := []string{"line\nfeed", "\u2028line-separator", "\u2029paragraph-separator", "\x1b[31mred", "\u202eoverride", string([]byte{0xff, 0xfe})}
 	for _, value := range values {
 		t.Run("name/"+value, func(t *testing.T) {
-			_, err := MarshalRecentRouteSnapshot(RecentRouteSnapshot{
+			_, err := MarshalRecentRouteSnapshot(protocol.RecentRouteSnapshot{
 				Generation: 1,
-				Entries:    []RecentRouteEntry{{Key: 1, Generation: 1, Target: ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: value}, Name: value, Kind: RouteKindLocal}},
+				Entries:    []protocol.RecentRouteEntry{{Key: 1, Generation: 1, Target: protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: value}, Name: value, Kind: protocol.RouteKindLocal}},
 			})
 			require.Error(t, err)
 		})
 		t.Run("host/"+value, func(t *testing.T) {
-			_, err := MarshalRecentRouteSnapshot(RecentRouteSnapshot{
+			_, err := MarshalRecentRouteSnapshot(protocol.RecentRouteSnapshot{
 				Generation: 1,
-				Entries:    []RecentRouteEntry{{Key: 1, Generation: 1, Target: testExactTarget(), Name: "work", HostLabel: value, Kind: RouteKindRemote}},
+				Entries:    []protocol.RecentRouteEntry{{Key: 1, Generation: 1, Target: testExactTarget(), Name: "work", HostLabel: value, Kind: protocol.RouteKindRemote}},
 			})
 			require.Error(t, err)
 		})
 }
 func TestRouteActionAndFailureCodecsAreBounded(t *testing.T) {
-	action := RouteNavigationAction{SnapshotGeneration: 9, Key: 7, Generation: 8}
+	action := protocol.RouteNavigationAction{SnapshotGeneration: 9, Key: 7, Generation: 8}
 	encoded, err := MarshalRouteNavigationAction(action)
 	require.NoError(t, err)
 	require.Equal(t, "000000000000000900000000000000070000000000000008", hex.EncodeToString(encoded))
 	require.NoError(t, err)
 	require.Equal(t, action, got)
-	failure := RouteNavigationFailure{Key: 7, Generation: 8, Code: RouteFailureStaleSelection}
+	failure := protocol.RouteNavigationFailure{Key: 7, Generation: 8, Code: protocol.RouteFailureStaleSelection}
 	encoded, err = MarshalRouteNavigationFailure(failure)
 	require.NoError(t, err)
 	require.Equal(t, "0000000000000007000000000000000801", hex.EncodeToString(encoded))
 	require.NoError(t, err)
 	require.Equal(t, failure, gotFailure)
-	for _, invalid := range []RouteNavigationAction{{}, {SnapshotGeneration: 1, Key: 1}, {SnapshotGeneration: 1, Generation: 1}, {Key: 1, Generation: 1}} {
+	for _, invalid := range []protocol.RouteNavigationAction{{}, {SnapshotGeneration: 1, Key: 1}, {SnapshotGeneration: 1, Generation: 1}, {Key: 1, Generation: 1}} {
 		_, err := MarshalRouteNavigationAction(invalid)
 		require.Error(t, err)
 	}
-	for _, invalid := range []RouteNavigationFailure{{}, {Key: 1, Generation: 1}, {Key: 1, Generation: 1, Code: 255}} {
+	for _, invalid := range []protocol.RouteNavigationFailure{{}, {Key: 1, Generation: 1}, {Key: 1, Generation: 1, Code: 255}} {
 		_, err := MarshalRouteNavigationFailure(invalid)
 		require.Error(t, err)
 	}

M internal/ports/routes_wire.go +165 -167

 package ports
 import (
-	"errors"
 	"fmt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
-var ErrInvalidRouteWire = errors.New("invalid route wire message")
 func validateRouteString(value, field string, allowEmpty bool) error {
-	if err := ValidateRouteLabel(value, allowEmpty); err != nil {
+	if err := protocol.ValidateRouteLabel(value, allowEmpty); err != nil {
 		return fmt.Errorf("%s: %w", field, err)
 	}
 	return nil
 }
-func marshalExactSessionTarget(w *payloadWriter, target ExactSessionTarget) {
+func marshalExactSessionTarget(w *payloadWriter, target protocol.ExactSessionTarget) {
 	w.putBytes(target.LifecycleID[:])
 	w.putString(target.SessionName)
 }
-func marshalExactTargetSection(w *payloadWriter, target *ExactSessionTarget) {
+func marshalExactTargetSection(w *payloadWriter, target *protocol.ExactSessionTarget) {
 	w.putBool(target != nil)
 	if target != nil {
 		marshalExactSessionTarget(w, *target)
 	}
 }
-func unmarshalExactTargetSection(r *payloadReader) (*ExactSessionTarget, error) {
+func unmarshalExactTargetSection(r *payloadReader) (*protocol.ExactSessionTarget, error) {
 	present, err := r.getBool()
 	if err != nil {
 		return nil, err
 	return nil
 }
-func unmarshalExactSessionTarget(r *payloadReader) (ExactSessionTarget, error) {
+func unmarshalExactSessionTarget(r *payloadReader) (protocol.ExactSessionTarget, error) {
-	var target ExactSessionTarget
+	var target protocol.ExactSessionTarget
 	lifecycle, err := r.getBytes(len(target.LifecycleID))
 	if err != nil {
-		return ExactSessionTarget{}, err
+		return protocol.ExactSessionTarget{}, err
 	}
 	copy(target.LifecycleID[:], lifecycle)
 	if target.SessionName, err = r.getString(); err != nil {
-		return ExactSessionTarget{}, err
+		return protocol.ExactSessionTarget{}, err
 	}
 	if err := target.Validate(); err != nil {
-		return ExactSessionTarget{}, fmt.Errorf("%w: exact target: %v", ErrInvalidRouteWire, err)
+		return protocol.ExactSessionTarget{}, fmt.Errorf("%w: exact target: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	return target, nil
 }
 // MarshalExactSessionTarget encodes the exact lifecycle/name pair used by
 // Hello and route-transition tests.
-func MarshalExactSessionTarget(target ExactSessionTarget) ([]byte, error) {
+func MarshalExactSessionTarget(target protocol.ExactSessionTarget) ([]byte, error) {
 	if err := target.Validate(); err != nil {
-		return nil, fmt.Errorf("%w: exact target: %v", ErrInvalidRouteWire, err)
+		return nil, fmt.Errorf("%w: exact target: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	w := payloadWriter{}
 	marshalExactSessionTarget(&w, target)
 // UnmarshalExactSessionTarget decodes one exact lifecycle/name pair and rejects
 // truncation, invalid identity, and trailing bytes.
-func UnmarshalExactSessionTarget(b []byte) (ExactSessionTarget, error) {
+func UnmarshalExactSessionTarget(b []byte) (protocol.ExactSessionTarget, error) {
 	r := payloadReader{b: b}
 	target, err := unmarshalExactSessionTarget(&r)
 	if err != nil {
-		return ExactSessionTarget{}, err
+		return protocol.ExactSessionTarget{}, err
 	}
 	if err := r.done(); err != nil {
-		return ExactSessionTarget{}, err
+		return protocol.ExactSessionTarget{}, err
 	}
 	return target, nil
 }
 // MarshalSamePeerSwitchRequest encodes the strict in-band session switch
 // confirmation. The target is non-optional and carries no display origin.
-func MarshalSamePeerSwitchRequest(request SamePeerSwitchRequest) ([]byte, error) {
+func MarshalSamePeerSwitchRequest(request protocol.SamePeerSwitchRequest) ([]byte, error) {
 	if err := request.Validate(); err != nil {
 		return nil, err
 	}
 }
 // UnmarshalSamePeerSwitchRequest decodes one complete in-band switch request.
-func UnmarshalSamePeerSwitchRequest(b []byte) (SamePeerSwitchRequest, error) {
+func UnmarshalSamePeerSwitchRequest(b []byte) (protocol.SamePeerSwitchRequest, error) {
 	r := payloadReader{b: b}
-	var request SamePeerSwitchRequest
+	var request protocol.SamePeerSwitchRequest
 	var err error
 	if request.RequestID, err = r.getUint64(); err != nil {
-		return SamePeerSwitchRequest{}, err
+		return protocol.SamePeerSwitchRequest{}, err
 	}
 	if request.Target, err = unmarshalExactSessionTarget(&r); err != nil {
-		return SamePeerSwitchRequest{}, err
+		return protocol.SamePeerSwitchRequest{}, err
 	}
 	preferred, err := r.getString()
 	if err != nil {
-		return SamePeerSwitchRequest{}, err
+		return protocol.SamePeerSwitchRequest{}, err
 	}
 	request.PreferredTabID = domain.TabStableID(preferred)
 	if err := r.done(); err != nil {
-		return SamePeerSwitchRequest{}, err
+		return protocol.SamePeerSwitchRequest{}, err
 	}
 	if err := request.Validate(); err != nil {
-		return SamePeerSwitchRequest{}, err
+		return protocol.SamePeerSwitchRequest{}, err
 	}
 	return request, nil
 }
 // MarshalSamePeerSwitchFailure encodes a bounded pre-commit rejection.
-func MarshalSamePeerSwitchFailure(failure SamePeerSwitchFailure) ([]byte, error) {
+func MarshalSamePeerSwitchFailure(failure protocol.SamePeerSwitchFailure) ([]byte, error) {
 	if err := failure.Validate(); err != nil {
 		return nil, err
 	}
 }
 // UnmarshalSamePeerSwitchFailure decodes a complete bounded rejection.
-func UnmarshalSamePeerSwitchFailure(b []byte) (SamePeerSwitchFailure, error) {
+func UnmarshalSamePeerSwitchFailure(b []byte) (protocol.SamePeerSwitchFailure, error) {
 	r := payloadReader{b: b}
-	var failure SamePeerSwitchFailure
+	var failure protocol.SamePeerSwitchFailure
 	var err error
 	if failure.RequestID, err = r.getUint64(); err != nil {
-		return SamePeerSwitchFailure{}, err
+		return protocol.SamePeerSwitchFailure{}, err
 	}
 	code, err := r.getUint8()
 	if err != nil {
-		return SamePeerSwitchFailure{}, err
+		return protocol.SamePeerSwitchFailure{}, err
 	}
-	failure.Code = SamePeerSwitchFailureCode(code)
+	failure.Code = protocol.SamePeerSwitchFailureCode(code)
 	if err := r.done(); err != nil {
-		return SamePeerSwitchFailure{}, err
+		return protocol.SamePeerSwitchFailure{}, err
 	}
 	if err := failure.Validate(); err != nil {
-		return SamePeerSwitchFailure{}, err
+		return protocol.SamePeerSwitchFailure{}, err
 	}
 	return failure, nil
 }
-func validateCommittedRouteIdentity(identity CommittedRouteIdentity) error {
+func validateCommittedRouteIdentity(identity protocol.CommittedRouteIdentity) error {
 	if err := identity.Validate(); err != nil {
-		return fmt.Errorf("%w: committed identity: %v", ErrInvalidRouteWire, err)
+		return fmt.Errorf("%w: committed identity: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	return nil
 }
 // MarshalCommittedRouteIdentity encodes the daemon's committed exact session
 // identity without exposing transport or client-ledger details.
-func MarshalCommittedRouteIdentity(identity CommittedRouteIdentity) ([]byte, error) {
+func MarshalCommittedRouteIdentity(identity protocol.CommittedRouteIdentity) ([]byte, error) {
 	if err := validateCommittedRouteIdentity(identity); err != nil {
 		return nil, err
 	}
 	return w.b, nil
 }
-func marshalCommittedRouteIdentityFields(w *payloadWriter, identity CommittedRouteIdentity) {
+func marshalCommittedRouteIdentityFields(w *payloadWriter, identity protocol.CommittedRouteIdentity) {
 	marshalExactSessionTarget(w, identity.Target)
 	w.putBool(identity.Ephemeral)
 }
 // marshalCommittedIdentitySection shares the standalone identity body and
 // validates embedded identities before Welcome serialization.
-func marshalCommittedIdentitySection(w *payloadWriter, identity *CommittedRouteIdentity) bool {
+func marshalCommittedIdentitySection(w *payloadWriter, identity *protocol.CommittedRouteIdentity) bool {
 	w.putBool(identity != nil)
 	if identity == nil {
 		return true
 	return true
 }
-func unmarshalCommittedIdentitySection(r *payloadReader) (*CommittedRouteIdentity, error) {
+func unmarshalCommittedIdentitySection(r *payloadReader) (*protocol.CommittedRouteIdentity, error) {
 	present, err := r.getBool()
 	if err != nil {
 		return nil, err
 	if err != nil {
 		return nil, err
 	}
-	identity := &CommittedRouteIdentity{Target: target, Ephemeral: ephemeral}
+	identity := &protocol.CommittedRouteIdentity{Target: target, Ephemeral: ephemeral}
 	if err := validateCommittedRouteIdentity(*identity); err != nil {
 		return nil, err
 	}
 	return identity, nil
 }
-func UnmarshalCommittedRouteIdentity(b []byte) (CommittedRouteIdentity, error) {
+func UnmarshalCommittedRouteIdentity(b []byte) (protocol.CommittedRouteIdentity, error) {
 	r := payloadReader{b: b}
 	target, err := unmarshalExactSessionTarget(&r)
 	if err != nil {
-		return CommittedRouteIdentity{}, err
+		return protocol.CommittedRouteIdentity{}, err
 	}
 	ephemeral, err := r.getBool()
 	if err != nil {
-		return CommittedRouteIdentity{}, err
+		return protocol.CommittedRouteIdentity{}, err
 	}
 	if err := r.done(); err != nil {
-		return CommittedRouteIdentity{}, err
+		return protocol.CommittedRouteIdentity{}, err
 	}
-	identity := CommittedRouteIdentity{Target: target, Ephemeral: ephemeral}
+	identity := protocol.CommittedRouteIdentity{Target: target, Ephemeral: ephemeral}
 	if err := validateCommittedRouteIdentity(identity); err != nil {
-		return CommittedRouteIdentity{}, err
+		return protocol.CommittedRouteIdentity{}, err
 	}
 	return identity, nil
 }
 // MarshalRoutePosition encodes one exact session and its attachment-local tab
 // cursor. Route positions are mutable client memory, not attach authority.
-func MarshalRoutePosition(position RoutePosition) ([]byte, error) {
+func MarshalRoutePosition(position protocol.RoutePosition) ([]byte, error) {
 	if err := position.Validate(); err != nil {
-		return nil, fmt.Errorf("%w: route position: %v", ErrInvalidRouteWire, err)
+		return nil, fmt.Errorf("%w: route position: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	w := payloadWriter{}
 	marshalExactSessionTarget(&w, position.Target)
 }
 // UnmarshalRoutePosition decodes one strict route-position payload.
-func UnmarshalRoutePosition(b []byte) (RoutePosition, error) {
+func UnmarshalRoutePosition(b []byte) (protocol.RoutePosition, error) {
 	r := payloadReader{b: b}
 	target, err := unmarshalExactSessionTarget(&r)
 	if err != nil {
-		return RoutePosition{}, err
+		return protocol.RoutePosition{}, err
 	}
 	activeTabID, err := r.getString()
 	if err != nil {
-		return RoutePosition{}, err
+		return protocol.RoutePosition{}, err
 	}
 	if err := r.done(); err != nil {
-		return RoutePosition{}, err
+		return protocol.RoutePosition{}, err
 	}
-	position := RoutePosition{Target: target, ActiveTabID: domain.TabStableID(activeTabID)}
+	position := protocol.RoutePosition{Target: target, ActiveTabID: domain.TabStableID(activeTabID)}
 	if err := position.Validate(); err != nil {
-		return RoutePosition{}, fmt.Errorf("%w: route position: %v", ErrInvalidRouteWire, err)
+		return protocol.RoutePosition{}, fmt.Errorf("%w: route position: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	return position, nil
 }
-func validateRouteRef(ref RouteRef) error {
+func validateRouteRef(ref protocol.RouteRef) error {
 	if err := ref.Validate(); err != nil {
-		return fmt.Errorf("%w: route reference: %v", ErrInvalidRouteWire, err)
+		return fmt.Errorf("%w: route reference: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	return nil
 }
-func marshalRouteRef(w *payloadWriter, ref RouteRef) {
+func marshalRouteRef(w *payloadWriter, ref protocol.RouteRef) {
 	w.putUint64(ref.Key)
 	w.putUint64(ref.Generation)
 }
-func unmarshalRouteRef(r *payloadReader) (RouteRef, error) {
+func unmarshalRouteRef(r *payloadReader) (protocol.RouteRef, error) {
 	key, err := r.getUint64()
 	if err != nil {
-		return RouteRef{}, err
+		return protocol.RouteRef{}, err
 	}
 	generation, err := r.getUint64()
 	if err != nil {
-		return RouteRef{}, err
+		return protocol.RouteRef{}, err
 	}
-	ref := RouteRef{Key: key, Generation: generation}
+	ref := protocol.RouteRef{Key: key, Generation: generation}
 	if err := validateRouteRef(ref); err != nil {
-		return RouteRef{}, err
+		return protocol.RouteRef{}, err
 	}
 	return ref, nil
 }
-func validateRecentRouteEntry(entry RecentRouteEntry) error {
+func validateRecentRouteEntry(entry protocol.RecentRouteEntry) error {
 	if entry.Key == 0 || entry.Generation == 0 {
-		return fmt.Errorf("%w: route entry identity is zero", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: route entry identity is zero", protocol.ErrInvalidRouteWire)
 	}
 	if err := entry.Target.Validate(); err != nil {
-		return fmt.Errorf("%w: invalid route lifecycle target: %v", ErrInvalidRouteWire, err)
+		return fmt.Errorf("%w: invalid route lifecycle target: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	if entry.Name != entry.Target.SessionName {
-		return fmt.Errorf("%w: route name does not match lifecycle target", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: route name does not match lifecycle target", protocol.ErrInvalidRouteWire)
 	}
 	if err := validateRouteString(entry.Name, "route name", false); err != nil {
-		return fmt.Errorf("%w: %v", ErrInvalidRouteWire, err)
+		return fmt.Errorf("%w: %v", protocol.ErrInvalidRouteWire, err)
 	}
 	if err := validateRouteString(entry.HostLabel, "route host label", true); err != nil {
-		return fmt.Errorf("%w: %v", ErrInvalidRouteWire, err)
+		return fmt.Errorf("%w: %v", protocol.ErrInvalidRouteWire, err)
 	}
-	if !entry.Kind.valid() {
+	if entry.Kind.Validate() != nil {
-		return fmt.Errorf("%w: invalid route kind", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: invalid route kind", protocol.ErrInvalidRouteWire)
 	}
-	if !entry.Reachability.valid() {
+	if entry.Reachability.Validate() != nil {
-		return fmt.Errorf("%w: invalid route reachability", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: invalid route reachability", protocol.ErrInvalidRouteWire)
 	}
 	return nil
 }
-func validateRecentRouteSnapshot(snapshot RecentRouteSnapshot) error {
+func validateRecentRouteSnapshot(snapshot protocol.RecentRouteSnapshot) error {
-	if len(snapshot.Entries) > RouteSnapshotMaxEntries {
+	if len(snapshot.Entries) > protocol.RouteSnapshotMaxEntries {
-		return fmt.Errorf("%w: too many route entries", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: too many route entries", protocol.ErrInvalidRouteWire)
 	}
-	if snapshot.Generation == 0 && (len(snapshot.Entries) != 0 || snapshot.ActiveEntry != (RecentRouteEntry{})) {
+	if snapshot.Generation == 0 && (len(snapshot.Entries) != 0 || snapshot.ActiveEntry != (protocol.RecentRouteEntry{})) {
-		return fmt.Errorf("%w: non-empty snapshot has zero generation", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: non-empty snapshot has zero generation", protocol.ErrInvalidRouteWire)
 	}
 	if err := validateRouteRef(snapshot.Active); err != nil {
 		return err
 	if err := validateRouteRef(snapshot.Home); err != nil {
 		return err
 	}
-	if snapshot.Active.empty() {
+	if snapshot.Active.IsZero() {
-		if snapshot.ActiveEntry != (RecentRouteEntry{}) {
+		if snapshot.ActiveEntry != (protocol.RecentRouteEntry{}) {
-			return fmt.Errorf("%w: active presentation has no active route", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: active presentation has no active route", protocol.ErrInvalidRouteWire)
 		}
 	} else {
 		if err := validateRecentRouteEntry(snapshot.ActiveEntry); err != nil {
 			return err
 		}
-		if snapshot.Active != (RouteRef{Key: snapshot.ActiveEntry.Key, Generation: snapshot.ActiveEntry.Generation}) {
+		if snapshot.Active != (protocol.RouteRef{Key: snapshot.ActiveEntry.Key, Generation: snapshot.ActiveEntry.Generation}) {
-			return fmt.Errorf("%w: active presentation does not match active route", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: active presentation does not match active route", protocol.ErrInvalidRouteWire)
 		}
 	}
-	if !snapshot.Active.empty() && snapshot.Active == snapshot.Previous {
+	if !snapshot.Active.IsZero() && snapshot.Active == snapshot.Previous {
-		return fmt.Errorf("%w: active and previous routes are identical", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: active and previous routes are identical", protocol.ErrInvalidRouteWire)
 	}
-	refs := make(map[RouteRef]struct{}, len(snapshot.Entries))
+	refs := make(map[protocol.RouteRef]struct{}, len(snapshot.Entries))
 	for _, entry := range snapshot.Entries {
-		if snapshot.Active == (RouteRef{Key: entry.Key, Generation: entry.Generation}) {
+		if snapshot.Active == (protocol.RouteRef{Key: entry.Key, Generation: entry.Generation}) {
-			return fmt.Errorf("%w: active route must be metadata-only", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: active route must be metadata-only", protocol.ErrInvalidRouteWire)
 		}
 		if err := validateRecentRouteEntry(entry); err != nil {
 			return err
 		}
-		ref := RouteRef{Key: entry.Key, Generation: entry.Generation}
+		ref := protocol.RouteRef{Key: entry.Key, Generation: entry.Generation}
 		if _, exists := refs[ref]; exists {
-			return fmt.Errorf("%w: duplicate route entry", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: duplicate route entry", protocol.ErrInvalidRouteWire)
 		}
 		refs[ref] = struct{}{}
 	}
 	for _, item := range []struct {
 		name string
-		ref  RouteRef
+		ref  protocol.RouteRef
 	}{
 		{name: "previous", ref: snapshot.Previous},
 		{name: "home", ref: snapshot.Home},
 	} {
-		if item.ref.empty() || item.ref == snapshot.Active {
+		if item.ref.IsZero() || item.ref == snapshot.Active {
 			// Active is metadata-only and intentionally excluded from the
 			// recent display entries. Home may point at active as well.
 			continue
 		}
 		if _, exists := refs[item.ref]; !exists {
-			return fmt.Errorf("%w: %s route reference is absent from snapshot", ErrInvalidRouteWire, item.name)
+			return fmt.Errorf("%w: %s route reference is absent from snapshot", protocol.ErrInvalidRouteWire, item.name)
 		}
 	}
 	return nil
 }
-func marshalRecentRouteEntry(w *payloadWriter, entry RecentRouteEntry) {
+func marshalRecentRouteEntry(w *payloadWriter, entry protocol.RecentRouteEntry) {
 	w.putUint64(entry.Key)
 	w.putUint64(entry.Generation)
 	marshalExactSessionTarget(w, entry.Target)
 	w.putUint8(uint8(entry.Reachability))
 }
-func unmarshalRecentRouteEntry(r *payloadReader) (RecentRouteEntry, error) {
+func unmarshalRecentRouteEntry(r *payloadReader) (protocol.RecentRouteEntry, error) {
-	var entry RecentRouteEntry
+	var entry protocol.RecentRouteEntry
 	var err error
 	if entry.Key, err = r.getUint64(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	if entry.Generation, err = r.getUint64(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	if entry.Target, err = unmarshalExactSessionTarget(r); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	if entry.Name, err = r.getString(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	if entry.HostLabel, err = r.getString(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	kind, err := r.getUint8()
 	if err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
-	entry.Kind = RouteKind(kind)
+	entry.Kind = protocol.RouteKind(kind)
 	if entry.Ephemeral, err = r.getBool(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	if entry.Attention, err = r.getBool(); err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
 	reachability, err := r.getUint8()
 	if err != nil {
-		return RecentRouteEntry{}, err
+		return protocol.RecentRouteEntry{}, err
 	}
-	entry.Reachability = RouteReachability(reachability)
+	entry.Reachability = protocol.RouteReachability(reachability)
 	return entry, nil
 }
 // MarshalRecentRouteSnapshot encodes a complete bounded client route view.
-func MarshalRecentRouteSnapshot(snapshot RecentRouteSnapshot) ([]byte, error) {
+func MarshalRecentRouteSnapshot(snapshot protocol.RecentRouteSnapshot) ([]byte, error) {
 	if err := validateRecentRouteSnapshot(snapshot); err != nil {
 		return nil, err
 	}
 	w := payloadWriter{}
 	w.putUint64(snapshot.Generation)
 	marshalRouteRef(&w, snapshot.Active)
-	if !snapshot.Active.empty() {
+	if !snapshot.Active.IsZero() {
 		marshalRecentRouteEntry(&w, snapshot.ActiveEntry)
 	}
 	marshalRouteRef(&w, snapshot.Previous)
 	// make this unreachable; it protects the wire contract if those bounds
 	// change independently in a future protocol revision.
 	if len(w.b) > MaxFrameLen-1 {
-		return nil, fmt.Errorf("%w: route snapshot is too large", ErrInvalidRouteWire)
+		return nil, fmt.Errorf("%w: route snapshot is too large", protocol.ErrInvalidRouteWire)
 	}
 	return w.b, nil
 }
-func validateRouteAttentionSubscription(subscription RouteAttentionSubscription) error {
+func validateRouteAttentionSubscription(subscription protocol.RouteAttentionSubscription) error {
-	if len(subscription.Targets) > RouteSnapshotMaxEntries {
+	if len(subscription.Targets) > protocol.RouteSnapshotMaxEntries {
-		return fmt.Errorf("%w: too many attention targets", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: too many attention targets", protocol.ErrInvalidRouteWire)
 	}
-	refs := make(map[RouteRef]struct{}, len(subscription.Targets))
+	refs := make(map[protocol.RouteRef]struct{}, len(subscription.Targets))
 	for _, target := range subscription.Targets {
-		if err := validateRouteRef(target.Ref); err != nil || target.Ref.empty() {
+		if err := validateRouteRef(target.Ref); err != nil || target.Ref.IsZero() {
-			return fmt.Errorf("%w: invalid attention route reference", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: invalid attention route reference", protocol.ErrInvalidRouteWire)
 		}
 		if err := target.Target.Validate(); err != nil {
-			return fmt.Errorf("%w: invalid attention target: %v", ErrInvalidRouteWire, err)
+			return fmt.Errorf("%w: invalid attention target: %v", protocol.ErrInvalidRouteWire, err)
 		}
 		if _, exists := refs[target.Ref]; exists {
-			return fmt.Errorf("%w: duplicate attention route reference", ErrInvalidRouteWire)
+			return fmt.Errorf("%w: duplicate attention route reference", protocol.ErrInvalidRouteWire)
 		}
 		refs[target.Ref] = struct{}{}
 	}
 // MarshalRouteAttentionSubscription encodes the bounded client mapping used
 // by the connected daemon to resolve live route-attention indicators.
-func MarshalRouteAttentionSubscription(subscription RouteAttentionSubscription) ([]byte, error) {
+func MarshalRouteAttentionSubscription(subscription protocol.RouteAttentionSubscription) ([]byte, error) {
 	if err := validateRouteAttentionSubscription(subscription); err != nil {
 		return nil, err
 	}
 // UnmarshalRouteAttentionSubscription decodes one strict bounded attention
 // mapping and rejects truncated, malformed, and trailing payloads.
-func UnmarshalRouteAttentionSubscription(b []byte) (RouteAttentionSubscription, error) {
+func UnmarshalRouteAttentionSubscription(b []byte) (protocol.RouteAttentionSubscription, error) {
 	r := payloadReader{b: b}
 	count, err := r.getUint8()
 	if err != nil {
-		return RouteAttentionSubscription{}, err
+		return protocol.RouteAttentionSubscription{}, err
 	}
-	if int(count) > RouteSnapshotMaxEntries {
+	if int(count) > protocol.RouteSnapshotMaxEntries {
-		return RouteAttentionSubscription{}, fmt.Errorf("%w: too many attention targets", ErrInvalidRouteWire)
+		return protocol.RouteAttentionSubscription{}, fmt.Errorf("%w: too many attention targets", protocol.ErrInvalidRouteWire)
 	}
-	subscription := RouteAttentionSubscription{Targets: make([]RouteAttentionTarget, 0, int(count))}
+	subscription := protocol.RouteAttentionSubscription{Targets: make([]protocol.RouteAttentionTarget, 0, int(count))}
 	for range int(count) {
 		ref, err := unmarshalRouteRef(&r)
 		if err != nil {
-			return RouteAttentionSubscription{}, err
+			return protocol.RouteAttentionSubscription{}, err
 		}
 		target, err := unmarshalExactSessionTarget(&r)
 		if err != nil {
-			return RouteAttentionSubscription{}, err
+			return protocol.RouteAttentionSubscription{}, err
 		}
-		subscription.Targets = append(subscription.Targets, RouteAttentionTarget{Ref: ref, Target: target})
+		subscription.Targets = append(subscription.Targets, protocol.RouteAttentionTarget{Ref: ref, Target: target})
 	}
 	if err := r.done(); err != nil {
-		return RouteAttentionSubscription{}, err
+		return protocol.RouteAttentionSubscription{}, err
 	}
 	if err := validateRouteAttentionSubscription(subscription); err != nil {
-		return RouteAttentionSubscription{}, err
+		return protocol.RouteAttentionSubscription{}, err
 	}
 	return subscription, nil
 }
 // UnmarshalRecentRouteSnapshot decodes and strictly validates one complete
 // immutable snapshot, including every referenced active/previous/home entry.
-func UnmarshalRecentRouteSnapshot(b []byte) (RecentRouteSnapshot, error) {
+func UnmarshalRecentRouteSnapshot(b []byte) (protocol.RecentRouteSnapshot, error) {
 	if len(b) > MaxFrameLen-1 {
-		return RecentRouteSnapshot{}, ErrInvalidRouteWire
+		return protocol.RecentRouteSnapshot{}, protocol.ErrInvalidRouteWire
 	}
 	r := payloadReader{b: b}
-	var snapshot RecentRouteSnapshot
+	var snapshot protocol.RecentRouteSnapshot
 	var err error
 	if snapshot.Generation, err = r.getUint64(); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
 	if snapshot.Active, err = unmarshalRouteRef(&r); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
-	if !snapshot.Active.empty() {
+	if !snapshot.Active.IsZero() {
 		if snapshot.ActiveEntry, err = unmarshalRecentRouteEntry(&r); err != nil {
-			return RecentRouteSnapshot{}, err
+			return protocol.RecentRouteSnapshot{}, err
 		}
 	}
 	if snapshot.Previous, err = unmarshalRouteRef(&r); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
 	if snapshot.Home, err = unmarshalRouteRef(&r); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
 	count, err := r.getUint8()
 	if err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
-	if int(count) > RouteSnapshotMaxEntries {
+	if int(count) > protocol.RouteSnapshotMaxEntries {
-		return RecentRouteSnapshot{}, fmt.Errorf("%w: too many route entries", ErrInvalidRouteWire)
+		return protocol.RecentRouteSnapshot{}, fmt.Errorf("%w: too many route entries", protocol.ErrInvalidRouteWire)
 	}
 	if count != 0 {
-		snapshot.Entries = make([]RecentRouteEntry, 0, int(count))
+		snapshot.Entries = make([]protocol.RecentRouteEntry, 0, int(count))
 	}
 	for range int(count) {
 		entry, err := unmarshalRecentRouteEntry(&r)
 		if err != nil {
-			return RecentRouteSnapshot{}, err
+			return protocol.RecentRouteSnapshot{}, err
 		}
 		snapshot.Entries = append(snapshot.Entries, entry)
 	}
 	if err := r.done(); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
 	if err := validateRecentRouteSnapshot(snapshot); err != nil {
-		return RecentRouteSnapshot{}, err
+		return protocol.RecentRouteSnapshot{}, err
 	}
 	return snapshot, nil
 }
-func validateRouteNavigationAction(action RouteNavigationAction) error {
+func validateRouteNavigationAction(action protocol.RouteNavigationAction) error {
 	if action.SnapshotGeneration == 0 || action.Key == 0 || action.Generation == 0 {
-		return fmt.Errorf("%w: navigation action identity is zero", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: navigation action identity is zero", protocol.ErrInvalidRouteWire)
 	}
 	return nil
 }
-func MarshalRouteNavigationAction(action RouteNavigationAction) ([]byte, error) {
+func MarshalRouteNavigationAction(action protocol.RouteNavigationAction) ([]byte, error) {
 	if err := validateRouteNavigationAction(action); err != nil {
 		return nil, err
 	}
 	return w.b, nil
 }
-func UnmarshalRouteNavigationAction(b []byte) (RouteNavigationAction, error) {
+func UnmarshalRouteNavigationAction(b []byte) (protocol.RouteNavigationAction, error) {
 	r := payloadReader{b: b}
-	var action RouteNavigationAction
+	var action protocol.RouteNavigationAction
 	var err error
 	if action.SnapshotGeneration, err = r.getUint64(); err != nil {
-		return RouteNavigationAction{}, err
+		return protocol.RouteNavigationAction{}, err
 	}
 	if action.Key, err = r.getUint64(); err != nil {
-		return RouteNavigationAction{}, err
+		return protocol.RouteNavigationAction{}, err
 	}
 	if action.Generation, err = r.getUint64(); err != nil {
-		return RouteNavigationAction{}, err
+		return protocol.RouteNavigationAction{}, err
 	}
 	if err := r.done(); err != nil {
-		return RouteNavigationAction{}, err
+		return protocol.RouteNavigationAction{}, err
 	}
 	if err := validateRouteNavigationAction(action); err != nil {
-		return RouteNavigationAction{}, err
+		return protocol.RouteNavigationAction{}, err
 	}
 	return action, nil
 }
-func validateRouteNavigationFailure(failure RouteNavigationFailure) error {
+func validateRouteNavigationFailure(failure protocol.RouteNavigationFailure) error {
 	if failure.Key == 0 || failure.Generation == 0 {
-		return fmt.Errorf("%w: failure identity is zero", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: failure identity is zero", protocol.ErrInvalidRouteWire)
 	}
-	if !failure.Code.valid() {
+	if failure.Code.Validate() != nil {
-		return fmt.Errorf("%w: invalid failure code", ErrInvalidRouteWire)
+		return fmt.Errorf("%w: invalid failure code", protocol.ErrInvalidRouteWire)
 	}
 	return nil
 }
-func MarshalRouteNavigationFailure(failure RouteNavigationFailure) ([]byte, error) {
+func MarshalRouteNavigationFailure(failure protocol.RouteNavigationFailure) ([]byte, error) {
 	if err := validateRouteNavigationFailure(failure); err != nil {
 		return nil, err
 	}
 	return w.b, nil
 }
-func UnmarshalRouteNavigationFailure(b []byte) (RouteNavigationFailure, error) {
+func UnmarshalRouteNavigationFailure(b []byte) (protocol.RouteNavigationFailure, error) {
 	r := payloadReader{b: b}
-	var failure RouteNavigationFailure
+	var failure protocol.RouteNavigationFailure
 	var err error
 	if failure.Key, err = r.getUint64(); err != nil {
-		return RouteNavigationFailure{}, err
+		return protocol.RouteNavigationFailure{}, err
 	}
 	if failure.Generation, err = r.getUint64(); err != nil {
-		return RouteNavigationFailure{}, err
+		return protocol.RouteNavigationFailure{}, err
 	}
 	code, err := r.getUint8()
 	if err != nil {
-		return RouteNavigationFailure{}, err
+		return protocol.RouteNavigationFailure{}, err
 	}
-	failure.Code = RouteFailureCode(code)
+	failure.Code = protocol.RouteFailureCode(code)
 	if err := r.done(); err != nil {
-		return RouteNavigationFailure{}, err
+		return protocol.RouteNavigationFailure{}, err
 	}
 	if err := validateRouteNavigationFailure(failure); err != nil {
-		return RouteNavigationFailure{}, err
+		return protocol.RouteNavigationFailure{}, err
 	}
 	return failure, nil
 }

M internal/ports/same_peer_switch_test.go +17 -8

 	"testing"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
-func samePeerSwitchTarget() ExactSessionTarget {
+func samePeerSwitchTarget() protocol.ExactSessionTarget {
 	var lifecycle domain.SessionLifecycleID
 	lifecycle[0] = 9
-	return ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
+	return protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
 }
 func TestSamePeerSwitchWireStrict(t *testing.T) {
-	request := SamePeerSwitchRequest{RequestID: 7, Target: samePeerSwitchTarget(), PreferredTabID: "tab-2"}
+	request := protocol.SamePeerSwitchRequest{RequestID: 7, Target: samePeerSwitchTarget(), PreferredTabID: "tab-2"}
 	requestWire := append([]byte{0, 0, 0, 0, 0, 0, 0, 7, 9}, make([]byte, 15)...)
 	requestWire = append(requestWire, 0, 4, 'w', 'o', 'r', 'k', 0, 5, 't', 'a', 'b', '-', '2')
-	failure := SamePeerSwitchFailure{RequestID: 7, Code: SamePeerSwitchStaleTarget}
+	failure := protocol.SamePeerSwitchFailure{RequestID: 7, Code: protocol.SamePeerSwitchStaleTarget}
 	for _, tt := range []struct {
 		name    string
 			decode:  func(payload []byte) (any, error) { return UnmarshalSamePeerSwitchRequest(payload) },
 			assert: func(t *testing.T, decoded any) {
 				t.Helper()
-				if got := decoded.(SamePeerSwitchRequest); got != request {
+				got, ok := decoded.(protocol.SamePeerSwitchRequest)
+				if !ok {
+					t.Fatalf("decoded type = %T, want protocol.SamePeerSwitchRequest", decoded)
+				}
+				if got != request {
 					t.Fatalf("request = %+v, want %+v", got, request)
 				}
 			},
 			decode:  func(payload []byte) (any, error) { return UnmarshalSamePeerSwitchFailure(payload) },
 			assert: func(t *testing.T, decoded any) {
 				t.Helper()
-				if got := decoded.(SamePeerSwitchFailure); got != failure {
+				got, ok := decoded.(protocol.SamePeerSwitchFailure)
+				if !ok {
+					t.Fatalf("decoded type = %T, want protocol.SamePeerSwitchFailure", decoded)
+				}
+				if got != failure {
 					t.Fatalf("failure = %+v, want %+v", got, failure)
 				}
 			},
 }
 func TestSamePeerSwitchWireRejectsInvalidValues(t *testing.T) {
-	valid := SamePeerSwitchRequest{RequestID: 1, Target: samePeerSwitchTarget()}
+	valid := protocol.SamePeerSwitchRequest{RequestID: 1, Target: samePeerSwitchTarget()}
-	for _, request := range []SamePeerSwitchRequest{
+	for _, request := range []protocol.SamePeerSwitchRequest{
 		{},
 		{RequestID: 1},
 		{RequestID: 1, Target: samePeerSwitchTarget(), PreferredTabID: "bad tab"},

A internal/ports/session_control.go +323 -0

@@ -0,0 +1,323 @@
	1	+	package ports
	2	+
	3	+	import (
	4	+	"errors"
	5	+	"fmt"
	6	+	"math"
	7	+	"time"
	8	+
	9	+	"github.com/bnema/vev/internal/domain"
	10	+	"github.com/bnema/vev/internal/protocol"
	11	+	)
	12	+
	13	+	// HandshakeTimeout bounds every transport handshake from connect through the
	14	+	// first committed publication.
	15	+	const HandshakeTimeout = 15 * time.Second
	16	+
	17	+	// ProtocolVersion is the current vev IPC wire protocol version.
	18	+	const ProtocolVersion uint16 = 37
	19	+
	20	+	// ConnectionCapabilities describes transport behavior relevant to session
	21	+	// flow without naming a concrete carriage.
	22	+	type ConnectionCapabilities struct {
	23	+	OutputDataLimit int
	24	+	PreferredOutputWindow uint8
	25	+	AsyncSend bool
	26	+	OwnedSynchronousSend bool
	27	+	LinkState bool
	28	+	}
	29	+
	30	+	var (
	31	+	ErrInvalidHello = errors.New("ports: invalid hello")
	32	+	ErrInvalidAttachTarget = errors.New("ports: invalid attach target")
	33	+	ErrInvalidEnvironmentPolicy = errors.New("ports: invalid environment policy")
	34	+	ErrInvalidClientNotice = errors.New("ports: invalid client notice")
	35	+	ErrInvalidDetached = errors.New("ports: invalid detached reason")
	36	+	)
	37	+
	38	+	const (
	39	+	IntentEphemeral uint8 = 0
	40	+	IntentNew uint8 = 1
	41	+	IntentAttach uint8 = 2
	42	+	IntentResume uint8 = 3
	43	+	)
	44	+
	45	+	type EnvironmentPolicy uint8
	46	+
	47	+	const (
	48	+	EnvironmentPolicyClientOwned EnvironmentPolicy = iota
	49	+	EnvironmentPolicyDaemonOwned
	50	+	)
	51	+
	52	+	const (
	53	+	CapabilityResume uint32 = 1 << 0
	54	+	CapabilityUDP uint32 = 1 << 1
	55	+	CapabilityPredict uint32 = 1 << 2
	56	+	)
	57	+
	58	+	const (
	59	+	ErrVersionMismatch uint16 = 1
	60	+	ErrNoSuchSession uint16 = 2
	61	+	ErrNameTaken uint16 = 3
	62	+	ErrServerShutdown uint16 = 4
	63	+	ErrInvalidSessionName uint16 = 5
	64	+	ErrUnknownCommand uint16 = 6
	65	+	ErrNotScriptable uint16 = 7
	66	+	ErrInvalidCommandArgs uint16 = 8
	67	+	ErrNoSuchTarget uint16 = 9
	68	+	ErrAmbiguousTarget uint16 = 10
	69	+	ErrInternal uint16 = 255
	70	+	)
	71	+
	72	+	const (
	73	+	ReasonDetach uint8 = 0
	74	+	ReasonSessionKilled uint8 = 1
	75	+	ReasonServerShutdown uint8 = 2
	76	+	ReasonReplaced uint8 = 3
	77	+	)
	78	+
	79	+	// Hello is sent by the client immediately after connecting.
	80	+	type Hello struct {
	81	+	Version uint16
	82	+	Intent uint8
	83	+	ClientID [16]byte
	84	+	ResumeToken uint64
	85	+	Name string
	86	+	Size domain.Size
	87	+	PixelWidth int
	88	+	PixelHeight int
	89	+	TermEnv string
	90	+	Cwd string
	91	+	TrueColor bool
	92	+	// KittyDirectGraphics is an explicit declaration that the client has
	93	+	// probed its direct outer terminal and it accepts Kitty graphics output.
	94	+	KittyDirectGraphics bool
	95	+	MaxOutputInFlight uint8
	96	+	Env []string
	97	+	RemoteTarget *domain.RemoteSessionTarget
	98	+	ExactTarget *protocol.ExactSessionTarget
	99	+	PreferredTabID domain.TabStableID
	100	+	EnvironmentPolicy EnvironmentPolicy
	101	+	NavigationCapabilities protocol.NavigationCapabilities
	102	+	StartupOverlay protocol.StartupOverlay
	103	+	Remote bool
	104	+	}
	105	+
	106	+	func (h Hello) Geometry() domain.Geometry {
	107	+	return domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}.NormalizePixels()
	108	+	}
	109	+
	110	+	type Input struct {
	111	+	InputSeq uint64
	112	+	Data []byte
	113	+	}
	114	+
	115	+	type ClientNotice struct{ Action uint8 }
	116	+
	117	+	const (
	118	+	ClientNoticeClipboardFallback uint8 = 1
	119	+	ClientNoticeClipboardTooLarge uint8 = 2
	120	+	ClientNoticeLinkDegraded uint8 = 3
	121	+	ClientNoticeLinkConnected uint8 = 4
	122	+	)
	123	+
	124	+	type Detach struct{}
	125	+	type Ping struct{}
	126	+	type Pong struct{}
	127	+
	128	+	type Welcome struct {
	129	+	SessionID string
	130	+	SessionName string
	131	+	Ephemeral bool
	132	+	ResumeToken uint64
	133	+	Capabilities uint32
	134	+	CommittedIdentity *protocol.CommittedRouteIdentity
	135	+	}
	136	+
	137	+	type ErrorMsg struct {
	138	+	Code uint16
	139	+	Text string
	140	+	}
	141	+
	142	+	type AttachTarget struct {
	143	+	Endpoint string
	144	+	Session string
	145	+	Intent uint8
	146	+	RemoteTarget *domain.RemoteSessionTarget
	147	+	ExactTarget *protocol.ExactSessionTarget
	148	+	EnvironmentPolicy EnvironmentPolicy
	149	+	SamePeer bool
	150	+	}
	151	+
	152	+	type Detached struct{ Reason uint8 }
	153	+	type List struct{}
	154	+
	155	+	type Kill struct {
	156	+	Name string
	157	+	All bool
	158	+	}
	159	+
	160	+	type SessionState uint8
	161	+
	162	+	const (
	163	+	SessionUp SessionState = iota
	164	+	SessionDown
	165	+	SessionBroken
	166	+	)
	167	+
	168	+	type SessionInfo struct {
	169	+	SessionID string
	170	+	Name string
	171	+	State SessionState
	172	+	Ephemeral bool
	173	+	Tabs uint16
	174	+	Attached bool
	175	+	}
	176	+
	177	+	type Sessions struct{ Sessions []SessionInfo }
	178	+	type OutputResetRequest struct{}
	179	+
	180	+	func validEnvironmentPolicy(policy EnvironmentPolicy) bool {
	181	+	return policy == EnvironmentPolicyClientOwned \|\| policy == EnvironmentPolicyDaemonOwned
	182	+	}
	183	+
	184	+	func validClientNoticeAction(action uint8) bool {
	185	+	switch action {
	186	+	case ClientNoticeClipboardFallback, ClientNoticeClipboardTooLarge, ClientNoticeLinkDegraded, ClientNoticeLinkConnected:
	187	+	return true
	188	+	default:
	189	+	return false
	190	+	}
	191	+	}
	192	+
	193	+	func validDetachedReason(reason uint8) bool {
	194	+	switch reason {
	195	+	case ReasonDetach, ReasonSessionKilled, ReasonServerShutdown, ReasonReplaced:
	196	+	return true
	197	+	default:
	198	+	return false
	199	+	}
	200	+	}
	201	+
	202	+	func ValidateEnvironmentPolicy(policy EnvironmentPolicy) error {
	203	+	if !validEnvironmentPolicy(policy) {
	204	+	return ErrInvalidEnvironmentPolicy
	205	+	}
	206	+	return nil
	207	+	}
	208	+
	209	+	func ValidateClientNotice(m ClientNotice) error {
	210	+	if !validClientNoticeAction(m.Action) {
	211	+	return ErrInvalidClientNotice
	212	+	}
	213	+	return nil
	214	+	}
	215	+
	216	+	func ValidateDetached(m Detached) error {
	217	+	if !validDetachedReason(m.Reason) {
	218	+	return ErrInvalidDetached
	219	+	}
	220	+	return nil
	221	+	}
	222	+
	223	+	func validateHelloNavigation(h Hello) error {
	224	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
	225	+	if h.NavigationCapabilities != 0 \|\| h.StartupOverlay != protocol.StartupOverlayNone {
	226	+	return protocol.ErrInvalidNavigation
	227	+	}
	228	+	return nil
	229	+	}
	230	+	return protocol.ValidateNavigation(h.NavigationCapabilities, h.StartupOverlay, h.RemoteTarget != nil \|\| h.EnvironmentPolicy == EnvironmentPolicyDaemonOwned)
	231	+	}
	232	+
	233	+	func ValidateHello(h Hello) error {
	234	+	if h.Intent != IntentEphemeral && h.Intent != IntentNew && h.Intent != IntentAttach && h.Intent != IntentResume {
	235	+	return ErrInvalidHello
	236	+	}
	237	+	if err := protocol.ValidateGeometry(domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}); err != nil {
	238	+	return fmt.Errorf("%w: geometry", ErrInvalidHello)
	239	+	}
	240	+	if !validEnvironmentPolicy(h.EnvironmentPolicy) {
	241	+	return ErrInvalidHello
	242	+	}
	243	+	if err := validateHelloNavigation(h); err != nil {
	244	+	return fmt.Errorf("%w: navigation: %w", ErrInvalidHello, err)
	245	+	}
	246	+	if len(h.Name) > math.MaxUint16 \|\| len(h.TermEnv) > math.MaxUint16 \|\| len(h.Cwd) > math.MaxUint16 \|\| len(h.Env) > math.MaxUint32 {
	247	+	return ErrInvalidHello
	248	+	}
	249	+	for _, entry := range h.Env {
	250	+	if uint64(len(entry)) > math.MaxUint32 {
	251	+	return ErrInvalidHello
	252	+	}
	253	+	}
	254	+	if h.PreferredTabID != "" {
	255	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
	256	+	return ErrInvalidHello
	257	+	}
	258	+	if err := domain.ValidateTabStableID(h.PreferredTabID); err != nil {
	259	+	return fmt.Errorf("%w: preferred tab: %v", ErrInvalidHello, err)
	260	+	}
	261	+	}
	262	+	if h.ExactTarget != nil {
	263	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
	264	+	return ErrInvalidHello
	265	+	}
	266	+	if err := h.ExactTarget.Validate(); err != nil {
	267	+	return fmt.Errorf("%w: exact target: %v", ErrInvalidHello, err)
	268	+	}
	269	+	if h.Name != h.ExactTarget.SessionName {
	270	+	return ErrInvalidHello
	271	+	}
	272	+	if h.RemoteTarget != nil && (h.RemoteTarget.LifecycleID != h.ExactTarget.LifecycleID \|\| h.RemoteTarget.SessionName != h.ExactTarget.SessionName) {
	273	+	return ErrInvalidHello
	274	+	}
	275	+	}
	276	+	if h.RemoteTarget == nil {
	277	+	return nil
	278	+	}
	279	+	if h.EnvironmentPolicy != EnvironmentPolicyDaemonOwned \|\| (h.Intent != IntentAttach && h.Intent != IntentResume) {
	280	+	return ErrInvalidHello
	281	+	}
	282	+	if err := validateWireRemoteTarget(*h.RemoteTarget); err != nil {
	283	+	return fmt.Errorf("%w: remote target: %v", ErrInvalidHello, err)
	284	+	}
	285	+	if h.Name != h.RemoteTarget.SessionName {
	286	+	return ErrInvalidHello
	287	+	}
	288	+	return nil
	289	+	}
	290	+
	291	+	func ValidateAttachTarget(m AttachTarget) error {
	292	+	if m.Session == "" \|\| len(m.Endpoint) > math.MaxUint16 \|\| len(m.Session) > math.MaxUint16 {
	293	+	return ErrInvalidAttachTarget
	294	+	}
	295	+	if err := domain.ValidateSessionName(m.Session); err != nil {
	296	+	return ErrInvalidAttachTarget
	297	+	}
	298	+	if m.Intent != IntentEphemeral && m.Intent != IntentNew && m.Intent != IntentAttach && m.Intent != IntentResume {
	299	+	return ErrInvalidAttachTarget
	300	+	}
	301	+	if m.Intent == IntentResume \|\| !validEnvironmentPolicy(m.EnvironmentPolicy) {
	302	+	return ErrInvalidAttachTarget
	303	+	}
	304	+	if m.ExactTarget != nil && (m.ExactTarget.SessionName != m.Session \|\| m.ExactTarget.Validate() != nil) {
	305	+	return ErrInvalidAttachTarget
	306	+	}
	307	+	if m.SamePeer && (m.Endpoint != "" \|\| m.RemoteTarget != nil \|\| m.ExactTarget == nil) {
	308	+	return ErrInvalidAttachTarget
	309	+	}
	310	+	if m.RemoteTarget == nil {
	311	+	return nil
	312	+	}
	313	+	if m.EnvironmentPolicy != EnvironmentPolicyDaemonOwned \|\| m.Intent != IntentAttach {
	314	+	return ErrInvalidAttachTarget
	315	+	}
	316	+	if err := validateWireRemoteTarget(*m.RemoteTarget); err != nil {
	317	+	return fmt.Errorf("%w: remote target: %v", ErrInvalidAttachTarget, err)
	318	+	}
	319	+	if m.Endpoint != m.RemoteTarget.Endpoint \|\| m.Session != m.RemoteTarget.SessionName {
	320	+	return ErrInvalidAttachTarget
	321	+	}
	322	+	return nil
	323	+	}

M internal/ports/wire.go +125 -601

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 // errShortPayload is returned when a payload ends before a required field
 	return writer
 }}
-// ErrInvalidSize reports a terminal size that cannot be represented by the
-// protocol or would exceed the bounded screen area.
-var ErrInvalidSize = errors.New("ports: invalid terminal size")
-// ErrInvalidHello reports a malformed Hello semantic value.
-var ErrInvalidHello = errors.New("ports: invalid hello")
-// ErrInvalidOutput reports a malformed Output semantic value.
-var ErrInvalidOutput = errors.New("ports: invalid output")
-// ErrInvalidAck reports a malformed Ack semantic value.
-var ErrInvalidAck = errors.New("ports: invalid ack")
-// ErrInvalidAttachTarget reports a malformed attach target.
-var ErrInvalidAttachTarget = errors.New("ports: invalid attach target")
-// ErrInvalidNavigation reports an unknown or impossible navigation value.
-var ErrInvalidNavigation = errors.New("ports: invalid navigation")
-// Intent values carried by Hello, describing what the client wants to do.
-const (
-	IntentEphemeral uint8 = 0
-	IntentNew       uint8 = 1
-	IntentAttach    uint8 = 2
-	IntentResume    uint8 = 3
-)
-// EnvironmentPolicy controls which side owns the environment used for future
-// PTY children. Direct CLI attaches keep the historical client-owned policy;
-// picker handoffs use daemon ownership so a local environment cannot leak into
-// a remote daemon.
-type EnvironmentPolicy uint8
-const (
-	EnvironmentPolicyClientOwned EnvironmentPolicy = iota
-	EnvironmentPolicyDaemonOwned
-)
-func validEnvironmentPolicy(policy EnvironmentPolicy) bool {
-	return policy == EnvironmentPolicyClientOwned || policy == EnvironmentPolicyDaemonOwned
-}
-func validNavigationCapabilities(capabilities NavigationCapabilities) bool {
-	return capabilities&^(NavigationCapabilityHomePicker|NavigationCapabilityBack) == 0
-}
-func validStartupOverlay(overlay StartupOverlay) bool {
-	return overlay == StartupOverlayNone || overlay == StartupOverlaySessionPicker
-}
-// ValidateNavigation validates route capabilities independently of the rest of
-// the Hello payload. homePickerRoute indicates that the route may open its
-// home/session picker (for example, a remote target or daemon-owned route).
-func ValidateNavigation(capabilities NavigationCapabilities, overlay StartupOverlay, homePickerRoute bool) error {
-	if !validNavigationCapabilities(capabilities) || !validStartupOverlay(overlay) {
-		return ErrInvalidNavigation
-	}
-	home := capabilities&NavigationCapabilityHomePicker != 0
-	back := capabilities&NavigationCapabilityBack != 0
-	if (home && !homePickerRoute) || back != (overlay == StartupOverlaySessionPicker) {
-		return ErrInvalidNavigation
-	}
-	if homePickerRoute && back {
-		return ErrInvalidNavigation
-	}
-	return nil
-}
-func validateHelloNavigation(h Hello) error {
-	if h.Intent != IntentAttach && h.Intent != IntentResume {
-		if h.NavigationCapabilities != 0 || h.StartupOverlay != StartupOverlayNone {
-			return ErrInvalidNavigation
-		}
-		return nil
-	}
-	return ValidateNavigation(h.NavigationCapabilities, h.StartupOverlay, h.RemoteTarget != nil || h.EnvironmentPolicy == EnvironmentPolicyDaemonOwned)
-}
-// Capability bits advertised in Welcome.
-const (
-	CapabilityResume  uint32 = 1 << 0
-	CapabilityUDP     uint32 = 1 << 1
-	CapabilityPredict uint32 = 1 << 2
-)
-// ErrorMsg codes.
-const (
-	ErrVersionMismatch    uint16 = 1
-	ErrNoSuchSession      uint16 = 2
-	ErrNameTaken          uint16 = 3
-	ErrServerShutdown     uint16 = 4
-	ErrInvalidSessionName uint16 = 5
-	ErrUnknownCommand     uint16 = 6
-	ErrNotScriptable      uint16 = 7
-	ErrInvalidCommandArgs uint16 = 8
-	ErrNoSuchTarget       uint16 = 9
-	ErrAmbiguousTarget    uint16 = 10
-	ErrInternal           uint16 = 255
-)
-// Detached reasons.
-const (
-	ReasonDetach         uint8 = 0
-	ReasonSessionKilled  uint8 = 1
-	ReasonServerShutdown uint8 = 2
-	ReasonReplaced       uint8 = 3
-)
-// Hello is sent by the client immediately after connecting.
-type Hello struct {
-	Version     uint16
-	Intent      uint8
-	ClientID    [16]byte
-	ResumeToken uint64
-	Name        string
-	Size        domain.Size
-	PixelWidth  int
-	PixelHeight int
-	TermEnv     string
-	Cwd         string
-	TrueColor   bool
-	// KittyDirectGraphics is an explicit declaration that the client has
-	// probed its direct outer terminal and it accepts Kitty graphics output.
-	// Environment values are never sufficient to set this capability.
-	KittyDirectGraphics bool
-	// MaxOutputInFlight is the requested maximum number of unacknowledged
-	// state-bearing output frames.
-	MaxOutputInFlight uint8
-	// Env is the complete exported client environment for future PTY children.
-	// Entries are opaque strings so their ordering and contents are preserved.
-	Env []string
-	// RemoteTarget is present only for a picker-selected remote attach. It is
-	// carried through reconnects and is validated by the owning daemon before
-	// it creates or publishes any session resources.
-	RemoteTarget *domain.RemoteSessionTarget
-	// ExactTarget is an optional lifecycle/name identity selected by the client
-	// ledger. It is transport-neutral and never replaces the daemon's authority
-	// to validate or commit the target.
-	ExactTarget *ExactSessionTarget
-	// PreferredTabID is a client-owned route cursor. The daemon treats it as an
-	// attachment-local hint and falls back when the stable tab no longer exists.
-	PreferredTabID         domain.TabStableID
-	EnvironmentPolicy      EnvironmentPolicy
-	NavigationCapabilities NavigationCapabilities
-	StartupOverlay         StartupOverlay
-	// Remote identifies a direct remote carriage even when no exact picker
-	// target is present. It is daemon-facing so remote rendering backends can
-	// be disabled consistently for both direct and picker attaches.
-	Remote bool
-}
-// Input carries raw bytes typed/pasted by the client, destined for the PTY.
-type Input struct {
-	InputSeq uint64
-	Data     []byte
-}
-// Geometry returns the complete controlling-terminal geometry carried by the
-// handshake. Pixel dimensions are optional as a pair.
-func (h Hello) Geometry() domain.Geometry {
-	return domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}.NormalizePixels()
-}
-// Resize notifies the daemon of a client-side terminal geometry change.
-type Resize struct {
-	Size        domain.Size
-	PixelWidth  int
-	PixelHeight int
-}
-// Geometry returns the complete controlling-terminal geometry carried by the
-// resize message. Pixel dimensions are optional as a pair.
-func (m Resize) Geometry() domain.Geometry {
-	return domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}.NormalizePixels()
-}
-// Theme reports the client's terminal foreground/background colors, ANSI
-// palette entries, and whether the client terminal supports truecolor.
-type Theme struct {
-	HasForeground bool
-	Foreground    renderer.RGB
-	HasBackground bool
-	Background    renderer.RGB
-	TrueColor     bool
-	SchemeKnown   bool
-	Light         bool
-	PaletteKnown  uint16
-	Palette       [16]renderer.RGB
-}
-// ImagePush carries a clipboard image from a remote client, to be written to
-// a temp file and injected into the focused pane's PTY as a path (see
-// docs/superpowers/specs/2026-07-04-clipboard-image-transfer-design.md).
-type ImagePush struct {
-	InputSeq uint64
-	Mime     string
-	Data     []byte
-}
-// ClientNotice reports a fixed client-side event for daemon-rendered user
-// feedback. Action values are deliberately closed so a client cannot inject
-// arbitrary display text into a shared session.
-type ClientNotice struct {
-	Action uint8
-}
-const (
-	ClientNoticeClipboardFallback uint8 = 1
-	ClientNoticeClipboardTooLarge uint8 = 2
-	ClientNoticeLinkDegraded      uint8 = 3
-	ClientNoticeLinkConnected     uint8 = 4
-)
-func validClientNoticeAction(action uint8) bool {
-	switch action {
-	case ClientNoticeClipboardFallback, ClientNoticeClipboardTooLarge, ClientNoticeLinkDegraded, ClientNoticeLinkConnected:
-		return true
-	default:
-		return false
-	}
-}
-func validDetachedReason(reason uint8) bool {
-	switch reason {
-	case ReasonDetach, ReasonSessionKilled, ReasonServerShutdown, ReasonReplaced:
-		return true
-	default:
-		return false
-	}
-}
-// Detach asks the daemon to detach the current client without killing the
-// session.
-type Detach struct{}
-// Ping is a keepalive/liveness probe sent by either side.
-type Ping struct{}
-// Pong answers a Ping.
-type Pong struct{}
-// Ack acknowledges receipt/application of an output state in one output epoch.
-type Ack struct {
-	Epoch uint64
-	State uint64
-}
-// Welcome is the daemon's reply to a successful Hello.
-type Welcome struct {
-	SessionID         string
-	SessionName       string
-	Ephemeral         bool
-	ResumeToken       uint64
-	Capabilities      uint32
-	CommittedIdentity *CommittedRouteIdentity
-}
-// ErrorMsg reports a protocol- or session-level failure to the client.
-type ErrorMsg struct {
-	Code uint16
-	Text string
-}
-// Output carries one ordered output publication for an attachment.
-type Output struct {
-	Epoch        uint64
-	Base         uint64
-	New          uint64
-	Echo         uint64
-	ViewRevision uint64
-	Size         domain.Size
-	Full         bool
-	Data         []byte
-}
-// AttachTarget identifies the endpoint and exact session/tab selected for a
-// new attachment. Endpoint and Session remain the compatibility route fields;
-// RemoteTarget is the authoritative picker identity when non-nil.
-type AttachTarget struct {
-	Endpoint          string
-	Session           string
-	Intent            uint8
-	RemoteTarget      *domain.RemoteSessionTarget
-	ExactTarget       *ExactSessionTarget
-	EnvironmentPolicy EnvironmentPolicy
-	SamePeer          bool
-}
-// Detached tells a client it has been disconnected from its session and why.
-type Detached struct {
-	Reason uint8
-}
-// List asks the daemon to enumerate its live sessions. It carries no
-// fields; the request is fully described by its message type.
-type List struct{}
-// Kill asks the daemon to terminate one named session or all sessions.
-type Kill struct {
-	Name string
-	All  bool
-}
-// SessionState is the client-visible lifecycle state of a session.
-type SessionState uint8
-const (
-	SessionUp SessionState = iota
-	SessionDown
-	SessionBroken
-)
-// SessionInfo describes one session in a Sessions listing.
-type SessionInfo struct {
-	SessionID string
-	Name      string
-	State     SessionState
-	Ephemeral bool
-	Tabs      uint16
-	Attached  bool
-}
-// Sessions is the daemon's reply to a List, enumerating live sessions.
-type Sessions struct {
-	Sessions []SessionInfo
-}
-// OutputResetRequest asks a remote output stream to rebase.
-type OutputResetRequest struct{}
-// SessionTabMeta describes one tab in a remote session's metadata snapshot.
-// ID is stable for the lifetime of its remote tab and ordered only for display.
 // payloadWriter builds a message payload by appending fields in wire order.
 type payloadWriter struct {
 	b []byte
 	if err != nil {
 		return err
 	}
-	if !validEnvironmentPolicy(EnvironmentPolicy(policy)) {
+	if ValidateEnvironmentPolicy(EnvironmentPolicy(policy)) != nil {
 		return errInvalidEnum
 	}
 	return nil
 	if err != nil {
 		return nil, 0, err
 	}
-	if !validEnvironmentPolicy(EnvironmentPolicy(policy)) {
+	if ValidateEnvironmentPolicy(EnvironmentPolicy(policy)) != nil {
 		return nil, 0, errInvalidEnum
 	}
 	return target, EnvironmentPolicy(policy), nil
 // ValidateHello validates Hello semantics without retaining or allocating any
 // payload data.
-func ValidateHello(h Hello) error {
-	if h.Intent != IntentEphemeral && h.Intent != IntentNew && h.Intent != IntentAttach && h.Intent != IntentResume {
-		return ErrInvalidHello
-	}
-	if err := ValidateGeometry(domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}); err != nil {
-		return fmt.Errorf("%w: geometry", ErrInvalidHello)
-	}
-	if !validEnvironmentPolicy(h.EnvironmentPolicy) {
-		return ErrInvalidHello
-	}
-	if err := validateHelloNavigation(h); err != nil {
-		return fmt.Errorf("%w: navigation: %w", ErrInvalidHello, err)
-	}
-	if len(h.Name) > math.MaxUint16 || len(h.TermEnv) > math.MaxUint16 || len(h.Cwd) > math.MaxUint16 || len(h.Env) > math.MaxUint32 {
-		return ErrInvalidHello
-	}
-	for _, entry := range h.Env {
-		if uint64(len(entry)) > math.MaxUint32 {
-			return ErrInvalidHello
-		}
-	}
-	if h.PreferredTabID != "" {
-		if h.Intent != IntentAttach && h.Intent != IntentResume {
-			return ErrInvalidHello
-		}
-		if err := domain.ValidateTabStableID(h.PreferredTabID); err != nil {
-			return fmt.Errorf("%w: preferred tab: %v", ErrInvalidHello, err)
-		}
-	}
-	if h.ExactTarget != nil {
-		if h.Intent != IntentAttach && h.Intent != IntentResume {
-			return ErrInvalidHello
-		}
-		if err := h.ExactTarget.Validate(); err != nil {
-			return fmt.Errorf("%w: exact target: %v", ErrInvalidHello, err)
-		}
-		if h.Name != h.ExactTarget.SessionName {
-			return ErrInvalidHello
-		}
-		if h.RemoteTarget != nil && (h.RemoteTarget.LifecycleID != h.ExactTarget.LifecycleID || h.RemoteTarget.SessionName != h.ExactTarget.SessionName) {
-			return ErrInvalidHello
-		}
-	}
-	if h.RemoteTarget == nil {
-		if h.EnvironmentPolicy != EnvironmentPolicyClientOwned && h.EnvironmentPolicy != EnvironmentPolicyDaemonOwned {
-			return ErrInvalidHello
-		}
-		return nil
-	}
-	if h.EnvironmentPolicy != EnvironmentPolicyDaemonOwned {
-		return ErrInvalidHello
-	}
-	if h.Intent != IntentAttach && h.Intent != IntentResume {
-		return ErrInvalidHello
-	}
-	if err := validateWireRemoteTarget(*h.RemoteTarget); err != nil {
-		return fmt.Errorf("%w: remote target: %v", ErrInvalidHello, err)
-	}
-	if h.Name != h.RemoteTarget.SessionName {
-		return ErrInvalidHello
-	}
-	return nil
-}
 // ValidateOutput validates the final output state before data allocation.
-func ValidateOutput(m Output) error {
-	if m.Epoch == 0 {
-		return ErrInvalidOutput
-	}
-	if m.New == 0 {
-		if m.Base != 0 || m.Full {
-			return ErrInvalidOutput
-		}
-	} else if (m.Base == 0 && !m.Full) || (m.Base != 0 && (m.Full || m.New != m.Base+1)) {
-		return ErrInvalidOutput
-	}
-	if err := ValidateSize(m.Size); err != nil {
-		return fmt.Errorf("%w: size", ErrInvalidOutput)
-	}
-	if uint64(len(m.Data)) > math.MaxUint32 || len(m.Data) > MaxOutputDataLen {
-		return ErrInvalidOutput
-	}
-	return nil
-}
 // ValidateAck validates an epoch-scoped output acknowledgement.
-func ValidateAck(m Ack) error {
-	if m.Epoch == 0 {
-		return ErrInvalidAck
-	}
-	return nil
-}
 // ValidateAttachTarget validates a client-owned route handoff. An empty
 // Endpoint selects another session on the currently connected daemon; a
 // non-empty Endpoint selects a discovered remote daemon.
-func ValidateAttachTarget(m AttachTarget) error {
-	if m.Session == "" || len(m.Endpoint) > math.MaxUint16 || len(m.Session) > math.MaxUint16 {
-		return ErrInvalidAttachTarget
-	}
-	if err := domain.ValidateSessionName(m.Session); err != nil {
-		return ErrInvalidAttachTarget
-	}
-	if m.Intent != IntentEphemeral && m.Intent != IntentNew && m.Intent != IntentAttach && m.Intent != IntentResume {
-		return ErrInvalidAttachTarget
-	}
-	if m.Intent == IntentResume {
-		return ErrInvalidAttachTarget
-	}
-	if !validEnvironmentPolicy(m.EnvironmentPolicy) {
-		return ErrInvalidAttachTarget
-	}
-	if m.ExactTarget != nil && (m.ExactTarget.SessionName != m.Session || m.ExactTarget.Validate() != nil) {
-		return ErrInvalidAttachTarget
-	}
-	if m.SamePeer && (m.Endpoint != "" || m.RemoteTarget != nil || m.ExactTarget == nil) {
-		return ErrInvalidAttachTarget
-	}
-	if m.RemoteTarget == nil {
-		return nil
-	}
-	if m.EnvironmentPolicy != EnvironmentPolicyDaemonOwned {
-		return ErrInvalidAttachTarget
-	}
-	if m.Intent != IntentAttach {
-		return ErrInvalidAttachTarget
-	}
-	if err := validateWireRemoteTarget(*m.RemoteTarget); err != nil {
-		return fmt.Errorf("%w: remote target: %v", ErrInvalidAttachTarget, err)
-	}
-	if m.Endpoint != m.RemoteTarget.Endpoint || m.Session != m.RemoteTarget.SessionName {
-		return ErrInvalidAttachTarget
-	}
-	return nil
-}
 func validateWireRemoteTarget(target domain.RemoteSessionTarget) error {
 	if len(target.Endpoint) > math.MaxUint16 || len(target.DisplayOrigin) > math.MaxUint16 || len(target.SessionName) > math.MaxUint16 || len(target.LiveTabID) > math.MaxUint16 || len(target.StoppedTab.RawName) > math.MaxUint16 {
 	if err != nil {
 		return Hello{}, err
 	}
-	h.NavigationCapabilities = NavigationCapabilities(capabilities)
+	h.NavigationCapabilities = protocol.NavigationCapabilities(capabilities)
 	overlay, err := r.getUint8()
 	if err != nil {
 		return Hello{}, err
 	}
-	h.StartupOverlay = StartupOverlay(overlay)
+	h.StartupOverlay = protocol.StartupOverlay(overlay)
 	if h.Remote, err = r.getBool(); err != nil {
 		return Hello{}, err
 	}
 }
 // MarshalImagePush encodes m into an ImagePush message payload.
-func MarshalImagePush(m ImagePush) []byte {
+func MarshalImagePush(m protocol.ImagePush) []byte {
 	w := payloadWriter{}
 	w.putUint64(m.InputSeq)
 	w.putString(m.Mime)
 // UnmarshalImagePush decodes an ImagePush message payload. After the fixed
 // input sequence and length-prefixed mime string, the rest of the payload is
 // data; there is no length prefix for it.
-func UnmarshalImagePush(b []byte) (ImagePush, error) {
+func UnmarshalImagePush(b []byte) (protocol.ImagePush, error) {
 	r := payloadReader{b: b}
 	seq, err := r.getUint64()
 	if err != nil {
-		return ImagePush{}, err
+		return protocol.ImagePush{}, err
 	}
 	mime, err := r.getString()
 	if err != nil {
-		return ImagePush{}, err
+		return protocol.ImagePush{}, err
 	}
-	return ImagePush{InputSeq: seq, Mime: mime, Data: r.rest()}, nil
+	return protocol.ImagePush{InputSeq: seq, Mime: mime, Data: r.rest()}, nil
 }
 // MarshalClientNotice encodes a fixed one-byte client notice action.
 	if err != nil {
 		return ClientNotice{}, err
 	}
-	if !validClientNoticeAction(action) {
+	if ValidateClientNotice(ClientNotice{Action: action}) != nil {
 		return ClientNotice{}, errors.New("ports: unknown client notice action")
 	}
 	if err := r.done(); err != nil {
 }
 // MarshalResize encodes m into a Resize message payload.
-func MarshalResize(m Resize) ([]byte, error) {
+func MarshalResize(m protocol.Resize) ([]byte, error) {
-	if err := ValidateGeometry(domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}); err != nil {
+	if err := protocol.ValidateGeometry(domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}); err != nil {
 		return nil, err
 	}
 	w := payloadWriter{}
 }
 // MarshalTheme encodes m into a 57-byte fixed-width Theme message payload.
-func MarshalTheme(m Theme) []byte {
+func MarshalTheme(m protocol.Theme) []byte {
 	var flags uint8
 	if m.HasForeground {
 		flags |= 0x01
 }
 // UnmarshalTheme decodes a 57-byte fixed-width Theme message payload.
-func UnmarshalTheme(b []byte) (Theme, error) {
+func UnmarshalTheme(b []byte) (protocol.Theme, error) {
 	r := payloadReader{b: b}
 	flags, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	if flags&^uint8(0x1f) != 0 {
-		return Theme{}, errInvalidEnum
+		return protocol.Theme{}, errInvalidEnum
 	}
 	fgR, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	fgG, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	fgB, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	bgR, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	bgG, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	bgB, err := r.getUint8()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	paletteKnown, err := r.getUint16()
 	if err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
-	m := Theme{
+	m := protocol.Theme{
 		HasForeground: flags&0x01 != 0,
 		Foreground:    renderer.RGB{R: fgR, G: fgG, B: fgB},
 		HasBackground: flags&0x02 != 0,
 	}
 	for i := range m.Palette {
 		if m.Palette[i].R, err = r.getUint8(); err != nil {
-			return Theme{}, err
+			return protocol.Theme{}, err
 		}
 		if m.Palette[i].G, err = r.getUint8(); err != nil {
-			return Theme{}, err
+			return protocol.Theme{}, err
 		}
 		if m.Palette[i].B, err = r.getUint8(); err != nil {
-			return Theme{}, err
+			return protocol.Theme{}, err
 		}
 	}
 	if err := r.done(); err != nil {
-		return Theme{}, err
+		return protocol.Theme{}, err
 	}
 	return m, nil
 }
 // UnmarshalResize decodes a Resize message payload.
-func UnmarshalResize(b []byte) (Resize, error) {
+func UnmarshalResize(b []byte) (protocol.Resize, error) {
 	r := payloadReader{b: b}
 	cols, err := r.getUint16()
 	if err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
 	rows, err := r.getUint16()
 	if err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
 	pixelWidth, err := r.getUint16()
 	if err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
 	pixelHeight, err := r.getUint16()
 	if err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
 	if err := r.done(); err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
-	m := Resize{
+	m := protocol.Resize{
 		Size:        domain.Size{Cols: int(cols), Rows: int(rows)},
 		PixelWidth:  int(pixelWidth),
 		PixelHeight: int(pixelHeight),
 	}
-	if err := ValidateGeometry(domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}); err != nil {
+	if err := protocol.ValidateGeometry(domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}); err != nil {
-		return Resize{}, err
+		return protocol.Resize{}, err
 	}
 	return m, nil
 }
 }
 // MarshalAck encodes m into an epoch/state Ack payload.
-func MarshalAck(m Ack) ([]byte, error) {
+func MarshalAck(m protocol.Ack) ([]byte, error) {
-	if err := ValidateAck(m); err != nil {
+	if err := protocol.ValidateAck(m); err != nil {
 		return nil, err
 	}
 	w := payloadWriter{}
 }
 // UnmarshalAck decodes an epoch/state Ack payload.
-func UnmarshalAck(b []byte) (Ack, error) {
+func UnmarshalAck(b []byte) (protocol.Ack, error) {
 	r := payloadReader{b: b}
-	var m Ack
+	var m protocol.Ack
 	var err error
 	if m.Epoch, err = r.getUint64(); err != nil {
-		return Ack{}, err
+		return protocol.Ack{}, err
 	}
 	if m.State, err = r.getUint64(); err != nil {
-		return Ack{}, err
+		return protocol.Ack{}, err
 	}
 	if err := r.done(); err != nil {
-		return Ack{}, err
+		return protocol.Ack{}, err
 	}
-	if err := ValidateAck(m); err != nil {
+	if err := protocol.ValidateAck(m); err != nil {
-		return Ack{}, err
+		return protocol.Ack{}, err
 	}
 	return m, nil
 }
 		return Welcome{}, err
 	}
 	if m.CommittedIdentity != nil && (m.CommittedIdentity.Target.SessionName != m.SessionName || m.CommittedIdentity.Ephemeral != m.Ephemeral) {
-		return Welcome{}, fmt.Errorf("%w: committed identity does not match welcome", ErrInvalidRouteWire)
+		return Welcome{}, fmt.Errorf("%w: committed identity does not match welcome", protocol.ErrInvalidRouteWire)
 	}
 	if err := r.done(); err != nil {
 		return Welcome{}, err
 // MarshalOutput encodes m into the epoch/base/new/echo/viewRevision/
 // size/full/compression/decoded-length/data message layout. Compression is
 // limited to large, full snapshots and is retained only when it saves bytes.
-func MarshalOutput(m Output) ([]byte, error) {
+func MarshalOutput(m protocol.Output) ([]byte, error) {
-	if err := ValidateOutput(m); err != nil {
+	if err := protocol.ValidateOutput(m); err != nil {
 		return nil, err
 	}
 	kind, data, err := compressOutputData(m)
 	return w.b, nil
 }
-func compressOutputData(m Output) (byte, []byte, error) {
+func compressOutputData(m protocol.Output) (byte, []byte, error) {
 	if !m.Full || len(m.Data) < outputCompressionThreshold {
 		return outputCompressionNone, m.Data, nil
 	}
 // UnmarshalOutput strictly decodes one final Output payload. Header semantics
 // are validated before its bounded decoded data allocation.
-func UnmarshalOutput(b []byte) (Output, error) {
+func UnmarshalOutput(b []byte) (protocol.Output, error) {
 	if len(b) > MaxFrameLen-1 {
-		return Output{}, ErrInvalidOutput
+		return protocol.Output{}, protocol.ErrInvalidOutput
 	}
 	if len(b) < outputPayloadOverhead {
-		return Output{}, errShortPayload
+		return protocol.Output{}, errShortPayload
 	}
 	r := payloadReader{b: b}
-	var m Output
+	var m protocol.Output
 	var err error
 	if m.Epoch, err = r.getUint64(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	if m.Base, err = r.getUint64(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	if m.New, err = r.getUint64(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	if m.Echo, err = r.getUint64(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	if m.ViewRevision, err = r.getUint64(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	cols, err := r.getUint16()
 	if err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	rows, err := r.getUint16()
 	if err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	m.Size = domain.Size{Cols: int(cols), Rows: int(rows)}
 	if m.Full, err = r.getBool(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
-	if err := ValidateOutput(m); err != nil {
+	if err := protocol.ValidateOutput(m); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	kind, err := r.getUint8()
 	if err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	decodedLen, err := r.getUint32()
 	if err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
-	if int64(decodedLen) > int64(MaxOutputDataLen) {
+	if int64(decodedLen) > int64(protocol.MaxOutputDataLen) {
-		return Output{}, ErrInvalidOutput
+		return protocol.Output{}, protocol.ErrInvalidOutput
 	}
 	data, err := r.getLongBytes()
 	if err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	if err := r.done(); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	switch kind {
 	case outputCompressionNone:
 		if uint32(len(data)) != decodedLen {
-			return Output{}, ErrInvalidOutput
+			return protocol.Output{}, protocol.ErrInvalidOutput
 		}
 		m.Data = data
 	case outputCompressionZlib:
 		if !m.Full {
-			return Output{}, ErrInvalidOutput
+			return protocol.Output{}, protocol.ErrInvalidOutput
 		}
 		m.Data, err = decompressOutputData(data, int(decodedLen))
 		if err != nil {
-			return Output{}, ErrInvalidOutput
+			return protocol.Output{}, protocol.ErrInvalidOutput
 		}
 	default:
-		return Output{}, errInvalidEnum
+		return protocol.Output{}, errInvalidEnum
 	}
-	if err := ValidateOutput(m); err != nil {
+	if err := protocol.ValidateOutput(m); err != nil {
-		return Output{}, err
+		return protocol.Output{}, err
 	}
 	return m, nil
 }
 	if err != nil {
 		return Detached{}, err
 	}
-	if !validDetachedReason(reason) {
+	if ValidateDetached(Detached{Reason: reason}) != nil {
 		return Detached{}, errInvalidEnum
 	}
 	if err := r.done(); err != nil {
 		return renderer.Style{}, err
 	}
 	if flags&0x80 != 0 {
-		return renderer.Style{}, ErrRemotePreviewUnsupportedStyle
+		return renderer.Style{}, protocol.ErrRemotePreviewUnsupportedStyle
 	}
 	attrs, err := r.getUint16()
 	if err != nil {
 		ForegroundRGB: fgrgb, BackgroundRGB: bgrgb, UnderlineColorRGB: ulrgb}, nil
 }
-func MarshalRemotePreviewRequest(request RemotePreviewRequest) []byte {
+func MarshalRemotePreviewRequest(request protocol.RemotePreviewRequest) []byte {
-	if ValidateRemotePreviewRequest(request) != nil {
+	if protocol.ValidateRemotePreviewRequest(request) != nil {
 		return nil
 	}
 	w := payloadWriter{}
 	return w.b
 }
-func UnmarshalRemotePreviewRequest(data []byte) (RemotePreviewRequest, error) {
+func UnmarshalRemotePreviewRequest(data []byte) (protocol.RemotePreviewRequest, error) {
-	if len(data) > RemotePreviewMaxBytes {
+	if len(data) > protocol.RemotePreviewMaxBytes {
-		return RemotePreviewRequest{}, ErrInvalidRemotePreviewRequest
+		return protocol.RemotePreviewRequest{}, protocol.ErrInvalidRemotePreviewRequest
 	}
 	r := payloadReader{b: data}
-	var q RemotePreviewRequest
+	var q protocol.RemotePreviewRequest
 	var err error
 	if q.Version, err = r.getUint16(); err != nil {
 		return q, err
 	if err := r.done(); err != nil {
 		return q, err
 	}
-	if err := ValidateRemotePreviewRequest(q); err != nil {
+	if err := protocol.ValidateRemotePreviewRequest(q); err != nil {
 		return q, err
 	}
 	return q, nil
 const previewCellWireSize = 4 + 1 + 1 + 2 + 2 + 2 + 1 + 2 + 3 + 3 + 3
-func MarshalRemotePreview(preview RemotePreview) []byte {
+func MarshalRemotePreview(preview protocol.RemotePreview) []byte {
-	if ValidateRemotePreview(preview) != nil {
+	if protocol.ValidateRemotePreview(preview) != nil {
 		return nil
 	}
 	w := payloadWriter{}
 	return w.b
 }
-func UnmarshalRemotePreview(data []byte) (RemotePreview, error) {
+func UnmarshalRemotePreview(data []byte) (protocol.RemotePreview, error) {
-	if len(data) > RemotePreviewMaxBytes {
+	if len(data) > protocol.RemotePreviewMaxBytes {
-		return RemotePreview{}, ErrRemotePreviewTooLarge
+		return protocol.RemotePreview{}, protocol.ErrRemotePreviewTooLarge
 	}
 	r := payloadReader{b: data}
-	var p RemotePreview
+	var p protocol.RemotePreview
 	var err error
 	if p.Version, err = r.getUint16(); err != nil {
 		return p, err
 	if err != nil {
 		return p, err
 	}
-	p.Status = RemotePreviewStatus(status)
+	p.Status = protocol.RemotePreviewStatus(status)
 	id, err := r.getBytes(16)
 	if err != nil {
 		return p, err
 	if err != nil {
 		return p, err
 	}
-	if count > RemotePreviewMaxCells || uint64(count) > uint64(len(r.b)/previewCellWireSize) {
+	if count > protocol.RemotePreviewMaxCells || uint64(count) > uint64(len(r.b)/previewCellWireSize) {
-		return p, ErrRemotePreviewTooLarge
+		return p, protocol.ErrRemotePreviewTooLarge
 	}
 	if count != 0 {
 		p.Cells = make([]renderer.Cell, 0, int(count))
 				return p, e
 			}
 			if flags&^uint8(1) != 0 {
-				return p, ErrInvalidRemotePreview
+				return p, protocol.ErrInvalidRemotePreview
 			}
 			style, e := getPreviewStyle(&r)
 			if e != nil {
 	if err := r.done(); err != nil {
 		return p, err
 	}
-	if err := ValidateRemotePreview(p); err != nil {
+	if err := protocol.ValidateRemotePreview(p); err != nil {
 		return p, err
 	}
 	return p, nil
 }
 // MarshalNavigationDirective encodes one bounded navigation directive.
-func MarshalNavigationDirective(directive NavigationDirective) []byte {
+func MarshalNavigationDirective(directive protocol.NavigationDirective) []byte {
-	if directive.Action != NavigationOpenHomePicker && directive.Action != NavigationBack {
+	if directive.Action != protocol.NavigationOpenHomePicker && directive.Action != protocol.NavigationBack {
 		return nil
 	}
-	if directive.Action == NavigationOpenHomePicker && directive.LeaseID.IsZero() || directive.Action == NavigationBack && !directive.LeaseID.IsZero() {
+	if directive.Action == protocol.NavigationOpenHomePicker && directive.LeaseID.IsZero() || directive.Action == protocol.NavigationBack && !directive.LeaseID.IsZero() {
 		return nil
 	}
 	w := payloadWriter{}
 }
 // UnmarshalNavigationDirective decodes one strict navigation directive.
-func UnmarshalNavigationDirective(b []byte) (NavigationDirective, error) {
+func UnmarshalNavigationDirective(b []byte) (protocol.NavigationDirective, error) {
 	r := payloadReader{b: b}
 	value, err := r.getUint8()
 	if err != nil {
-		return NavigationDirective{}, ErrInvalidNavigation
+		return protocol.NavigationDirective{}, protocol.ErrInvalidNavigation
 	}
-	lease, err := r.getBytes(len(ParkedRouteLeaseID{}))
+	lease, err := r.getBytes(len(protocol.ParkedRouteLeaseID{}))
 	if err != nil {
-		return NavigationDirective{}, ErrInvalidNavigation
+		return protocol.NavigationDirective{}, protocol.ErrInvalidNavigation
 	}
 	if err := r.done(); err != nil {
-		return NavigationDirective{}, ErrInvalidNavigation
+		return protocol.NavigationDirective{}, protocol.ErrInvalidNavigation
 	}
-	directive := NavigationDirective{Action: NavigationAction(value)}
+	directive := protocol.NavigationDirective{Action: protocol.NavigationAction(value)}
 	copy(directive.LeaseID[:], lease)
 	if MarshalNavigationDirective(directive) == nil {
-		return NavigationDirective{}, ErrInvalidNavigation
+		return protocol.NavigationDirective{}, protocol.ErrInvalidNavigation
 	}
 	return directive, nil
 }
 // ValidateParkedRouteRequest enforces the closed action/target shape before a
 // request reaches either side's route state machine.
-func ValidateParkedRouteRequest(request ParkedRouteRequest) error {
-	if request.RequestID == 0 || request.LeaseID.IsZero() {
-		return ErrInvalidNavigation
-	}
-	switch request.Action {
-	case ParkedRoutePrepare, ParkedRouteResume:
-		if request.Target != nil {
-			return ErrInvalidNavigation
-		}
-	case ParkedRouteSwitch:
-		if request.Target == nil || validateWireRemoteTarget(*request.Target) != nil {
-			return ErrInvalidNavigation
-		}
-	default:
-		return ErrInvalidNavigation
-	}
-	return nil
-}
 // MarshalParkedRouteRequest encodes one retained-route operation.
-func MarshalParkedRouteRequest(request ParkedRouteRequest) []byte {
+func MarshalParkedRouteRequest(request protocol.ParkedRouteRequest) []byte {
-	if ValidateParkedRouteRequest(request) != nil {
+	if protocol.ValidateParkedRouteRequest(request) != nil {
 		return nil
 	}
 	w := payloadWriter{}
 }
 // UnmarshalParkedRouteRequest decodes one strict retained-route operation.
-func UnmarshalParkedRouteRequest(b []byte) (ParkedRouteRequest, error) {
+func UnmarshalParkedRouteRequest(b []byte) (protocol.ParkedRouteRequest, error) {
 	r := payloadReader{b: b}
 	requestID, err := r.getUint64()
 	if err != nil {
-		return ParkedRouteRequest{}, ErrInvalidNavigation
+		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
 	}
-	lease, err := r.getBytes(len(ParkedRouteLeaseID{}))
+	lease, err := r.getBytes(len(protocol.ParkedRouteLeaseID{}))
 	if err != nil {
-		return ParkedRouteRequest{}, ErrInvalidNavigation
+		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
 	}
 	action, err := r.getUint8()
 	if err != nil {
-		return ParkedRouteRequest{}, ErrInvalidNavigation
+		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
 	}
 	target, policy, err := unmarshalRemoteTargetSection(&r)
 	if err != nil || policy != EnvironmentPolicyDaemonOwned || r.done() != nil {
-		return ParkedRouteRequest{}, ErrInvalidNavigation
+		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
 	}
-	request := ParkedRouteRequest{RequestID: requestID, Action: ParkedRouteAction(action), Target: target}
+	request := protocol.ParkedRouteRequest{RequestID: requestID, Action: protocol.ParkedRouteAction(action), Target: target}
 	copy(request.LeaseID[:], lease)
-	if ValidateParkedRouteRequest(request) != nil {
+	if protocol.ValidateParkedRouteRequest(request) != nil {
-		return ParkedRouteRequest{}, ErrInvalidNavigation
+		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
 	}
 	return request, nil
 }
 // MarshalParkedRouteResponse encodes one correlated retained-route outcome.
-func MarshalParkedRouteResponse(response ParkedRouteResponse) []byte {
+func MarshalParkedRouteResponse(response protocol.ParkedRouteResponse) []byte {
-	if response.RequestID == 0 || response.Status < ParkedRouteReady || response.Status > ParkedRouteStaleTarget {
+	if response.RequestID == 0 || response.Status < protocol.ParkedRouteReady || response.Status > protocol.ParkedRouteStaleTarget {
 		return nil
 	}
 	w := payloadWriter{}
 }
 // UnmarshalParkedRouteResponse decodes one strict retained-route outcome.
-func UnmarshalParkedRouteResponse(b []byte) (ParkedRouteResponse, error) {
+func UnmarshalParkedRouteResponse(b []byte) (protocol.ParkedRouteResponse, error) {
 	r := payloadReader{b: b}
 	requestID, err := r.getUint64()
 	if err != nil {
-		return ParkedRouteResponse{}, ErrInvalidNavigation
+		return protocol.ParkedRouteResponse{}, protocol.ErrInvalidNavigation
 	}
 	status, err := r.getUint8()
 	if err != nil || r.done() != nil {
-		return ParkedRouteResponse{}, ErrInvalidNavigation
+		return protocol.ParkedRouteResponse{}, protocol.ErrInvalidNavigation
 	}
-	response := ParkedRouteResponse{RequestID: requestID, Status: ParkedRouteStatus(status)}
+	response := protocol.ParkedRouteResponse{RequestID: requestID, Status: protocol.ParkedRouteStatus(status)}
 	if MarshalParkedRouteResponse(response) == nil {
-		return ParkedRouteResponse{}, ErrInvalidNavigation
+		return protocol.ParkedRouteResponse{}, protocol.ErrInvalidNavigation
 	}
 	return response, nil
 }

M internal/ports/wire_final_test.go +11 -10

 	"testing"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestFinalProtocolVersionAndNoV21Hello(t *testing.T) {
 }
 func TestFinalResizeGoldenStrict(t *testing.T) {
-	msg := Resize{Size: domain.Size{Cols: 80, Rows: 24}}
+	msg := protocol.Resize{Size: domain.Size{Cols: 80, Rows: 24}}
 	want := []byte{0, 80, 0, 24, 0, 0, 0, 0}
 	got, err := MarshalResize(msg)
 	if err != nil {
 	assertAllPrefixesFail(t, got, UnmarshalResize)
 	assertTrailingGarbageFails(t, got, UnmarshalResize)
 	for _, size := range []domain.Size{{}, {Cols: 513, Rows: 512}} {
-		if got, err := MarshalResize(Resize{Size: size}); err == nil || got != nil {
+		if got, err := MarshalResize(protocol.Resize{Size: size}); err == nil || got != nil {
 			t.Fatalf("MarshalResize(%+v) = (%x, %v), want nil payload and error", size, got, err)
 		}
 	}
 }
 func TestFinalOutputGoldenStrict(t *testing.T) {
-	msg := Output{
+	msg := protocol.Output{
 		Epoch: 1, Base: 0, New: 7, Echo: 8, ViewRevision: 9,
 		Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("ok"),
 	}
 }
 func TestFinalOutputSemanticValidationBeforeDataAllocation(t *testing.T) {
-	valid := Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true}
+	valid := protocol.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true}
-	for _, bad := range []Output{
+	for _, bad := range []protocol.Output{
 		{},
 		{Epoch: 1, Base: 0, New: 1, Size: valid.Size},
 		{Epoch: 1, Base: 0, New: 1, Full: true},
 }
 func TestFinalAckGoldenStrict(t *testing.T) {
-	msg := Ack{Epoch: 2, State: 7}
+	msg := protocol.Ack{Epoch: 2, State: 7}
 	want := []byte{0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 7}
 	got, err := MarshalAck(msg)
 	if err != nil {
 		t.Fatalf("Ack bytes = %x, want %x", got, want)
 	}
 	back, err := UnmarshalAck(got)
-	if err != nil || back != (Ack{Epoch: 2, State: 7}) {
+	if err != nil || back != (protocol.Ack{Epoch: 2, State: 7}) {
 		t.Fatalf("Ack = %+v, error %v", back, err)
 	}
 	assertAllPrefixesFail(t, got, UnmarshalAck)
 	if _, err := UnmarshalAck(make([]byte, 16)); err == nil {
 		t.Fatal("UnmarshalAck accepted zero epoch")
 	}
-	if got, err := MarshalAck(Ack{State: 7}); err == nil || got != nil {
+	if got, err := MarshalAck(protocol.Ack{State: 7}); err == nil || got != nil {
 		t.Fatalf("MarshalAck accepted zero epoch: payload=%x err=%v", got, err)
 	}
 }
 func TestAttachTargetExactTargetWireStrict(t *testing.T) {
 	var lifecycle domain.SessionLifecycleID
 	lifecycle[0] = 1
-	target := AttachTarget{Session: "work", Intent: IntentAttach, ExactTarget: &ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}, SamePeer: true}
+	target := AttachTarget{Session: "work", Intent: IntentAttach, ExactTarget: &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}, SamePeer: true}
 	payload := MarshalAttachTarget(target)
 	want := append([]byte{0, 0, 0, 4, 'w', 'o', 'r', 'k', IntentAttach, 0, 0, 1, 1}, make([]byte, 15)...)
 	want = append(want, 0, 4, 'w', 'o', 'r', 'k', 1)
 	assertAllPrefixesFail(t, payload, UnmarshalAttachTarget)
 	assertTrailingGarbageFails(t, payload, UnmarshalAttachTarget)
 	mismatched := target
-	mismatched.ExactTarget = &ExactSessionTarget{LifecycleID: lifecycle, SessionName: "other"}
+	mismatched.ExactTarget = &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "other"}
 	if got := MarshalAttachTarget(mismatched); got != nil {
 		t.Fatalf("MarshalAttachTarget accepted mismatched target: %x", got)
 	}

M internal/ports/wire_test.go +17 -16

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 func TestImagePushGoldenAndRoundTrip(t *testing.T) {
 	tests := []struct {
 		name string
-		msg  ImagePush
+		msg  protocol.ImagePush
 		want []byte
 	}{
 		{
 			name: "png data",
-			msg:  ImagePush{InputSeq: 7, Mime: "image/png", Data: []byte{0x01, 0x02, 0x03}},
+			msg:  protocol.ImagePush{InputSeq: 7, Mime: "image/png", Data: []byte{0x01, 0x02, 0x03}},
 			want: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x09, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x01, 0x02, 0x03},
 		},
-		{name: "empty", msg: ImagePush{}, want: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+		{name: "empty", msg: protocol.ImagePush{}, want: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
 	}
 	for _, tt := range tests {
 	zeroes := make([]byte, 57)
 	tests := []struct {
 		name string
-		msg  Theme
+		msg  protocol.Theme
 		want []byte
 	}{
 		{
 			name: "empty",
-			msg:  Theme{},
+			msg:  protocol.Theme{},
 			want: zeroes,
 		},
 		{
 			name: "foreground only",
-			msg: Theme{
+			msg: protocol.Theme{
 				HasForeground: true,
 				Foreground:    renderer.RGB{R: 10, G: 20, B: 30},
 				Background:    renderer.RGB{R: 40, G: 50, B: 60},
 		},
 		{
 			name: "light flag without known scheme",
-			msg: Theme{
+			msg: protocol.Theme{
 				Light: true,
 			},
 			want: append([]byte{0x10}, zeroes[1:]...),
 		},
 		{
 			name: "full palette",
-			msg: Theme{
+			msg: protocol.Theme{
 				HasForeground: true,
 				Foreground:    renderer.RGB{R: 1, G: 2, B: 3},
 				HasBackground: true,
 	// A generation clear retains defaults/capabilities but has no palette bits.
 	// This literal payload locks the existing 57-byte Theme layout while the
 	// full definitive-palette golden above locks the final publication.
-	cleared := Theme{
+	cleared := protocol.Theme{
 		HasForeground: true,
 		Foreground:    renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true,
 }
 func TestResizeGoldenAndRoundTrip(t *testing.T) {
-	msg := Resize{Size: domain.Size{Cols: 100, Rows: 40}}
+	msg := protocol.Resize{Size: domain.Size{Cols: 100, Rows: 40}}
 	want := []byte{0x00, 0x64, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00}
 	got, err := MarshalResize(msg)
 func TestMarshalWelcomeRejectsInvalidCommittedIdentity(t *testing.T) {
 	got := MarshalWelcome(Welcome{
 		SessionName: "work",
-		CommittedIdentity: &CommittedRouteIdentity{
+		CommittedIdentity: &protocol.CommittedRouteIdentity{
-			Target: ExactSessionTarget{SessionName: "different"},
+			Target: protocol.ExactSessionTarget{SessionName: "different"},
 		},
 	})
 	require.Nil(t, got)
 		SessionID:   "session",
 		SessionName: "work",
 		Ephemeral:   true,
-		CommittedIdentity: &CommittedRouteIdentity{
+		CommittedIdentity: &protocol.CommittedRouteIdentity{
-			Target:    ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "work"},
+			Target:    protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "work"},
 			Ephemeral: true,
 		},
 	}
 }
 func TestOutputGoldenAndRoundTrip(t *testing.T) {
-	msg := Output{Epoch: 1, Base: 0, New: 2, Echo: 3, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("hello\n")}
+	msg := protocol.Output{Epoch: 1, Base: 0, New: 2, Echo: 3, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("hello\n")}
 	want := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x0a}
 	got, err := MarshalOutput(msg)
 }
 func TestAckGoldenAndRoundTrip(t *testing.T) {
-	msg := Ack{Epoch: 1, State: 0x0102030405060708}
+	msg := protocol.Ack{Epoch: 1, State: 0x0102030405060708}
 	want := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
 	got, err := MarshalAck(msg)

A internal/protocol/navigation.go +106 -0

@@ -0,0 +1,106 @@
	1	+	package protocol
	2	+
	3	+	import "github.com/bnema/vev/internal/domain"
	4	+
	5	+	type NavigationCapabilities uint8
	6	+
	7	+	const (
	8	+	NavigationCapabilityHomePicker NavigationCapabilities = 1 << iota
	9	+	NavigationCapabilityBack
	10	+	)
	11	+
	12	+	type StartupOverlay uint8
	13	+
	14	+	const (
	15	+	StartupOverlayNone StartupOverlay = iota
	16	+	StartupOverlaySessionPicker
	17	+	)
	18	+
	19	+	type NavigationAction uint8
	20	+
	21	+	const (
	22	+	NavigationOpenHomePicker NavigationAction = 1
	23	+	NavigationBack NavigationAction = 2
	24	+	)
	25	+
	26	+	type ParkedRouteLeaseID [16]byte
	27	+
	28	+	func (id ParkedRouteLeaseID) IsZero() bool { return id == ParkedRouteLeaseID{} }
	29	+
	30	+	type NavigationDirective struct {
	31	+	Action NavigationAction
	32	+	LeaseID ParkedRouteLeaseID
	33	+	}
	34	+
	35	+	type ParkedRouteAction uint8
	36	+
	37	+	const (
	38	+	ParkedRoutePrepare ParkedRouteAction = iota + 1
	39	+	ParkedRouteResume
	40	+	ParkedRouteSwitch
	41	+	)
	42	+
	43	+	type ParkedRouteRequest struct {
	44	+	RequestID uint64
	45	+	LeaseID ParkedRouteLeaseID
	46	+	Action ParkedRouteAction
	47	+	Target *domain.RemoteSessionTarget
	48	+	}
	49	+
	50	+	type ParkedRouteStatus uint8
	51	+
	52	+	const (
	53	+	ParkedRouteReady ParkedRouteStatus = iota + 1
	54	+	ParkedRouteResumed
	55	+	ParkedRouteSwitched
	56	+	ParkedRouteRejected
	57	+	ParkedRouteExpired
	58	+	ParkedRouteStaleTarget
	59	+	)
	60	+
	61	+	type ParkedRouteResponse struct {
	62	+	RequestID uint64
	63	+	Status ParkedRouteStatus
	64	+	}
	65	+
	66	+	func validNavigationCapabilities(capabilities NavigationCapabilities) bool {
	67	+	return capabilities&^(NavigationCapabilityHomePicker\|NavigationCapabilityBack) == 0
	68	+	}
	69	+
	70	+	func validStartupOverlay(overlay StartupOverlay) bool {
	71	+	return overlay == StartupOverlayNone \|\| overlay == StartupOverlaySessionPicker
	72	+	}
	73	+
	74	+	func ValidateNavigation(capabilities NavigationCapabilities, overlay StartupOverlay, homePickerRoute bool) error {
	75	+	if !validNavigationCapabilities(capabilities) \|\| !validStartupOverlay(overlay) {
	76	+	return ErrInvalidNavigation
	77	+	}
	78	+	home := capabilities&NavigationCapabilityHomePicker != 0
	79	+	back := capabilities&NavigationCapabilityBack != 0
	80	+	if (home && !homePickerRoute) \|\| back != (overlay == StartupOverlaySessionPicker) {
	81	+	return ErrInvalidNavigation
	82	+	}
	83	+	if homePickerRoute && back {
	84	+	return ErrInvalidNavigation
	85	+	}
	86	+	return nil
	87	+	}
	88	+
	89	+	func ValidateParkedRouteRequest(request ParkedRouteRequest) error {
	90	+	if request.RequestID == 0 \|\| request.LeaseID.IsZero() {
	91	+	return ErrInvalidNavigation
	92	+	}
	93	+	switch request.Action {
	94	+	case ParkedRoutePrepare, ParkedRouteResume:
	95	+	if request.Target != nil {
	96	+	return ErrInvalidNavigation
	97	+	}
	98	+	case ParkedRouteSwitch:
	99	+	if request.Target == nil \|\| validateRemoteTarget(*request.Target) != nil {
	100	+	return ErrInvalidNavigation
	101	+	}
	102	+	default:
	103	+	return ErrInvalidNavigation
	104	+	}
	105	+	return nil
	106	+	}

R internal/ports/remote_preview.go → internal/protocol/preview.go +35 -1 renamed, 82% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package protocol
2			2
3		import (	3		import (
4		"errors"	4		"errors"

@@ -10,6 +10,40 @@ import (
10		"github.com/bnema/vev/internal/domain"	10		"github.com/bnema/vev/internal/domain"
11		)	11		)
12			12
			13	+	// RemotePreviewSchemaVersion is independent from the attachment protocol version.
			14	+	const RemotePreviewSchemaVersion uint16 = 1
			15	+
			16	+	type RemotePreviewStatus uint8
			17	+
			18	+	const (
			19	+	RemotePreviewOK RemotePreviewStatus = iota
			20	+	RemotePreviewUnavailable
			21	+	RemotePreviewNoSuchTarget
			22	+	RemotePreviewStale
			23	+	RemotePreviewMalformed
			24	+	RemotePreviewTooLarge
			25	+	)
			26	+
			27	+	type RemotePreviewRequest struct {
			28	+	Version uint16
			29	+	Target domain.RemoteSessionTarget
			30	+	Width uint16
			31	+	Height uint16
			32	+	}
			33	+
			34	+	// RemotePreview is a bounded row-major styled-cell viewport. It is never
			35	+	// persisted, logged, or traced.
			36	+	type RemotePreview struct {
			37	+	Version uint16
			38	+	Status RemotePreviewStatus
			39	+	LifecycleID domain.SessionLifecycleID
			40	+	TabID domain.TabStableID
			41	+	Revision uint64
			42	+	Width uint16
			43	+	Height uint16
			44	+	Cells []renderer.Cell
			45	+	}
			46	+
13		const (	47		const (
14		RemotePreviewMaxWidth = 256	48		RemotePreviewMaxWidth = 256
15		RemotePreviewMaxHeight = 128	49		RemotePreviewMaxHeight = 128

R internal/ports/routes.go → internal/protocol/routes.go +21 -3 renamed, 93% similar

-package ports
+package protocol
 import (
 	"errors"
 	"github.com/bnema/vev/internal/domain"
 )
+// ErrInvalidRouteWire preserves the public error classification used by
+// strict route codecs while route values live in the semantic protocol.
+var ErrInvalidRouteWire = errors.New("invalid route wire message")
 // RouteOrigin identifies how a client reached a daemon. The origin is client
 // composition metadata, not an authority granted to the daemon.
 type RouteOrigin uint8
 	Targets []RouteAttentionTarget
 }
-func (r RouteRef) empty() bool { return r.Key == 0 && r.Generation == 0 }
+func (r RouteRef) IsZero() bool { return r.Key == 0 && r.Generation == 0 }
 func (r RouteRef) Validate() error {
-	if r.empty() {
+	if r.IsZero() {
 		return nil
 	}
 	if r.Key == 0 || r.Generation == 0 {
 	return c == SamePeerSwitchStaleTarget || c == SamePeerSwitchUnavailable
 }
+func (c SamePeerSwitchFailureCode) Validate() error {
+	if !c.valid() {
+		return ErrInvalidRouteWire
+	}
+	return nil
+}
 // SamePeerSwitchFailure leaves the source attachment unchanged. RequestID
 // rejects a delayed failure after a later user selection.
 type SamePeerSwitchFailure struct {
 	}
 }
+func (c RouteFailureCode) Validate() error {
+	if !c.valid() {
+		return ErrInvalidRouteWire
+	}
+	return nil
+}
 const (
 	// RouteSnapshotMaxEntries bounds one immutable publication and the amount
 	// of work a receiver performs before returning to its transport loop. The

A internal/protocol/session.go +101 -0

@@ -0,0 +1,101 @@
	1	+	// Package protocol defines vev's typed, transport-neutral client/daemon
	2	+	// contract. Binary framing and codecs live outside this package.
	3	+	package protocol
	4	+
	5	+	import (
	6	+	"errors"
	7	+	"fmt"
	8	+	"math"
	9	+
	10	+	renderer "github.com/bnema/vev-vt"
	11	+	"github.com/bnema/vev/internal/domain"
	12	+	)
	13	+
	14	+	// MaxOutputDataLen is the largest decoded terminal byte stream accepted by one
	15	+	// output publication in protocol version 37.
	16	+	const MaxOutputDataLen = (16 << 20) - 55
	17	+
	18	+	var (
	19	+	ErrInvalidSize = errors.New("ports: invalid terminal size")
	20	+	ErrInvalidOutput = errors.New("ports: invalid output")
	21	+	ErrInvalidAck = errors.New("ports: invalid ack")
	22	+	ErrInvalidNavigation = errors.New("ports: invalid navigation")
	23	+	)
	24	+
	25	+	type Resize struct {
	26	+	Size domain.Size
	27	+	PixelWidth int
	28	+	PixelHeight int
	29	+	}
	30	+
	31	+	func (m Resize) Geometry() domain.Geometry {
	32	+	return domain.Geometry{Size: m.Size, PixelWidth: m.PixelWidth, PixelHeight: m.PixelHeight}.NormalizePixels()
	33	+	}
	34	+
	35	+	type Theme struct {
	36	+	HasForeground bool
	37	+	Foreground renderer.RGB
	38	+	HasBackground bool
	39	+	Background renderer.RGB
	40	+	TrueColor bool
	41	+	SchemeKnown bool
	42	+	Light bool
	43	+	PaletteKnown uint16
	44	+	Palette [16]renderer.RGB
	45	+	}
	46	+
	47	+	type ImagePush struct {
	48	+	InputSeq uint64
	49	+	Mime string
	50	+	Data []byte
	51	+	}
	52	+
	53	+	type Ack struct {
	54	+	Epoch uint64
	55	+	State uint64
	56	+	}
	57	+
	58	+	type Output struct {
	59	+	Epoch uint64
	60	+	Base uint64
	61	+	New uint64
	62	+	Echo uint64
	63	+	ViewRevision uint64
	64	+	Size domain.Size
	65	+	Full bool
	66	+	Data []byte
	67	+	}
	68	+
	69	+	func ValidateOutput(m Output) error {
	70	+	if m.Epoch == 0 {
	71	+	return ErrInvalidOutput
	72	+	}
	73	+	if m.New == 0 {
	74	+	if m.Base != 0 \|\| m.Full {
	75	+	return ErrInvalidOutput
	76	+	}
	77	+	} else if (m.Base == 0 && !m.Full) \|\| (m.Base != 0 && (m.Full \|\| m.New != m.Base+1)) {
	78	+	return ErrInvalidOutput
	79	+	}
	80	+	if err := ValidateSize(m.Size); err != nil {
	81	+	return fmt.Errorf("%w: size", ErrInvalidOutput)
	82	+	}
	83	+	if uint64(len(m.Data)) > math.MaxUint32 \|\| len(m.Data) > MaxOutputDataLen {
	84	+	return ErrInvalidOutput
	85	+	}
	86	+	return nil
	87	+	}
	88	+
	89	+	func ValidateAck(m Ack) error {
	90	+	if m.Epoch == 0 {
	91	+	return ErrInvalidAck
	92	+	}
	93	+	return nil
	94	+	}
	95	+
	96	+	func validateRemoteTarget(target domain.RemoteSessionTarget) error {
	97	+	if len(target.Endpoint) > math.MaxUint16 \|\| len(target.DisplayOrigin) > math.MaxUint16 \|\| len(target.SessionName) > math.MaxUint16 \|\| len(target.LiveTabID) > math.MaxUint16 \|\| len(target.StoppedTab.RawName) > math.MaxUint16 {
	98	+	return errors.New("remote target string too long")
	99	+	}
	100	+	return target.Validate()
	101	+	}

A internal/protocol/session_test.go +49 -0

@@ -0,0 +1,49 @@
	1	+	package protocol
	2	+
	3	+	import (
	4	+	"errors"
	5	+	"testing"
	6	+
	7	+	renderer "github.com/bnema/vev-vt"
	8	+	"github.com/bnema/vev/internal/domain"
	9	+	"github.com/stretchr/testify/require"
	10	+	)
	11	+
	12	+	func TestOutputSemanticValidation(t *testing.T) {
	13	+	valid := Output{Epoch: 1, New: 1, Full: true, Size: domain.Size{Cols: 80, Rows: 24}}
	14	+	require.NoError(t, ValidateOutput(valid))
	15	+
	16	+	invalid := valid
	17	+	invalid.Epoch = 0
	18	+	require.ErrorIs(t, ValidateOutput(invalid), ErrInvalidOutput)
	19	+
	20	+	invalid = valid
	21	+	invalid.Data = make([]byte, MaxOutputDataLen+1)
	22	+	require.ErrorIs(t, ValidateOutput(invalid), ErrInvalidOutput)
	23	+	}
	24	+
	25	+	func TestRouteAndPreviewSemanticValidation(t *testing.T) {
	26	+	require.Error(t, ValidateRouteLabel("\x1b[31m", false))
	27	+	require.NoError(t, RouteRef{}.Validate())
	28	+	require.Error(t, (RouteRef{Key: 1}).Validate())
	29	+
	30	+	target := domain.RemoteSessionTarget{
	31	+	Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: domain.SessionLifecycleID{1},
	32	+	SessionName: "work", LiveTabID: "tab-1",
	33	+	}
	34	+	request := RemotePreviewRequest{Version: RemotePreviewSchemaVersion, Target: target, Width: 1, Height: 1}
	35	+	require.NoError(t, ValidateRemotePreviewRequest(request))
	36	+	preview := RemotePreview{
	37	+	Version: RemotePreviewSchemaVersion, Status: RemotePreviewOK,
	38	+	LifecycleID: target.LifecycleID, TabID: target.LiveTabID, Revision: 1,
	39	+	Width: 1, Height: 1, Cells: []renderer.Cell{{Rune: 'x'}},
	40	+	}
	41	+	require.NoError(t, ValidateRemotePreview(preview))
	42	+	preview.Cells[0].Rune = '\n'
	43	+	require.ErrorIs(t, ValidateRemotePreview(preview), ErrInvalidRemotePreview)
	44	+	}
	45	+
	46	+	func TestPresentationErrorsPreserveClassification(t *testing.T) {
	47	+	require.True(t, errors.Is(ValidateAck(Ack{}), ErrInvalidAck))
	48	+	require.True(t, errors.Is(ValidateParkedRouteRequest(ParkedRouteRequest{}), ErrInvalidNavigation))
	49	+	}

R internal/ports/wire_size.go → internal/protocol/size.go +1 -1 renamed, 98% similar

@@ -1,4 +1,4 @@
1	-	package ports	1	+	package protocol
2			2
3		import (	3		import (
4		"math"	4		"math"

M internal/testutil/replaytest/replay.go +4 -3

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
-func mustMarshalOutput(m ports.Output) []byte {
+func mustMarshalOutput(m protocol.Output) []byte {
 	payload, err := ports.MarshalOutput(m)
 	if err != nil {
 		panic(err)
 }
 var transcript = []ports.Frame{
-	{Type: ports.MsgOutput, Payload: mustMarshalOutput(ports.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: 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(ports.Output{Epoch: 1, Base: 1, New: 2, Echo: 7, Size: domain.Size{Cols: 80, Rows: 24}, Data: []byte("\x1b[2;1HTWO")})},
+	{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")})},
 }
 // Transcript returns a deep copy of the canonical replay transcript so an

M internal/usecase/client/client.go +67 -66

 	"github.com/bnema/vev-vt/protocol/terminalquery"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/theme"
 )
 // without relying on another OSC response.
 type terminalThemeState struct {
 	mu    sync.Mutex
-	theme ports.Theme
+	theme protocol.Theme
 }
 func (s *terminalThemeState) setTrueColor(enabled bool) {
 	s.mu.Unlock()
 }
-func (s *terminalThemeState) update(update func(*ports.Theme)) ports.Theme {
+func (s *terminalThemeState) update(update func(*protocol.Theme)) protocol.Theme {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	update(&s.theme)
 	return s.theme
 }
-func (s *terminalThemeState) snapshot() ports.Theme {
+func (s *terminalThemeState) snapshot() protocol.Theme {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	return s.theme
 	Remote bool
 	// Origin is explicit composition metadata for the initial route. A zero
 	// value is normalized to local for direct package callers and old tests.
-	Origin    ports.RouteOrigin
+	Origin    protocol.RouteOrigin
 	OriginKey string
 }
 	Intent                 uint8
 	SessionName            string
 	Remote                 bool
-	Origin                 ports.RouteOrigin
+	Origin                 protocol.RouteOrigin
 	OriginKey              string
 	RemoteTarget           *domain.RemoteSessionTarget
-	ExactTarget            *ports.ExactSessionTarget
+	ExactTarget            *protocol.ExactSessionTarget
 	PreferredTabID         domain.TabStableID
 	HostLabel              string
 	EnvironmentPolicy      ports.EnvironmentPolicy
-	NavigationCapabilities ports.NavigationCapabilities
+	NavigationCapabilities protocol.NavigationCapabilities
-	StartupOverlay         ports.StartupOverlay
+	StartupOverlay         protocol.StartupOverlay
 }
 // attachRoute captures the dialer, request, and resume token needed to
 	remoteHostLearner ports.RemoteHostLearner
 	attachHandoff     AttachHandoffFunc
 	remote            bool
-	origin            ports.RouteOrigin
+	origin            protocol.RouteOrigin
 	ledger            *routeLedger
-	routeFailure      *ports.RouteNavigationFailure
+	routeFailure      *protocol.RouteNavigationFailure
 	inputMu sync.Mutex
 	input   *terminalInputPump
 		}
 	}
 	if request.OriginKey != "" {
-		if err := ports.ValidateRouteLabel(request.OriginKey, false); err != nil {
+		if err := protocol.ValidateRouteLabel(request.OriginKey, false); err != nil {
 			return fmt.Errorf("vev: invalid route origin key: %w", err)
 		}
 	}
 	if err := (SessionTarget{Intent: request.Intent, SessionName: request.SessionName}).validate(); err != nil {
 		return fmt.Errorf("vev: invalid session target: %w", err)
 	}
-	if err := ports.ValidateNavigation(request.NavigationCapabilities, request.StartupOverlay, request.RemoteTarget != nil || request.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned); err != nil {
+	if err := protocol.ValidateNavigation(request.NavigationCapabilities, request.StartupOverlay, request.RemoteTarget != nil || request.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned); err != nil {
 		return fmt.Errorf("vev: invalid navigation route: %w", err)
 	}
 	if request.RemoteTarget == nil {
 	routeNavigationResumeFallback := false
 	var routeNavigationSelection *routeNavigationSelection
 	var routeNavigationFallback *attachRoute
-	var routeNavigationAction *ports.RouteNavigationAction
+	var routeNavigationAction *protocol.RouteNavigationAction
 	backoff := defaultReconnectBackoff.initial
 	themeState := &terminalThemeState{}
 	var rememberOnce sync.Once
 		} else {
 			attemptRequest.Intent = ports.IntentAttach
 		}
-		attemptRequest.StartupOverlay = ports.StartupOverlayNone
+		attemptRequest.StartupOverlay = protocol.StartupOverlayNone
-		attemptRequest.NavigationCapabilities &^= ports.NavigationCapabilityBack | ports.NavigationCapabilityHomePicker
+		attemptRequest.NavigationCapabilities &^= protocol.NavigationCapabilityBack | protocol.NavigationCapabilityHomePicker
 		resumeToken = route.resumeToken
 		returnResumeFallback = route.resumeToken != 0
 		remote = syncReconnectRemote(reconnect, attemptRequest.Remote || r.remote)
 		dialer = homeRoute.dialer
 		attemptRequest = homeRoute.request
 		attemptRequest.Intent = ports.IntentAttach
-		attemptRequest.NavigationCapabilities = ports.NavigationCapabilityBack
+		attemptRequest.NavigationCapabilities = protocol.NavigationCapabilityBack
-		attemptRequest.StartupOverlay = ports.StartupOverlaySessionPicker
+		attemptRequest.StartupOverlay = protocol.StartupOverlaySessionPicker
 		attemptRequest.RemoteTarget = nil
 		attemptRequest.EnvironmentPolicy = ports.EnvironmentPolicyClientOwned
 		attemptRequest.Remote = homeRoute.request.Remote || r.remote
 		}
 		request := cloneAttachRequest(homeRoute.request)
 		request.Intent = ports.IntentAttach
-		request.NavigationCapabilities = ports.NavigationCapabilityBack
+		request.NavigationCapabilities = protocol.NavigationCapabilityBack
-		request.StartupOverlay = ports.StartupOverlaySessionPicker
+		request.StartupOverlay = protocol.StartupOverlaySessionPicker
 		request.RemoteTarget = nil
 		request.EnvironmentPolicy = ports.EnvironmentPolicyClientOwned
 		request.Remote = false
 			// Back is transient to the picker overlay. Re-derive the home-picker
 			// capability from the selected route instead of trusting request
 			// metadata, which may have been cleared after a daemon-side switch.
-			attemptRequest.StartupOverlay = ports.StartupOverlayNone
+			attemptRequest.StartupOverlay = protocol.StartupOverlayNone
 			attemptRequest.NavigationCapabilities = 0
-			if homeRoute != nil && selection.selected.presentation.kind == ports.RouteKindRemote {
+			if homeRoute != nil && selection.selected.presentation.kind == protocol.RouteKindRemote {
-				attemptRequest.NavigationCapabilities = ports.NavigationCapabilityHomePicker
+				attemptRequest.NavigationCapabilities = protocol.NavigationCapabilityHomePicker
 			}
 			resumeToken = selection.selected.resumeToken
 			routeNavigationPending = true
 		}
 		if result.action != 0 {
 			switch result.action {
-			case ports.NavigationOpenHomePicker:
+			case protocol.NavigationOpenHomePicker:
 				// The daemon only sends this action after accepting a Hello that
 				// advertised Home support. The durable client-side prerequisite is
 				// the captured route itself; request metadata may have been rebased by
 				homeNavigationPending = true
 				enterHomePicker()
 				continue
-			case ports.NavigationBack:
+			case protocol.NavigationBack:
 				// As with Home, the daemon accepted Back in Hello before sending
 				// this action. The retained concrete route is the durable client
 				// prerequisite; request metadata may have been rebased meanwhile.
 					}
 					routeRequest.Intent = ports.IntentAttach
 					routeRequest.NavigationCapabilities = 0
-					routeRequest.StartupOverlay = ports.StartupOverlayNone
+					routeRequest.StartupOverlay = protocol.StartupOverlayNone
 					homeRoute = &attachRoute{dialer: dialer, request: routeRequest}
 				}
 			}
 				nextRequest.ExactTarget = result.target.ExactTarget
 			}
 			if homeRoute != nil && (nextRequest.RemoteTarget != nil || nextRequest.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned) {
-				nextRequest.NavigationCapabilities |= ports.NavigationCapabilityHomePicker
+				nextRequest.NavigationCapabilities |= protocol.NavigationCapabilityHomePicker
 			}
-			if attemptRequest.StartupOverlay == ports.StartupOverlaySessionPicker {
+			if attemptRequest.StartupOverlay == protocol.StartupOverlaySessionPicker {
 				returnRoute = nil
 				returnResumeFallback = false
 			}
 		if routeNavigationPending && routeNavigationFallback != nil {
 			if routeNavigationAction != nil {
 				action := *routeNavigationAction
-				r.routeFailure = &ports.RouteNavigationFailure{Key: action.Key, Generation: action.Generation, Code: routeFailureCode(result.err)}
+				r.routeFailure = &protocol.RouteNavigationFailure{Key: action.Key, Generation: action.Generation, Code: routeFailureCode(result.err)}
 				routeNavigationAction = nil
 			}
 			route := *routeNavigationFallback
 type attachResult struct {
 	resumeToken       uint64
 	sessionName       string
-	committedIdentity *ports.CommittedRouteIdentity
+	committedIdentity *protocol.CommittedRouteIdentity
-	routePosition     *ports.RoutePosition
+	routePosition     *protocol.RoutePosition
 	welcomed          bool
 	transportClosed   bool
 	target            *ports.AttachTarget
-	action            ports.NavigationAction
+	action            protocol.NavigationAction
 	homePickerTarget  bool
-	routeAction       *ports.RouteNavigationAction
+	routeAction       *protocol.RouteNavigationAction
 	err               error
 }
 	themeState.setTrueColor(trueColor)
 	exactTarget := request.ExactTarget
 	if exactTarget == nil && request.RemoteTarget != nil {
-		exactTarget = &ports.ExactSessionTarget{
+		exactTarget = &protocol.ExactSessionTarget{
 			LifecycleID: request.RemoteTarget.LifecycleID,
 			SessionName: request.RemoteTarget.SessionName,
 		}
 	}, transition); err != nil {
 		return handshakeFailure("awaiting welcome", err)
 	}
-	var committedIdentity *ports.CommittedRouteIdentity
+	var committedIdentity *protocol.CommittedRouteIdentity
-	var routePosition *ports.RoutePosition
+	var routePosition *protocol.RoutePosition
 	result := func(welcomed bool, err error) attachResult {
 		return attachResult{
 			resumeToken:       resumeToken,
 			delete(timers, id)
 		}
 	}
-	publish := func(snapshot ports.Theme) error {
+	publish := func(snapshot protocol.Theme) error {
 		frame := ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(snapshot)}
 		// The initial cleared snapshot is sent before the sender exists. This
 		// keeps the generation publication ordered before the first query and
 					return fmt.Errorf("publishing theme: %w", err)
 				}
 			case paletteActionPublishFinal:
-				themeState.update(func(current *ports.Theme) { *current = action.theme })
+				themeState.update(func(current *protocol.Theme) { *current = action.theme })
 				if err := publish(action.theme); err != nil {
 					return fmt.Errorf("publishing theme: %w", err)
 				}
 	var nextSamePeerRequestID uint64
 	type parkedRoutePending struct {
 		requestID      uint64
-		action         ports.ParkedRouteAction
+		action         protocol.ParkedRouteAction
-		leaseID        ports.ParkedRouteLeaseID
+		leaseID        protocol.ParkedRouteLeaseID
 		fallbackTarget *ports.AttachTarget
 		timer          ports.Timer
 	}
 			// 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(ports.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+				payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 				if err != nil {
 					return err
 				}
 			return fmt.Errorf("reading terminal geometry for parked route: %w", err)
 		}
 		geometry = geometry.NormalizePixels()
-		payload, err := ports.MarshalResize(ports.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+		payload, err := ports.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)
 		}
 			return context.Canceled
 		}
 	}
-	sendParkedRouteRequest := func(action ports.ParkedRouteAction, leaseID ports.ParkedRouteLeaseID, target *domain.RemoteSessionTarget) error {
+	sendParkedRouteRequest := func(action protocol.ParkedRouteAction, leaseID protocol.ParkedRouteLeaseID, target *domain.RemoteSessionTarget) error {
 		if parkedPending != nil {
 			return errors.New("vev: parked-route request already pending")
 		}
 		nextParkedRequestID++
-		request := ports.ParkedRouteRequest{RequestID: nextParkedRequestID, LeaseID: leaseID, Action: action, Target: target}
+		request := protocol.ParkedRouteRequest{RequestID: nextParkedRequestID, LeaseID: leaseID, Action: action, Target: target}
 		payload := ports.MarshalParkedRouteRequest(request)
 		if payload == nil {
 			return errors.New("vev: invalid parked-route request")
 			return context.Canceled
 		}
 	}
-	handleParkedPicker := func(leaseID ports.ParkedRouteLeaseID) (attachResult, bool) {
+	handleParkedPicker := func(leaseID protocol.ParkedRouteLeaseID) (attachResult, bool) {
 		pickerCtx, cancelPicker := context.WithCancel(ctx)
 		pickerDone := make(chan struct{})
 		go func() {
 			if err := sendParkedRouteSize(); err != nil {
 				return welcomedResult(err), true
 			}
-			if err := sendParkedRouteRequest(ports.ParkedRouteSwitch, leaseID, &target); err != nil {
+			if err := sendParkedRouteRequest(protocol.ParkedRouteSwitch, leaseID, &target); err != nil {
 				return welcomedResult(fmt.Errorf("vev: switching parked route: %w", err)), true
 			}
 			fallback := *selection.target
 		if err := sendParkedRouteSize(); err != nil {
 			return welcomedResult(err), true
 		}
-		if err := sendParkedRouteRequest(ports.ParkedRouteResume, leaseID, nil); err != nil {
+		if err := sendParkedRouteRequest(protocol.ParkedRouteResume, leaseID, nil); err != nil {
 			return welcomedResult(fmt.Errorf("vev: resuming parked route: %w", err)), true
 		}
 		return attachResult{}, false
 			return fmt.Errorf("reading terminal geometry for reconnect reconciliation: %w", serr)
 		}
 		geometry = geometry.NormalizePixels()
-		payload, err := ports.MarshalResize(ports.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+		payload, err := ports.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)
 		}
 		}
 		return nil
 	}
-	sendRouteFailure := func(action ports.RouteNavigationAction, code ports.RouteFailureCode) error {
+	sendRouteFailure := func(action protocol.RouteNavigationAction, code protocol.RouteFailureCode) error {
-		payload, err := ports.MarshalRouteNavigationFailure(ports.RouteNavigationFailure{
+		payload, err := ports.MarshalRouteNavigationFailure(protocol.RouteNavigationFailure{
 			Key:        action.Key,
 			Generation: action.Generation,
 			Code:       code,
 			}
 		case event := <-paletteEvents:
 			if event.kind == paletteEventScheme {
-				retained := themeState.update(func(current *ports.Theme) {
+				retained := themeState.update(func(current *protocol.Theme) {
 					current.SchemeKnown = true
 					current.Light = event.light
 				})
 					}
 					nextSamePeerRequestID++
 					request := a.runner.ledger.samePeerHandoff(request, target)
-					payload, err := ports.MarshalSamePeerSwitchRequest(ports.SamePeerSwitchRequest{
+					payload, err := ports.MarshalSamePeerSwitchRequest(protocol.SamePeerSwitchRequest{
 						RequestID:      nextSamePeerRequestID,
 						Target:         *target.ExactTarget,
 						PreferredTabID: request.PreferredTabID,
 				pending := *parkedPending
 				clearParkedPending()
 				switch pending.action {
-				case ports.ParkedRoutePrepare:
+				case protocol.ParkedRoutePrepare:
-					if response.Status != ports.ParkedRouteReady {
+					if response.Status != protocol.ParkedRouteReady {
 						fallback := welcomedResult(nil)
-						fallback.action = ports.NavigationOpenHomePicker
+						fallback.action = protocol.NavigationOpenHomePicker
 						return fallback
 					}
 					if selection, done := handleParkedPicker(pending.leaseID); done {
 						return selection
 					}
-				case ports.ParkedRouteResume:
+				case protocol.ParkedRouteResume:
-					if response.Status != ports.ParkedRouteResumed {
+					if response.Status != protocol.ParkedRouteResumed {
 						return welcomedResult(errors.New("vev: parked route could not resume"))
 					}
 					awaitParkedFull()
-				case ports.ParkedRouteSwitch:
+				case protocol.ParkedRouteSwitch:
 					switch response.Status {
-					case ports.ParkedRouteSwitched:
+					case protocol.ParkedRouteSwitched:
 						awaitParkedFull()
 						continue
-					case ports.ParkedRouteStaleTarget:
+					case protocol.ParkedRouteStaleTarget:
 						if transition != nil {
 							transition.stop()
 						}
 					return welcomedResult(fmt.Errorf("vev: decoding navigation action: %w", derr))
 				}
 				_, datagramRoute := transport.(ports.DatagramTransport)
-				if directive.Action == ports.NavigationOpenHomePicker && a.openHomePicker != nil && datagramRoute {
+				if directive.Action == protocol.NavigationOpenHomePicker && a.openHomePicker != nil && datagramRoute {
 					stopForeground()
 					if err := flushSender(); err != nil {
 						return welcomedResult(fmt.Errorf("vev: parking remote foreground: %w", err))
 					}
-					if err := sendParkedRouteRequest(ports.ParkedRoutePrepare, directive.LeaseID, nil); err != nil {
+					if err := sendParkedRouteRequest(protocol.ParkedRoutePrepare, directive.LeaseID, nil); err != nil {
 						return welcomedResult(fmt.Errorf("vev: preparing parked route: %w", err))
 					}
 					continue
 					return welcomedResult(fmt.Errorf("vev: decoding route navigation action: %w", derr))
 				}
 				if a.runner.ledger == nil {
-					if ferr := sendRouteFailure(action, ports.RouteFailureUnavailable); ferr != nil {
+					if ferr := sendRouteFailure(action, protocol.RouteFailureUnavailable); ferr != nil {
 						return welcomedResult(ferr)
 					}
 					continue
 				}
 				_, valid, noOp := a.runner.ledger.navigationRecord(action)
 				if !valid {
-					if ferr := sendRouteFailure(action, ports.RouteFailureStaleSelection); ferr != nil {
+					if ferr := sendRouteFailure(action, protocol.RouteFailureStaleSelection); ferr != nil {
 						return welcomedResult(ferr)
 					}
 					continue
 		if state == 0 {
 			return true
 		}
-		payload, err := ports.MarshalAck(ports.Ack{Epoch: epoch, State: state})
+		payload, err := ports.MarshalAck(protocol.Ack{Epoch: epoch, State: state})
 		if err != nil {
 			select {
 			case errCh <- fmt.Errorf("encoding output ACK: %w", err):
 			},
 			sendImage: func(mime string, data []byte) {
 				inputSeq++
-				send(ports.Frame{Type: ports.MsgImagePush, Payload: ports.MarshalImagePush(ports.ImagePush{InputSeq: inputSeq, Mime: mime, Data: data})})
+				send(ports.Frame{Type: ports.MsgImagePush, Payload: ports.MarshalImagePush(protocol.ImagePush{InputSeq: inputSeq, Mime: mime, Data: data})})
 			},
 			next: coalescer.Scan,
 		}
 				return
 			}
 			geometry = geometry.NormalizePixels()
-			payload, err := ports.MarshalResize(ports.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
+			payload, err := ports.MarshalResize(protocol.Resize{Size: geometry.Size, PixelWidth: geometry.PixelWidth, PixelHeight: geometry.PixelHeight})
 			if err != nil {
 				log.Error("encoding terminal resize", "error", err)
 				continue

M internal/usecase/client/client_test.go +100 -99

 	"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/usecase/client"
 )
 		{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID:   "s1",
 			SessionName: "main",
-			CommittedIdentity: &ports.CommittedRouteIdentity{
+			CommittedIdentity: &protocol.CommittedRouteIdentity{
-				Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "main"},
+				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "main"},
 			},
 		}))},
 		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	err := runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), client.AttachRequest{
 		Intent:      ports.IntentAttach,
 		SessionName: "main",
-		Origin:      ports.RouteOriginLocal,
+		Origin:      protocol.RouteOriginLocal,
 		OriginKey:   "local",
 	})
 	require.NoError(t, err)
-	var snapshot ports.RecentRouteSnapshot
+	var snapshot protocol.RecentRouteSnapshot
-	var subscription ports.RouteAttentionSubscription
+	var subscription protocol.RouteAttentionSubscription
 	foundSnapshot := false
 	foundSubscription := false
 	for _, frame := range tr.Sends() {
 	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
 		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{
+			CommittedIdentity: &protocol.CommittedRouteIdentity{
-				Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
+				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 			},
 		}))
 	}
-	secondTarget := ports.ExactSessionTarget{LifecycleID: secondLifecycle, SessionName: "second"}
+	secondTarget := protocol.ExactSessionTarget{LifecycleID: secondLifecycle, SessionName: "second"}
 	first := &recordingTransport{recvs: []recvItem{
 		{f: welcome("first", firstLifecycle)},
 		{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{
 			Session: "second", Intent: ports.IntentAttach, ExactTarget: &secondTarget,
 			EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, SamePeer: true,
 		}))},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(ports.CommittedRouteIdentity{Target: secondTarget}))},
+		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: secondTarget}))},
 		{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	}}
 	dialer := &sequenceDialer{trs: []ports.Transport{first}}
 	err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{
 		Intent: ports.IntentAttach, SessionName: "first",
-		Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Origin: protocol.RouteOriginLocal, OriginKey: "local",
 		EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,
 	})
 	request := client.AttachRequest{
 		Intent: ports.IntentAttach, SessionName: "work", Remote: true,
 		RemoteTarget: target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
-		NavigationCapabilities: ports.NavigationCapabilityHomePicker,
+		NavigationCapabilities: protocol.NavigationCapabilityHomePicker,
-		StartupOverlay:         ports.StartupOverlayNone,
+		StartupOverlay:         protocol.StartupOverlayNone,
 	}
 	tr := &recordingTransport{recvs: []recvItem{
 		{f: welcomeFrame(0)},
 	sourceLifecycle := domain.SessionLifecycleID{1}
 	targetLifecycle := domain.SessionLifecycleID{2}
-	target := ports.ExactSessionTarget{LifecycleID: targetLifecycle, SessionName: "stopped"}
+	target := protocol.ExactSessionTarget{LifecycleID: targetLifecycle, SessionName: "stopped"}
 	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
 		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{
+			CommittedIdentity: &protocol.CommittedRouteIdentity{
-				Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
+				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 			},
 		}))
 	}
 	err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{
 		Intent: ports.IntentAttach, SessionName: "source",
-		Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Origin: protocol.RouteOriginLocal, OriginKey: "local",
 		EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,
 	})
 	welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
 		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
+			CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
 		}))
 	}
 	remoteTarget := domain.RemoteSessionTarget{
 	}}
 	remote := &recordingTransport{recvs: []recvItem{
 		{f: welcome("work", remoteLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
 	}}
 	local2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("local", localLifecycle)},
 	remoteDialer := &sequenceDialer{trs: []ports.Transport{remote}}
 	deps := testDependencies(localDialer, term, realClock{}, nil, nil)
 	deps.AttachHandoff = func(ports.AttachTarget) (ports.Dialer, client.AttachRequest, error) {
-		target := ports.ExactSessionTarget{LifecycleID: remoteLifecycle, SessionName: "work"}
+		target := protocol.ExactSessionTarget{LifecycleID: remoteLifecycle, SessionName: "work"}
 		return remoteDialer, client.AttachRequest{
 			Intent: ports.IntentAttach, SessionName: "work", Remote: true,
-			Origin: ports.RouteOriginRemote, OriginKey: "remote", ExactTarget: &target,
+			Origin: protocol.RouteOriginRemote, OriginKey: "remote", ExactTarget: &target,
 			EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,
 			// Deliberately omit the copied Home capability. The accepted server
 			// action remains valid because Runner retained the concrete home route.
 	}
 	require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	}))
-	require.Equal(t, ports.StartupOverlaySessionPicker, helloFromSend(t, local2).StartupOverlay)
+	require.Equal(t, protocol.StartupOverlaySessionPicker, helloFromSend(t, local2).StartupOverlay)
 }
 func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
 	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 		SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,
-		CommittedIdentity: &ports.CommittedRouteIdentity{Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
+		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
 	}))
 }
 		selection := *target.RemoteTarget
 		return dialer, client.AttachRequest{
 			Intent: ports.IntentAttach, SessionName: target.Session, Remote: true,
-			Origin: ports.RouteOriginDiscovery, OriginKey: target.Endpoint,
+			Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,
 			RemoteTarget: &selection, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
 		}, nil
 	}
 	return deps
 }
-func hybridParkedRequestHandler(requests chan<- ports.ParkedRouteRequest, requestErrors chan<- error, signals map[ports.ParkedRouteAction]chan struct{}) func(ports.Frame) {
+func hybridParkedRequestHandler(requests chan<- protocol.ParkedRouteRequest, requestErrors chan<- error, signals map[protocol.ParkedRouteAction]chan struct{}) func(ports.Frame) {
-	once := make(map[ports.ParkedRouteAction]*sync.Once, len(signals))
+	once := make(map[protocol.ParkedRouteAction]*sync.Once, len(signals))
 	for action := range signals {
 		once[action] = &sync.Once{}
 	}
 	localInitial := hybridLocalBootstrap(localLifecycle, sourceTarget)
 	parkSent := make(chan struct{})
 	switchSent := make(chan struct{})
-	parkedRequests := make(chan ports.ParkedRouteRequest, 2)
+	parkedRequests := make(chan protocol.ParkedRouteRequest, 2)
 	parkedRequestErrors := make(chan error, 2)
 	remote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", remoteSourceLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(ports.CommittedRouteIdentity{Target: ports.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},
+		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 2, Status: ports.ParkedRouteSwitched}))},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}))},
-		{f: frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 2, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("target frame")}))},
+		{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(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	}}
-	remote.onSend = hybridParkedRequestHandler(parkedRequests, parkedRequestErrors, map[ports.ParkedRouteAction]chan struct{}{
+	remote.onSend = hybridParkedRequestHandler(parkedRequests, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
-		ports.ParkedRoutePrepare: parkSent,
+		protocol.ParkedRoutePrepare: parkSent,
-		ports.ParkedRouteSwitch:  switchSent,
+		protocol.ParkedRouteSwitch:  switchSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
 	deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
 	err := runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	})
 	require.NoError(t, err)
 	}
 	prepareRequest := <-parkedRequests
 	switchRequest := <-parkedRequests
-	require.Equal(t, ports.ParkedRoutePrepare, prepareRequest.Action)
+	require.Equal(t, protocol.ParkedRoutePrepare, prepareRequest.Action)
-	require.Equal(t, ports.ParkedRouteSwitch, switchRequest.Action)
+	require.Equal(t, protocol.ParkedRouteSwitch, switchRequest.Action)
 	require.NotNil(t, switchRequest.Target)
 	require.Equal(t, targetTarget, *switchRequest.Target)
 	frames := remote.Sends()
 		}
 		request, requestErr := ports.UnmarshalParkedRouteRequest(frame.Payload)
 		require.NoError(t, requestErr)
-		if request.Action == ports.ParkedRouteSwitch {
+		if request.Action == protocol.ParkedRouteSwitch {
 			switchIndex = i
 			break
 		}
 	parkedRequestErrors := make(chan error, 1)
 	sourceRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", sourceLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady})), wait: prepareSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: prepareSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 2, Status: ports.ParkedRouteExpired})), wait: switchSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteExpired})), wait: switchSent},
 	}}
-	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[ports.ParkedRouteAction]chan struct{}{
+	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
-		ports.ParkedRoutePrepare: prepareSent,
+		protocol.ParkedRoutePrepare: prepareSent,
-		ports.ParkedRouteSwitch:  switchSent,
+		protocol.ParkedRouteSwitch:  switchSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
 	deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
 	require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	}))
 	select {
 	case requestErr := <-parkedRequestErrors:
 	remote := &recordingTransport{
 		recvs: []recvItem{
 			{f: hybridWelcomeFrame("work", remoteLifecycle)},
-			{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+			{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
 		},
 		stall: remoteClosed,
 	}
-	remote.onSend = hybridParkedRequestHandler(nil, nil, map[ports.ParkedRouteAction]chan struct{}{
+	remote.onSend = hybridParkedRequestHandler(nil, nil, map[protocol.ParkedRouteAction]chan struct{}{
-		ports.ParkedRoutePrepare: prepareSent,
+		protocol.ParkedRoutePrepare: prepareSent,
 	})
 	localDialer := &sequenceDialer{trs: []ports.Transport{localInitial}}
 	result := make(chan error, 1)
 	go func() {
 		result <- runTestClient(ctx, deps, client.AttachRequest{
-			Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+			Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 		})
 	}()
 	select {
 	parkedRequestErrors := make(chan error, 2)
 	remote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("work", remoteLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 2, Status: ports.ParkedRouteResumed})), wait: resumeSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed})), wait: resumeSent},
-		{f: frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 1, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("source frame")}))},
+		{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(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	}}
-	remote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[ports.ParkedRouteAction]chan struct{}{
+	remote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
-		ports.ParkedRoutePrepare: parkSent,
+		protocol.ParkedRoutePrepare: parkSent,
-		ports.ParkedRouteResume:  resumeSent,
+		protocol.ParkedRouteResume:  resumeSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationBack)},
+		{f: navigationDirectiveFrame(protocol.NavigationBack)},
 	}}
 	localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}
 	remoteDialer := &sequenceDialer{trs: []ports.Transport{markedDatagramTransport{Transport: remote}}}
 	deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
 	require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	}))
 	select {
 	case requestErr := <-parkedRequestErrors:
 	defer close(keepSourceOpen)
 	sourceRemote := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("source", sourceLifecycle)},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
-		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady})), wait: parkSent},
+		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
 		{err: io.EOF, wait: keepSourceOpen},
 	}}
-	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[ports.ParkedRouteAction]chan struct{}{
+	sourceRemote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
-		ports.ParkedRoutePrepare: parkSent,
+		protocol.ParkedRoutePrepare: parkSent,
 	})
 	localPicker := &recordingTransport{recvs: []recvItem{
 		{f: hybridWelcomeFrame("local", localLifecycle)},
 	})
 	require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "local", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	}))
 	select {
 	case requestErr := <-parkedRequestErrors:
 			SessionName:  name,
 			ResumeToken:  token,
 			Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{
+			CommittedIdentity: &protocol.CommittedRouteIdentity{
-				Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
+				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 			},
 		}))
 	}
 	}}
 	local2 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("test", localLifecycle, 11)},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(ports.CommittedRouteIdentity{
+		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
-			Target: ports.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
+			Target: protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
 		}))},
-		{f: frameOf(ports.MsgNavigateRecentRoute, mustMarshalRouteAction(ports.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 2}))},
+		{f: frameOf(ports.MsgNavigateRecentRoute, mustMarshalRouteAction(protocol.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 2}))},
 	}}
 	local3 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("test", localLifecycle, 11)},
-		{f: navigationDirectiveFrame(ports.NavigationBack)},
+		{f: navigationDirectiveFrame(protocol.NavigationBack)},
 	}}
 	remote1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("remote-manual", remoteLifecycle, 22)},
-		{f: frameOf(ports.MsgNavigateRecentRoute, mustMarshalRouteAction(ports.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}))},
+		{f: frameOf(ports.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(ports.CommittedRouteIdentity{
+		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
-			Target: ports.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"},
+			Target: protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"},
 		}))},
-		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(ports.RoutePosition{
+		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{
-			Target: ports.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, ActiveTabID: "tab-2",
+			Target: protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, ActiveTabID: "tab-2",
 		}))},
-		{f: navigationDirectiveFrame(ports.NavigationOpenHomePicker)},
+		{f: navigationDirectiveFrame(protocol.NavigationOpenHomePicker)},
 	}}
 	remote3 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("remote-new", remoteNewLifecycle, 22)},
 		require.Equal(t, remoteHandoff, target)
 		return remoteDialer, client.AttachRequest{
 			Intent: ports.IntentAttach, SessionName: target.Session, Remote: true,
-			Origin: ports.RouteOriginDiscovery, OriginKey: target.Endpoint,
+			Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,
 			RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
 		}, nil
 	}
 	err := runTestClient(context.Background(), deps, client.AttachRequest{
-		Intent: ports.IntentAttach, SessionName: "test", Origin: ports.RouteOriginLocal, OriginKey: "local",
+		Intent: ports.IntentAttach, SessionName: "test", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 	})
 	remoteHello := helloFromSend(t, remote2)
 	require.NoError(t, err)
-	require.Equal(t, ports.NavigationCapabilityHomePicker, remoteHello.NavigationCapabilities)
+	require.Equal(t, protocol.NavigationCapabilityHomePicker, remoteHello.NavigationCapabilities)
 	remoteNewHello := helloFromSend(t, remote3)
 	require.Equal(t, "remote-new", remoteNewHello.Name)
-	require.Equal(t, &ports.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, remoteNewHello.ExactTarget)
+	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: remoteNewLifecycle, SessionName: "remote-new"}, remoteNewHello.ExactTarget)
 }
-func navigationDirectiveFrame(action ports.NavigationAction) ports.Frame {
+func navigationDirectiveFrame(action protocol.NavigationAction) ports.Frame {
-	directive := ports.NavigationDirective{Action: action}
+	directive := protocol.NavigationDirective{Action: action}
-	if action == ports.NavigationOpenHomePicker {
+	if action == protocol.NavigationOpenHomePicker {
-		directive.LeaseID = ports.ParkedRouteLeaseID{1}
+		directive.LeaseID = protocol.ParkedRouteLeaseID{1}
 	}
 	return frameOf(ports.MsgNavigationAction, ports.MarshalNavigationDirective(directive))
 }
-func mustMarshalCommittedIdentity(identity ports.CommittedRouteIdentity) []byte {
+func mustMarshalCommittedIdentity(identity protocol.CommittedRouteIdentity) []byte {
 	payload, err := ports.MarshalCommittedRouteIdentity(identity)
 	if err != nil {
 		panic(err)
 	return payload
 }
-func mustMarshalRouteAction(action ports.RouteNavigationAction) []byte {
+func mustMarshalRouteAction(action protocol.RouteNavigationAction) []byte {
 	payload, err := ports.MarshalRouteNavigationAction(action)
 	if err != nil {
 		panic(err)
 	return payload
 }
-func mustMarshalRoutePosition(position ports.RoutePosition) []byte {
+func mustMarshalRoutePosition(position protocol.RoutePosition) []byte {
 	payload, err := ports.MarshalRoutePosition(position)
 	if err != nil {
 		panic(err)
 	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
 	unblock := scriptRecv(tr,
 		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1", SessionName: "main"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},
+		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},
 		recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	)
 	defer unblock()
 	tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
 	tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
 	// The resize frame is forwarded via the sender goroutine.
-	gotResize := make(chan ports.Resize, 1)
+	gotResize := make(chan protocol.Resize, 1)
 	tr.EXPECT().Send(isType(ports.MsgResize)).RunAndReturn(func(f ports.Frame) error {
 		r, _ := ports.UnmarshalResize(f.Payload)
 		gotResize <- r
 	term := newRunTerminal()
 	defer term.in.unblock()
 	lifecycle := domain.SessionLifecycleID{7, 8, 9}
-	target := ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
+	target := protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
 	welcome := func(token uint64) ports.Frame {
 		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID: "work", SessionName: "work", ResumeToken: token, Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{Target: target},
+			CommittedIdentity: &protocol.CommittedRouteIdentity{Target: target},
 		}))
 	}
 	tr1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome(11)},
-		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(ports.RoutePosition{Target: target, ActiveTabID: "tab-2"}))},
+		{f: frameOf(ports.MsgRoutePosition, mustMarshalRoutePosition(protocol.RoutePosition{Target: target, ActiveTabID: "tab-2"}))},
 		{err: io.EOF},
 	}}
 	tr2 := &recordingTransport{recvs: []recvItem{
 	result := make(chan error, 1)
 	go func() {
 		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{
-			Intent: ports.IntentAttach, SessionName: "work", Origin: ports.RouteOriginLocal, OriginKey: "local",
+			Intent: ports.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local",
 		})
 	}()
 	clock.fireReconnect(t)
 	welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {
 		return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{
 			SessionID: name, SessionName: name, ResumeToken: token, Capabilities: ports.CapabilityResume,
-			CommittedIdentity: &ports.CommittedRouteIdentity{
+			CommittedIdentity: &protocol.CommittedRouteIdentity{
-				Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
+				Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
 			},
 		}))
 	}
 	tr1 := &recordingTransport{recvs: []recvItem{
 		{f: welcome("old", oldLifecycle, 11)},
-		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(ports.CommittedRouteIdentity{
+		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{
-			Target: ports.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
+			Target: protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"},
 		}))},
 		{err: io.EOF},
 	}}
 	go func() {
 		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{
 			Intent: ports.IntentAttach, SessionName: "old", Remote: true,
-			Origin: ports.RouteOriginDiscovery, OriginKey: "remote",
+			Origin: protocol.RouteOriginDiscovery, OriginKey: "remote",
 			RemoteTarget: remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
 		})
 	}()
 	reconnectHello := helloFromSend(t, tr2)
 	require.Equal(t, ports.IntentResume, reconnectHello.Intent)
 	require.Equal(t, "new", reconnectHello.Name)
-	require.Equal(t, &ports.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"}, reconnectHello.ExactTarget)
+	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"}, reconnectHello.ExactTarget)
 	require.Nil(t, reconnectHello.RemoteTarget)
 }

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // ciFakeReader is a directly-controllable ports.ClipboardReader for
 	return r.mime, r.data, r.err
 }
-func newTestClipboardIntercept(reader ports.ClipboardReader) (*clipboardIntercept, *pasteCoalescer, *pcFakeClock, *pcCollector, *[]ports.ImagePush) {
+func newTestClipboardIntercept(reader ports.ClipboardReader) (*clipboardIntercept, *pasteCoalescer, *pcFakeClock, *pcCollector, *[]protocol.ImagePush) {
 	clk := &pcFakeClock{}
 	col := &pcCollector{}
 	pc := newPasteCoalescer(clk, col.emit)
-	var images []ports.ImagePush
+	var images []protocol.ImagePush
 	ci := &clipboardIntercept{
 		coalescer: pc,
 		reader:    reader,
 		log:       slog.New(slog.NewTextHandler(nil, &slog.HandlerOptions{Level: slog.LevelError + 1})),
 		sendImage: func(mime string, data []byte) {
-			images = append(images, ports.ImagePush{Mime: mime, Data: data})
+			images = append(images, protocol.ImagePush{Mime: mime, Data: data})
 		},
 		next: pc.Scan,
 	}
 	ci.Scan([]byte("b"))
 	require.Equal(t, 1, reader.n, "clipboard must be read exactly once per Ctrl+V")
-	require.Equal(t, []ports.ImagePush{{Mime: "image/png", Data: []byte("PNGDATA")}}, *images)
+	require.Equal(t, []protocol.ImagePush{{Mime: "image/png", Data: []byte("PNGDATA")}}, *images)
 	require.Equal(t, [][]byte{[]byte("a"), []byte("b")}, col.snapshot(), "0x16 itself must never reach the coalescer/pane")
 }

M internal/usecase/client/clipboard_intercept_test.go +4 -3

 	"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/usecase/client"
 )
 // transport that captures every MsgInput/MsgImagePush send, and a Recv that
 // answers Welcome then, once triggered, Detached — mirroring the pattern used
 // by the OSC-color-response test elsewhere in this package.
-func runRemoteClipboardTest(t *testing.T, remote bool, clip ports.ClipboardReader, stdin []byte, triggerByte byte) (gotInput chan []byte, gotImage chan ports.ImagePush) {
+func runRemoteClipboardTest(t *testing.T, remote bool, clip ports.ClipboardReader, stdin []byte, triggerByte byte) (gotInput chan []byte, gotImage chan protocol.ImagePush) {
 	t.Helper()
 	var out bytes.Buffer
 	var restoreCount int32
 	tm.EXPECT().ResizeEvents().Return(resizeCh).Maybe()
 	gotInput = make(chan []byte, 8)
-	gotImage = make(chan ports.ImagePush, 1)
+	gotImage = make(chan protocol.ImagePush, 1)
 	allowDetach := make(chan struct{})
 	tr := portsmocks.NewMockTransport(t)
 		}
 	}
 	beforeOutput := out.String()
-	transport.recv <- frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 1, Base: 0, New: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("incremental")}))
+	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(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))
 	select {

M internal/usecase/client/navigation_test.go +7 -6

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 		valid   bool
 	}{
 		{name: "ordinary route", request: AttachRequest{}, valid: true},
-		{name: "home picker without remote route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", NavigationCapabilities: ports.NavigationCapabilityHomePicker}, valid: false},
+		{name: "home picker without remote route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", NavigationCapabilities: protocol.NavigationCapabilityHomePicker}, valid: false},
-		{name: "home picker on daemon-owned remote route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", Remote: true, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, NavigationCapabilities: ports.NavigationCapabilityHomePicker}, valid: true},
+		{name: "home picker on daemon-owned remote route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", Remote: true, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}, valid: true},
-		{name: "back on client-owned route", request: AttachRequest{StartupOverlay: ports.StartupOverlaySessionPicker, NavigationCapabilities: ports.NavigationCapabilityBack}, valid: true},
+		{name: "back on client-owned route", request: AttachRequest{StartupOverlay: protocol.StartupOverlaySessionPicker, NavigationCapabilities: protocol.NavigationCapabilityBack}, valid: true},
-		{name: "back on remote-target route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", RemoteTarget: remoteRoute, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, StartupOverlay: ports.StartupOverlaySessionPicker, NavigationCapabilities: ports.NavigationCapabilityBack}, valid: false},
+		{name: "back on remote-target route", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "work", RemoteTarget: remoteRoute, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, StartupOverlay: protocol.StartupOverlaySessionPicker, NavigationCapabilities: protocol.NavigationCapabilityBack}, valid: false},
 		{name: "unknown capability", request: AttachRequest{NavigationCapabilities: 4}, valid: false},
-		{name: "back without startup picker", request: AttachRequest{NavigationCapabilities: ports.NavigationCapabilityBack}, valid: false},
+		{name: "back without startup picker", request: AttachRequest{NavigationCapabilities: protocol.NavigationCapabilityBack}, valid: false},
-		{name: "startup picker without back", request: AttachRequest{StartupOverlay: ports.StartupOverlaySessionPicker}, valid: false},
+		{name: "startup picker without back", request: AttachRequest{StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: false},
 	}
 	for _, tt := range tests {

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

@@ -1,6 +1,6 @@
1		package client	1		package client
2			2
3	-	import "github.com/bnema/vev/internal/ports"	3	+	import "github.com/bnema/vev/internal/protocol"
4			4
5		// outputApplyState is the client-side dependency chain for one attachment.	5		// outputApplyState is the client-side dependency chain for one attachment.
6		// State-bearing frames are accepted only when their epoch, base, and view	6		// State-bearing frames are accepted only when their epoch, base, and view

@@ -12,7 +12,7 @@ type outputApplyState struct {
12		initialized bool	12		initialized bool
13		}	13		}
14			14
15	-	func (s outputApplyState) next(output ports.Output) (outputApplyState, bool) {	15	+	func (s outputApplyState) next(output protocol.Output) (outputApplyState, bool) {
16		if output.Epoch == 0 {	16		if output.Epoch == 0 {
17		return outputApplyState{}, false	17		return outputApplyState{}, false
18		}	18		}

M internal/usecase/client/output_state_test.go +12 -12


@@ -4,28 +4,28 @@ import (
4		"testing"	4		"testing"
5			5
6		"github.com/bnema/vev/internal/domain"	6		"github.com/bnema/vev/internal/domain"
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol"
8		)	8		)
9			9
10		func TestOutputApplyStateTransitions(t *testing.T) {	10		func TestOutputApplyStateTransitions(t *testing.T) {
11	-	full := ports.Output{Epoch: 1, Base: 0, New: 1, Full: true, ViewRevision: 2, Size: domain.Size{Cols: 80, Rows: 24}}	11	+	full := protocol.Output{Epoch: 1, Base: 0, New: 1, Full: true, ViewRevision: 2, Size: domain.Size{Cols: 80, Rows: 24}}
12		tests := []struct {	12		tests := []struct {
13		name string	13		name string
14		state outputApplyState	14		state outputApplyState
15	-	output ports.Output	15	+	output protocol.Output
16		accepted bool	16		accepted bool
17		want outputApplyState	17		want outputApplyState
18		}{	18		}{
19		{name: "first full", output: full, accepted: true, want: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}},	19		{name: "first full", output: full, accepted: true, want: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}},
20	-	{name: "first gap", output: ports.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 2}, accepted: false},	20	+	{name: "first gap", output: protocol.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 2}, accepted: false},
21	-	{name: "increment", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 2}, accepted: true, want: outputApplyState{epoch: 1, state: 2, viewRevision: 2, initialized: true}},	21	+	{name: "increment", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 2}, accepted: true, want: outputApplyState{epoch: 1, state: 2, viewRevision: 2, initialized: true}},
22	-	{name: "base gap", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 1, Base: 0, New: 2, Full: true, ViewRevision: 2}, accepted: false},	22	+	{name: "base gap", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 1, Base: 0, New: 2, Full: true, ViewRevision: 2}, accepted: false},
23	-	{name: "revision gap", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 3}, accepted: false},	23	+	{name: "revision gap", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 3}, accepted: false},
24	-	{name: "handoff side effect crosses newer epoch replay gate", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 2, ViewRevision: 3}, accepted: true, want: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}},	24	+	{name: "handoff side effect crosses newer epoch replay gate", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 2, ViewRevision: 3}, accepted: true, want: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}},
25	-	{name: "handoff side effect crosses stale epoch replay gate", state: outputApplyState{epoch: 2, state: 4, viewRevision: 5, initialized: true}, output: ports.Output{Epoch: 1, ViewRevision: 2}, accepted: true, want: outputApplyState{epoch: 2, state: 4, viewRevision: 5, initialized: true}},	25	+	{name: "handoff side effect crosses stale epoch replay gate", state: outputApplyState{epoch: 2, state: 4, viewRevision: 5, initialized: true}, output: protocol.Output{Epoch: 1, ViewRevision: 2}, accepted: true, want: outputApplyState{epoch: 2, state: 4, viewRevision: 5, initialized: true}},
26	-	{name: "side effect cannot invent state", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 2, Base: 1}, accepted: false},	26	+	{name: "side effect cannot invent state", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 2, Base: 1}, accepted: false},
27	-	{name: "side effect cannot claim full replay", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 2, Full: true}, accepted: false},	27	+	{name: "side effect cannot claim full replay", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 2, Full: true}, accepted: false},
28	-	{name: "new epoch reset", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: ports.Output{Epoch: 2, Base: 0, New: 1, Full: true, ViewRevision: 3}, accepted: true, want: outputApplyState{epoch: 2, state: 1, viewRevision: 3, initialized: true}},	28	+	{name: "new epoch reset", state: outputApplyState{epoch: 1, state: 1, viewRevision: 2, initialized: true}, output: protocol.Output{Epoch: 2, Base: 0, New: 1, Full: true, ViewRevision: 3}, accepted: true, want: outputApplyState{epoch: 2, state: 1, viewRevision: 3, initialized: true}},
29		}	29		}
30		for _, tt := range tests {	30		for _, tt := range tests {
31		t.Run(tt.name, func(t *testing.T) {	31		t.Run(tt.name, func(t *testing.T) {

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

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // attachPaletteClock deliberately exposes each independently-created timer.
 type attachPaletteTransport struct {
 	mu           sync.Mutex
 	frames       []ports.Frame
-	themes       []ports.Theme
+	themes       []protocol.Theme
-	themeCh      chan ports.Theme
+	themeCh      chan protocol.Theme
 	inputCh      chan ports.Input
 	detached     chan ports.Frame
 	themeSendErr error
 func newAttachPaletteTransport() *attachPaletteTransport {
 	return &attachPaletteTransport{
-		themeCh:  make(chan ports.Theme, 16),
+		themeCh:  make(chan protocol.Theme, 16),
 		inputCh:  make(chan ports.Input, 16),
 		detached: make(chan ports.Frame, 1),
 	}
 	return <-t.detached, nil
 }
 func (*attachPaletteTransport) Close() error { return nil }
-func (t *attachPaletteTransport) snapshots() []ports.Theme {
+func (t *attachPaletteTransport) snapshots() []protocol.Theme {
 	t.mu.Lock()
 	defer t.mu.Unlock()
-	return append([]ports.Theme(nil), t.themes...)
+	return append([]protocol.Theme(nil), t.themes...)
 }
 type attachPaletteHarness struct {
 	t.Helper()
 	return <-h.writer.wrote
 }
-func (h *attachPaletteHarness) nextTheme(t *testing.T) ports.Theme {
+func (h *attachPaletteHarness) nextTheme(t *testing.T) protocol.Theme {
 	t.Helper()
 	return <-h.transport.themeCh
 }
 	defer cancel()
 	coordinator := newPaletteGenerationCoordinator()
-	coordinator.start(ports.Theme{}, false)
+	coordinator.start(protocol.Theme{}, false)
 	var activeGeneration atomic.Uint64
 	activeGeneration.Store(uint64(coordinator.current.id))
 	// This models attachAttempt handling the scheme event. The replacement is
 	// draining, so a marker tagged with its ID would incorrectly start its
 	// color batch before the real drain boundary arrives.
-	coordinator.start(ports.Theme{SchemeKnown: true, Light: scheme.light}, true)
+	coordinator.start(protocol.Theme{SchemeKnown: true, Light: scheme.light}, true)
 	newID := coordinator.current.id
 	activeGeneration.Store(uint64(newID))
 	close(schemeHandled)

M internal/usecase/client/palette_attach_test.go +2 -1

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type paletteAttachClock struct{}
 type paletteAttachTransport struct {
 	mu       sync.Mutex
 	sent     []ports.Frame
-	themes   []ports.Theme
+	themes   []protocol.Theme
 	finals   int
 	finalSet chan struct{}
 }

M internal/usecase/client/palette_generation.go +7 -7


@@ -4,7 +4,7 @@ import (
4		"time"	4		"time"
5			5
6		renderer "github.com/bnema/vev-vt"	6		renderer "github.com/bnema/vev-vt"
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol"
8		)	8		)
9			9
10		// Palette queries always have a DECRQM boundary. The first marker drains	10		// Palette queries always have a DECRQM boundary. The first marker drains

@@ -38,7 +38,7 @@ const (
38		type paletteGeneration struct {	38		type paletteGeneration struct {
39		id paletteGenerationID	39		id paletteGenerationID
40		phase paletteGenerationPhase	40		phase paletteGenerationPhase
41	-	theme ports.Theme	41	+	theme protocol.Theme
42		expectedMarkers int	42		expectedMarkers int
43		awaitingLateDrainBoundary bool	43		awaitingLateDrainBoundary bool
44		}	44		}

@@ -83,7 +83,7 @@ type paletteGenerationAction struct {
83		kind paletteGenerationActionKind	83		kind paletteGenerationActionKind
84		id paletteGenerationID	84		id paletteGenerationID
85		bytes string	85		bytes string
86	-	theme ports.Theme	86	+	theme protocol.Theme
87		deadline time.Duration	87		deadline time.Duration
88		}	88		}
89			89

@@ -93,7 +93,7 @@ type paletteGenerationCoordinator struct {
93		next paletteGenerationID	93		next paletteGenerationID
94		current paletteGeneration	94		current paletteGeneration
95		active bool	95		active bool
96	-	finalized ports.Theme	96	+	finalized protocol.Theme
97		}	97		}
98			98
99		func newPaletteGenerationCoordinator() *paletteGenerationCoordinator {	99		func newPaletteGenerationCoordinator() *paletteGenerationCoordinator {

@@ -104,7 +104,7 @@ func newPaletteGenerationCoordinator() *paletteGenerationCoordinator {
104		// batch or a replacement drain. The retained foreground/background and	104		// batch or a replacement drain. The retained foreground/background and
105		// capability avoid a full neutral flash, while the accumulator begins with no	105		// capability avoid a full neutral flash, while the accumulator begins with no
106		// defaults or palette values so a definitive result never mixes generations.	106		// defaults or palette values so a definitive result never mixes generations.
107	-	func (c *paletteGenerationCoordinator) start(retained ports.Theme, replacement bool) []paletteGenerationAction {	107	+	func (c *paletteGenerationCoordinator) start(retained protocol.Theme, replacement bool) []paletteGenerationAction {
108		actions := c.cancelCurrent()	108		actions := c.cancelCurrent()
109		c.next++	109		c.next++
110		id := c.next	110		id := c.next

@@ -115,7 +115,7 @@ func (c *paletteGenerationCoordinator) start(retained ports.Theme, replacement b
115		c.current = paletteGeneration{	115		c.current = paletteGeneration{
116		id: id,	116		id: id,
117		phase: generationCollecting,	117		phase: generationCollecting,
118	-	theme: ports.Theme{	118	+	theme: protocol.Theme{
119		TrueColor: retained.TrueColor,	119		TrueColor: retained.TrueColor,
120		SchemeKnown: retained.SchemeKnown,	120		SchemeKnown: retained.SchemeKnown,
121		Light: retained.Light,	121		Light: retained.Light,

@@ -250,7 +250,7 @@ func (c *paletteGenerationCoordinator) palette(id paletteGenerationID, slot uint
250		c.handle(paletteGenerationEvent{id: id, kind: paletteEventPalette, slot: slot, rgb: rgb})	250		c.handle(paletteGenerationEvent{id: id, kind: paletteEventPalette, slot: slot, rgb: rgb})
251		}	251		}
252			252
253	-	func (c *paletteGenerationCoordinator) finalizedTheme() ports.Theme { return c.finalized }	253	+	func (c *paletteGenerationCoordinator) finalizedTheme() protocol.Theme { return c.finalized }
254			254
255		// paletteMarkerScanner consumes only complete DECRQM 2031 replies and retains	255		// paletteMarkerScanner consumes only complete DECRQM 2031 replies and retains
256		// possible prefixes across reads, forwarding all ordinary input exactly once.	256		// possible prefixes across reads, forwarding all ordinary input exactly once.

M internal/usecase/client/palette_generation_test.go +3 -3


@@ -7,7 +7,7 @@ import (
7		"github.com/stretchr/testify/require"	7		"github.com/stretchr/testify/require"
8			8
9		renderer "github.com/bnema/vev-vt"	9		renderer "github.com/bnema/vev-vt"
10	-	"github.com/bnema/vev/internal/ports"	10	+	"github.com/bnema/vev/internal/protocol"
11		)	11		)
12			12
13		// manualPaletteClock applies only declarative coordinator timer actions. Its	13		// manualPaletteClock applies only declarative coordinator timer actions. Its

@@ -52,8 +52,8 @@ func (c manualPaletteClock) fireCompletion(g paletteGenerationCoordinator, id
52		return g.handle(paletteGenerationEvent{id: id, kind: paletteEventCompletionDeadline})	52		return g.handle(paletteGenerationEvent{id: id, kind: paletteEventCompletionDeadline})
53		}	53		}
54			54
55	-	func generationTheme() ports.Theme {	55	+	func generationTheme() protocol.Theme {
56	-	return ports.Theme{	56	+	return protocol.Theme{
57		TrueColor: true,	57		TrueColor: true,
58		HasForeground: true,	58		HasForeground: true,
59		Foreground: renderer.RGB{R: 1, G: 2, B: 3},	59		Foreground: renderer.RGB{R: 1, G: 2, B: 3},

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

 	"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"
 )
 type reconnectToastTerminalHarness struct {
 	require.Contains(t, firstToast, "┌")
 	require.Contains(t, firstToast, "probing UDP path")
-	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  4,
 		New:   5,
 	require.NotContains(t, out.String(), offlineMessage)
 	beforeReset := out.String()
-	for _, output := range []ports.Output{
+	for _, output := range []protocol.Output{
 		{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")},
 	} {
 	// 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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Size:  domain.Size{Cols: 1, Rows: 1},
 		Data:  []byte("handoff graphics cleanup"),
 	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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 		Epoch: 2,
 		Base:  4,
 		New:   5,
 	}
 }
-func requireResize(t *testing.T, sends *reconnectToastSentFrames) ports.Resize {
+func requireResize(t *testing.T, sends *reconnectToastSentFrames) protocol.Resize {
 	t.Helper()
 	frame := requireSentFrame(t, sends, "Resize frame", func(frame ports.Frame) bool {
 		return frame.Type == ports.MsgResize
 	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(ports.Output{
+	tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.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(ports.Output{
+			tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 				Epoch: 1,
 				Base:  0,
 				New:   2,
 			tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}
 			requireReconnectToastOutput(t, out.completed)
 			arm()
-			tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(ports.Output{
+			tr.recvCh <- reconnectToastRecv{frame: ports.Frame{Type: ports.MsgOutput, Payload: mustMarshalOutput(protocol.Output{
 				Epoch: 1,
 				Base:  0,
 				New:   2,

M internal/usecase/client/remote_attach_validation_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"
 )
 func TestMalformedAttachRequestsNeverDial(t *testing.T) {
 		{name: "missing session name", request: AttachRequest{Intent: ports.IntentAttach}},
 		{name: "unsafe session name", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "bad name"}},
 		{name: "daemon-owned without remote", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "main", EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}},
-		{name: "ephemeral with navigation capability", request: AttachRequest{Intent: ports.IntentEphemeral, NavigationCapabilities: ports.NavigationCapabilityHomePicker}},
+		{name: "ephemeral with navigation capability", request: AttachRequest{Intent: ports.IntentEphemeral, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

M internal/usecase/client/routes.go +58 -57

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // maxRouteLedgerEntries is the product history cap. It is deliberately
 func (i routeIdentity) empty() bool { return i.key == 0 && i.generation == 0 }
-func (i routeIdentity) wire() ports.RouteRef {
+func (i routeIdentity) wire() protocol.RouteRef {
-	return ports.RouteRef{Key: uint64(i.key), Generation: uint64(i.generation)}
+	return protocol.RouteRef{Key: uint64(i.key), Generation: uint64(i.generation)}
 }
-func identityFromWire(ref ports.RouteRef) routeIdentity {
+func identityFromWire(ref protocol.RouteRef) routeIdentity {
 	return routeIdentity{key: routeKey(ref.Key), generation: routeGeneration(ref.Generation)}
 }
 type routePresentation struct {
 	name         string
 	hostLabel    string
-	kind         ports.RouteKind
+	kind         protocol.RouteKind
 	ephemeral    bool
 	attention    bool
-	reachability ports.RouteReachability
+	reachability protocol.RouteReachability
 }
 type routeCandidate struct {
-	origin       ports.RouteOrigin
+	origin       protocol.RouteOrigin
 	originKey    string
-	target       ports.ExactSessionTarget
+	target       protocol.ExactSessionTarget
 	presentation routePresentation
 	dialer       ports.Dialer
 	request      AttachRequest
 type routeRecord struct {
 	identity     routeIdentity
-	origin       ports.RouteOrigin
+	origin       protocol.RouteOrigin
 	originKey    string
-	target       ports.ExactSessionTarget
+	target       protocol.ExactSessionTarget
 	presentation routePresentation
 	dialer       ports.Dialer
 	request      AttachRequest
 func newRouteLedger() *routeLedger { return &routeLedger{} }
-func cloneCommittedIdentity(identity *ports.CommittedRouteIdentity) *ports.CommittedRouteIdentity {
+func cloneCommittedIdentity(identity *protocol.CommittedRouteIdentity) *protocol.CommittedRouteIdentity {
 	if identity == nil {
 		return nil
 	}
 	return &clone
 }
-func cloneRoutePosition(position *ports.RoutePosition) *ports.RoutePosition {
+func cloneRoutePosition(position *protocol.RoutePosition) *protocol.RoutePosition {
 	if position == nil {
 		return nil
 	}
 	return &clone
 }
-func routeCandidateForAttach(request AttachRequest, identity ports.CommittedRouteIdentity, dialer ports.Dialer, resumeToken uint64) routeCandidate {
+func routeCandidateForAttach(request AttachRequest, identity protocol.CommittedRouteIdentity, dialer ports.Dialer, resumeToken uint64) routeCandidate {
 	origin := normalizeRouteOrigin(request.Origin, request.Remote)
 	originKey := normalizeRouteOriginKey(request.OriginKey, origin)
-	kind := ports.RouteKindLocal
+	kind := protocol.RouteKindLocal
 	hostLabel := ""
-	if request.Remote || request.RemoteTarget != nil || origin != ports.RouteOriginLocal {
+	if request.Remote || request.RemoteTarget != nil || origin != protocol.RouteOriginLocal {
-		kind = ports.RouteKindRemote
+		kind = protocol.RouteKindRemote
 		if request.RemoteTarget != nil {
 			hostLabel = domain.RemoteDisplayOrigin(request.RemoteTarget.DisplayOrigin)
 		}
 			hostLabel:    hostLabel,
 			kind:         kind,
 			ephemeral:    identity.Ephemeral,
-			reachability: ports.RouteReachabilityReachable,
+			reachability: protocol.RouteReachabilityReachable,
 		},
 		dialer:      dialer,
 		request:     request,
 	}
 }
-func routeCandidateForCommittedIdentity(active routeRecord, identity ports.CommittedRouteIdentity) routeCandidate {
+func routeCandidateForCommittedIdentity(active routeRecord, identity protocol.CommittedRouteIdentity) routeCandidate {
 	request := cloneAttachRequest(active.request)
 	request.SessionName = identity.Target.SessionName
 	request.ExactTarget = &identity.Target
 			hostLabel:    active.presentation.hostLabel,
 			kind:         active.presentation.kind,
 			ephemeral:    identity.Ephemeral,
-			reachability: ports.RouteReachabilityReachable,
+			reachability: protocol.RouteReachabilityReachable,
 		},
 		dialer:      active.dialer,
 		request:     request,
 	}
 }
-func normalizeRouteOrigin(origin ports.RouteOrigin, remote bool) ports.RouteOrigin {
+func normalizeRouteOrigin(origin protocol.RouteOrigin, remote bool) protocol.RouteOrigin {
 	if origin != 0 {
 		return origin
 	}
 	if remote {
-		return ports.RouteOriginRemote
+		return protocol.RouteOriginRemote
 	}
-	return ports.RouteOriginLocal
+	return protocol.RouteOriginLocal
 }
-func routeFailureCode(err error) ports.RouteFailureCode {
+func routeFailureCode(err error) protocol.RouteFailureCode {
 	var protocolErr *ProtocolError
 	if errors.As(err, &protocolErr) {
 		switch protocolErr.Code {
 		case ports.ErrNoSuchSession, ports.ErrNoSuchTarget:
-			return ports.RouteFailureNoSuchRoute
+			return protocol.RouteFailureNoSuchRoute
 		}
 	}
 	if errors.Is(err, errRouteTargetChanged) {
-		return ports.RouteFailureTargetChanged
+		return protocol.RouteFailureTargetChanged
 	}
-	return ports.RouteFailureUnavailable
+	return protocol.RouteFailureUnavailable
 }
-func normalizeRouteOriginKey(key string, origin ports.RouteOrigin) string {
+func normalizeRouteOriginKey(key string, origin protocol.RouteOrigin) string {
 	if key != "" {
 		return key
 	}
 	switch origin {
-	case ports.RouteOriginLocal:
+	case protocol.RouteOriginLocal:
 		return "local"
-	case ports.RouteOriginDiscovery:
+	case protocol.RouteOriginDiscovery:
 		return "discovery"
 	default:
 		return "remote"
 }
 func validateRoutePresentation(p routePresentation) error {
-	if err := ports.ValidateRouteLabel(p.name, false); err != nil {
+	if err := protocol.ValidateRouteLabel(p.name, false); err != nil {
 		return err
 	}
-	if err := ports.ValidateRouteLabel(p.hostLabel, true); err != nil {
+	if err := protocol.ValidateRouteLabel(p.hostLabel, true); err != nil {
 		return err
 	}
 	if err := p.kind.Validate(); err != nil {
 	return routeIdentity{key: l.nextKey, generation: l.generation}, nil
 }
-func (l *routeLedger) findByTargetLocked(origin ports.RouteOrigin, originKey string, target ports.ExactSessionTarget) int {
+func (l *routeLedger) findByTargetLocked(origin protocol.RouteOrigin, originKey string, target protocol.ExactSessionTarget) int {
 	for i := range l.entries {
 		entry := l.entries[i]
 		if entry.origin == origin && entry.originKey == originKey && entry.target == target {
 // commitCommittedIdentity snapshots the current active record and commits the
 // daemon's local transition under one lock. The active route, origin, dialer,
 // and attach request cannot be read from different ledger generations.
-func (l *routeLedger) commitCommittedIdentity(identity ports.CommittedRouteIdentity) (routeIdentity, error) {
+func (l *routeLedger) commitCommittedIdentity(identity protocol.CommittedRouteIdentity) (routeIdentity, error) {
 	if err := identity.Validate(); err != nil {
 		return routeIdentity{}, err
 	}
 // updateRoutePosition remembers a cursor only for the currently active exact
 // route. Delayed frames from a prior transition are valid wire messages but do
 // not mutate another route.
-func (l *routeLedger) updateRoutePosition(position ports.RoutePosition) error {
+func (l *routeLedger) updateRoutePosition(position protocol.RoutePosition) error {
 	if err := position.Validate(); err != nil {
 		return err
 	}
 	return -1
 }
-func (l *routeLedger) lookup(ref ports.RouteRef) (routeRecord, bool) {
+func (l *routeLedger) lookup(ref protocol.RouteRef) (routeRecord, bool) {
 	identity := identityFromWire(ref)
 	if identity.empty() {
 		return routeRecord{}, false
 // attentionSubscription publishes only routes served by the active route's
 // daemon. Other route origins remain private to their owning daemon.
-func (l *routeLedger) attentionSubscription() ports.RouteAttentionSubscription {
+func (l *routeLedger) attentionSubscription() protocol.RouteAttentionSubscription {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	activeIndex := l.indexByIdentityLocked(l.active)
 	if activeIndex < 0 {
-		return ports.RouteAttentionSubscription{}
+		return protocol.RouteAttentionSubscription{}
 	}
 	active := l.entries[activeIndex]
-	subscription := ports.RouteAttentionSubscription{Targets: make([]ports.RouteAttentionTarget, 0, len(l.entries))}
+	subscription := protocol.RouteAttentionSubscription{Targets: make([]protocol.RouteAttentionTarget, 0, len(l.entries))}
 	for _, entry := range l.entries {
 		if entry.identity == active.identity || entry.origin != active.origin || entry.originKey != active.originKey {
 			continue
 		}
-		subscription.Targets = append(subscription.Targets, ports.RouteAttentionTarget{
+		subscription.Targets = append(subscription.Targets, protocol.RouteAttentionTarget{
 			Ref:    entry.identity.wire(),
 			Target: entry.target,
 		})
 	return subscription
 }
-func (r routeRecord) snapshotEntry() ports.RecentRouteEntry {
+func (r routeRecord) snapshotEntry() protocol.RecentRouteEntry {
-	return ports.RecentRouteEntry{
+	return protocol.RecentRouteEntry{
 		Key:          uint64(r.identity.key),
 		Generation:   uint64(r.identity.generation),
 		Target:       r.target,
 	}
 }
-func (l *routeLedger) snapshot() ports.RecentRouteSnapshot {
+func (l *routeLedger) snapshot() protocol.RecentRouteSnapshot {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation: uint64(l.generation),
 		Active:     l.active.wire(),
 		Previous:   l.previous.wire(),
 	if len(l.entries) == 0 {
 		return snapshot
 	}
-	snapshot.Entries = make([]ports.RecentRouteEntry, 0, len(l.entries))
+	snapshot.Entries = make([]protocol.RecentRouteEntry, 0, len(l.entries))
 	for _, entry := range l.entries {
 		if entry.identity == l.active {
 			snapshot.ActiveEntry = entry.snapshotEntry()
 	origin := normalizeRouteOrigin(active.Origin, active.Remote)
 	originKey := normalizeRouteOriginKey(active.OriginKey, origin)
 	environmentPolicy := target.EnvironmentPolicy
-	if origin == ports.RouteOriginLocal {
+	if origin == protocol.RouteOriginLocal {
 		environmentPolicy = ports.EnvironmentPolicyClientOwned
 	}
 		request.RemoteTarget = nil
 		if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == ports.EnvironmentPolicyClientOwned {
 			request.NavigationCapabilities = 0
-			request.StartupOverlay = ports.StartupOverlayNone
+			request.StartupOverlay = protocol.StartupOverlayNone
 		}
 		request.EnvironmentPolicy = environmentPolicy
 		request.ExactTarget = target.ExactTarget
 	request.RemoteTarget = nil
 	if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == ports.EnvironmentPolicyClientOwned {
 		request.NavigationCapabilities = 0
-		request.StartupOverlay = ports.StartupOverlayNone
+		request.StartupOverlay = protocol.StartupOverlayNone
 	}
 	request.EnvironmentPolicy = environmentPolicy
 	return request
 }
-func (l *routeLedger) activeRef() ports.RouteRef {
+func (l *routeLedger) activeRef() protocol.RouteRef {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	return l.active.wire()
 }
-func (l *routeLedger) previousRef() ports.RouteRef {
+func (l *routeLedger) previousRef() protocol.RouteRef {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	return l.previous.wire()
 }
-func (l *routeLedger) homeRef() ports.RouteRef {
+func (l *routeLedger) homeRef() protocol.RouteRef {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	return l.home.wire()
 	record             routeRecord
 	snapshotGeneration routeGeneration
 	active             routeIdentity
-	origin             ports.RouteOrigin
+	origin             protocol.RouteOrigin
 	originKey          string
-	target             ports.ExactSessionTarget
+	target             protocol.ExactSessionTarget
 }
 type routeTransitionCommit struct {
-	identity     ports.CommittedRouteIdentity
+	identity     protocol.CommittedRouteIdentity
 	presentation routePresentation
 	dialer       ports.Dialer
 	resumeToken  uint64
 // generation, and active identity under one read lock. The commit phase uses
 // the captured generation and active identity to reject interleavings that
 // changed the ledger while dialing.
-func (l *routeLedger) navigationSelection(action ports.RouteNavigationAction) (routeNavigationSelection, bool) {
+func (l *routeLedger) navigationSelection(action protocol.RouteNavigationAction) (routeNavigationSelection, bool) {
 	if action.SnapshotGeneration == 0 || action.Key == 0 || action.Generation == 0 {
 		return routeNavigationSelection{}, false
 	}
-	identity := identityFromWire(ports.RouteRef{Key: action.Key, Generation: action.Generation})
+	identity := identityFromWire(protocol.RouteRef{Key: action.Key, Generation: action.Generation})
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	if uint64(l.generation) != action.SnapshotGeneration {
 // navigationRecord validates that an action belongs to the latest complete
 // snapshot. The active route is metadata-only and selecting it is a no-op.
-func (l *routeLedger) navigationRecord(action ports.RouteNavigationAction) (routeRecord, bool, bool) {
+func (l *routeLedger) navigationRecord(action protocol.RouteNavigationAction) (routeRecord, bool, bool) {
 	selection, ok := l.navigationSelection(action)
 	return selection.selected, ok, selection.noOp
 }
 // navigate resolves a captured key/generation, attempts resume before exact
 // attach, and commits only after the connector returns a matching identity.
 // A failed transition restores the prior live route and leaves history alone.
-func (l *routeLedger) navigate(ctx context.Context, action ports.RouteNavigationAction, connector routeTransitionConnector) error {
+func (l *routeLedger) navigate(ctx context.Context, action protocol.RouteNavigationAction, connector routeTransitionConnector) error {
 	selection, ok := l.navigationSelection(action)
 	if !ok {
 		return errRouteStaleSelection
 	if ctx == nil {
 		return errors.New("route transition context is nil")
 	}
-	selected := ports.RouteRef{Key: action.Key, Generation: action.Generation}
+	selected := protocol.RouteRef{Key: action.Key, Generation: action.Generation}
 	plan := routeTransitionPlan{
 		identity:           identityFromWire(selected),
 		record:             record,

M internal/usecase/client/routes_test.go +66 -65

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
-func routeTestTarget(index byte) ports.ExactSessionTarget {
+func routeTestTarget(index byte) protocol.ExactSessionTarget {
-	return ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{index + 1}, SessionName: "session-" + string(rune('a'+index%26)) + string(rune('0'+index/26))}
+	return protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{index + 1}, SessionName: "session-" + string(rune('a'+index%26)) + string(rune('0'+index/26))}
 }
-func routeTestCandidate(index byte, origin ports.RouteOrigin) routeCandidate {
+func routeTestCandidate(index byte, origin protocol.RouteOrigin) routeCandidate {
 	target := routeTestTarget(index)
 	return routeCandidate{
 		origin: origin,
 		target: target,
 		presentation: routePresentation{
 			name:         target.SessionName,
-			kind:         ports.RouteKindLocal,
+			kind:         protocol.RouteKindLocal,
-			reachability: ports.RouteReachabilityReachable,
+			reachability: protocol.RouteReachabilityReachable,
 		},
 		request: AttachRequest{
 			Intent:      ports.IntentAttach,
 	target := routeTestTarget(1)
 	candidate := routeCandidateForAttach(AttachRequest{
 		Intent: ports.IntentAttach, SessionName: target.SessionName, Remote: true,
-		Origin: ports.RouteOriginRemote, OriginKey: "user@remote", HostLabel: "remote",
+		Origin: protocol.RouteOriginRemote, OriginKey: "user@remote", HostLabel: "remote",
-	}, ports.CommittedRouteIdentity{Target: target}, nil, 0)
+	}, protocol.CommittedRouteIdentity{Target: target}, nil, 0)
 	require.Nil(t, candidate.request.RemoteTarget)
 	require.Equal(t, "remote", candidate.request.HostLabel)
 	ledger := newRouteLedger()
 	var keys []routeKey
 	for i := byte(0); i < maxRouteLedgerEntries+8; i++ {
-		candidate := routeTestCandidate(i, ports.RouteOriginLocal)
+		candidate := routeTestCandidate(i, protocol.RouteOriginLocal)
 		candidate.home = i == 0
 		identity, err := ledger.commit(candidate)
 		require.NoError(t, err)
 	require.Len(t, snapshot.Entries, maxRouteLedgerEntries-1)
 	require.Equal(t, uint64(keys[len(keys)-1]), snapshot.Active.Key)
 	require.Equal(t, routeTestTarget(maxRouteLedgerEntries+7), snapshot.ActiveEntry.Target)
-	require.Equal(t, snapshot.Active, ports.RouteRef{Key: snapshot.ActiveEntry.Key, Generation: snapshot.ActiveEntry.Generation})
+	require.Equal(t, snapshot.Active, protocol.RouteRef{Key: snapshot.ActiveEntry.Key, Generation: snapshot.ActiveEntry.Generation})
 	for _, entry := range snapshot.Entries {
 		require.NoError(t, entry.Target.Validate())
 		require.Equal(t, entry.Name, entry.Target.SessionName)
-		require.NotEqual(t, snapshot.Active, ports.RouteRef{Key: entry.Key, Generation: entry.Generation})
+		require.NotEqual(t, snapshot.Active, protocol.RouteRef{Key: entry.Key, Generation: entry.Generation})
 	}
 	require.Equal(t, uint64(keys[len(keys)-2]), snapshot.Previous.Key)
 	require.Equal(t, uint64(keys[0]), snapshot.Home.Key, "home is retained when older entries are evicted")
 	require.Equal(t, originalName, fresh.Entries[0].Name)
 	old := ledger.activeRef()
-	_, err := ledger.commit(routeTestCandidate(maxRouteLedgerEntries+9, ports.RouteOriginLocal))
+	_, err := ledger.commit(routeTestCandidate(maxRouteLedgerEntries+9, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	require.NotEqual(t, old, ledger.activeRef())
 	require.Equal(t, old, ledger.previousRef(), "the old active route becomes the previous route")
 func TestRouteLedgerRemembersTabsIndependentlyPerExactRoute(t *testing.T) {
 	ledger := newRouteLedger()
-	first := routeTestCandidate(1, ports.RouteOriginLocal)
+	first := routeTestCandidate(1, protocol.RouteOriginLocal)
 	firstIdentity, err := ledger.commit(first)
 	require.NoError(t, err)
 	firstRef := ledger.activeRef()
 	firstSnapshotGeneration := ledger.snapshot().Generation
-	require.NoError(t, ledger.updateRoutePosition(ports.RoutePosition{Target: first.target, ActiveTabID: "tab-first"}))
+	require.NoError(t, ledger.updateRoutePosition(protocol.RoutePosition{Target: first.target, ActiveTabID: "tab-first"}))
 	require.Equal(t, firstRef, ledger.activeRef(), "tab memory must not rotate route identity")
 	require.Equal(t, firstSnapshotGeneration, ledger.snapshot().Generation, "tab memory must not stale navigation snapshots")
-	second := routeTestCandidate(2, ports.RouteOriginRemote)
+	second := routeTestCandidate(2, protocol.RouteOriginRemote)
 	secondIdentity, err := ledger.commit(second)
 	require.NoError(t, err)
 	secondRef := ledger.activeRef()
 	secondSnapshotGeneration := ledger.snapshot().Generation
-	require.NoError(t, ledger.updateRoutePosition(ports.RoutePosition{Target: second.target, ActiveTabID: "tab-second"}))
+	require.NoError(t, ledger.updateRoutePosition(protocol.RoutePosition{Target: second.target, ActiveTabID: "tab-second"}))
 	require.Equal(t, secondRef, ledger.activeRef(), "tab memory must not rotate route identity")
 	require.Equal(t, secondSnapshotGeneration, ledger.snapshot().Generation, "tab memory must not stale navigation snapshots")
 func TestRouteLedgerSamePeerHandoffRestoresRouteTab(t *testing.T) {
 	ledger := newRouteLedger()
-	first := routeTestCandidate(1, ports.RouteOriginLocal)
+	first := routeTestCandidate(1, protocol.RouteOriginLocal)
 	first.originKey = "local"
 	_, err := ledger.commit(first)
 	require.NoError(t, err)
-	require.NoError(t, ledger.updateRoutePosition(ports.RoutePosition{Target: first.target, ActiveTabID: "tab-first"}))
+	require.NoError(t, ledger.updateRoutePosition(protocol.RoutePosition{Target: first.target, ActiveTabID: "tab-first"}))
-	second := routeTestCandidate(2, ports.RouteOriginLocal)
+	second := routeTestCandidate(2, protocol.RouteOriginLocal)
 	second.originKey = "local"
 	_, err = ledger.commit(second)
 	require.NoError(t, err)
 	recreated.LifecycleID[0]++
 	for _, tt := range []struct {
 		name            string
-		target          ports.ExactSessionTarget
+		target          protocol.ExactSessionTarget
-		wantExactTarget *ports.ExactSessionTarget
+		wantExactTarget *protocol.ExactSessionTarget
 		wantTab         domain.TabStableID
 	}{
 		{name: "matching lifecycle restores remembered tab", target: first.target, wantExactTarget: &first.target, wantTab: "tab-first"},
 }
 func TestRouteLedgerSamePeerHandoffClearsDaemonOwnedNavigationForLocalRoutes(t *testing.T) {
-	active := routeTestCandidate(2, ports.RouteOriginLocal)
+	active := routeTestCandidate(2, protocol.RouteOriginLocal)
 	active.originKey = "local"
 	active.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
-	active.request.NavigationCapabilities = ports.NavigationCapabilityHomePicker
+	active.request.NavigationCapabilities = protocol.NavigationCapabilityHomePicker
-	active.request.StartupOverlay = ports.StartupOverlaySessionPicker
+	active.request.StartupOverlay = protocol.StartupOverlaySessionPicker
 	for _, tt := range []struct {
 		name    string
 			ledger := newRouteLedger()
 			target := routeTestTarget(1)
 			if tt.matched {
-				stored := routeTestCandidate(1, ports.RouteOriginLocal)
+				stored := routeTestCandidate(1, protocol.RouteOriginLocal)
 				stored.originKey = "local"
 				stored.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
-				stored.request.NavigationCapabilities = ports.NavigationCapabilityHomePicker
+				stored.request.NavigationCapabilities = protocol.NavigationCapabilityHomePicker
-				stored.request.StartupOverlay = ports.StartupOverlaySessionPicker
+				stored.request.StartupOverlay = protocol.StartupOverlaySessionPicker
 				_, err := ledger.commit(stored)
 				require.NoError(t, err)
 			}
 			require.Equal(t, ports.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
 			require.Zero(t, request.NavigationCapabilities)
-			require.Equal(t, ports.StartupOverlayNone, request.StartupOverlay)
+			require.Equal(t, protocol.StartupOverlayNone, request.StartupOverlay)
 			require.NoError(t, validateAttachRequest(request))
 		})
 	}
 func TestRouteLedgerSamePeerHandoffDropsOriginalRemoteTarget(t *testing.T) {
 	ledger := newRouteLedger()
-	work := routeTestCandidate(1, ports.RouteOriginRemote)
+	work := routeTestCandidate(1, protocol.RouteOriginRemote)
 	work.originKey = "remote"
 	work.request.Remote = true
 	work.request.OriginKey = "remote"
 	_, err := ledger.commit(work)
 	require.NoError(t, err)
-	agents := routeTestCandidate(2, ports.RouteOriginRemote)
+	agents := routeTestCandidate(2, protocol.RouteOriginRemote)
 	agents.originKey = "remote"
 	agents.request.Remote = true
 	agents.request.OriginKey = "remote"
 	})
 	require.True(t, request.Remote)
-	require.Equal(t, ports.RouteOriginRemote, request.Origin)
+	require.Equal(t, protocol.RouteOriginRemote, request.Origin)
 	require.Equal(t, "remote", request.OriginKey)
 	require.Nil(t, request.RemoteTarget)
 }
 func TestRouteAttentionSubscriptionIncludesOnlyActiveOriginRoutes(t *testing.T) {
 	ledger := newRouteLedger()
-	first := routeTestCandidate(0, ports.RouteOriginRemote)
+	first := routeTestCandidate(0, protocol.RouteOriginRemote)
 	first.originKey = "host-a"
 	firstIdentity, err := ledger.commit(first)
 	require.NoError(t, err)
-	other := routeTestCandidate(1, ports.RouteOriginLocal)
+	other := routeTestCandidate(1, protocol.RouteOriginLocal)
 	_, err = ledger.commit(other)
 	require.NoError(t, err)
-	otherRemote := routeTestCandidate(2, ports.RouteOriginRemote)
+	otherRemote := routeTestCandidate(2, protocol.RouteOriginRemote)
 	otherRemote.originKey = "host-b"
 	_, err = ledger.commit(otherRemote)
 	require.NoError(t, err)
-	active := routeTestCandidate(3, ports.RouteOriginRemote)
+	active := routeTestCandidate(3, protocol.RouteOriginRemote)
 	active.originKey = "host-a"
 	_, err = ledger.commit(active)
 	require.NoError(t, err)
 	subscription := ledger.attentionSubscription()
-	require.Equal(t, []ports.RouteAttentionTarget{{
+	require.Equal(t, []protocol.RouteAttentionTarget{{
 		Ref:    firstIdentity.wire(),
 		Target: first.target,
 	}}, subscription.Targets)
 func TestCommittedIdentityRenamesActiveRouteInPlace(t *testing.T) {
 	ledger := newRouteLedger()
-	original := routeTestCandidate(0, ports.RouteOriginLocal)
+	original := routeTestCandidate(0, protocol.RouteOriginLocal)
-	original.target = ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "0"}
+	original.target = protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "0"}
 	original.presentation.name = "0"
 	original.request.SessionName = "0"
 	identity, err := ledger.commit(original)
 	require.NoError(t, err)
 	before := ledger.snapshot()
-	committed, err := ledger.commitCommittedIdentity(ports.CommittedRouteIdentity{
+	committed, err := ledger.commitCommittedIdentity(protocol.CommittedRouteIdentity{
-		Target:    ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "vps-infra"},
+		Target:    protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "vps-infra"},
 		Ephemeral: false,
 	})
 	require.NoError(t, err)
 func TestCommittedIdentityDoesNotReassignHomeRoute(t *testing.T) {
 	ledger := newRouteLedger()
-	home := routeTestCandidate(1, ports.RouteOriginLocal)
+	home := routeTestCandidate(1, protocol.RouteOriginLocal)
 	home.home = true
 	homeIdentity, err := ledger.commit(home)
 	require.NoError(t, err)
-	committed, err := ledger.commitCommittedIdentity(ports.CommittedRouteIdentity{
+	committed, err := ledger.commitCommittedIdentity(protocol.CommittedRouteIdentity{
 		Target:    routeTestTarget(2),
 		Ephemeral: true,
 	})
 	require.True(t, ok)
 	require.Equal(t, committed, active.identity)
-	_, err = ledger.commit(routeTestCandidate(1, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(1, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	require.True(t, mustRouteRecord(t, ledger, ledger.activeRef()).home, "upserting the home route must retain its marker")
 }
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			_, err := ledger.commitAttach(routeTestCandidate(i, ports.RouteOriginLocal))
+			_, err := ledger.commitAttach(routeTestCandidate(i, protocol.RouteOriginLocal))
 			errs <- err
 		}()
 	}
 func TestRouteLedgerTransitionRejectsConcurrentCommit(t *testing.T) {
 	ledger := newRouteLedger()
-	selected, err := ledger.commit(routeTestCandidate(1, ports.RouteOriginLocal))
+	selected, err := ledger.commit(routeTestCandidate(1, protocol.RouteOriginLocal))
 	require.NoError(t, err)
-	_, err = ledger.commit(routeTestCandidate(2, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(2, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	selection, ok := ledger.navigationSelection(selected.wireNavigationAction(routeGeneration(ledger.snapshot().Generation)))
 	require.True(t, ok)
-	_, err = ledger.commit(routeTestCandidate(3, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(3, protocol.RouteOriginLocal))
 	require.NoError(t, err)
-	candidate := routeTestCandidate(4, ports.RouteOriginLocal)
+	candidate := routeTestCandidate(4, protocol.RouteOriginLocal)
 	err = ledger.commitTransition(selected, selection.snapshotGeneration, selection.active, candidate)
 	require.ErrorIs(t, err, errRouteStaleSelection)
 	require.Equal(t, routeTestTarget(3), mustRouteRecord(t, ledger, ledger.activeRef()).target)
 }
-func mustRouteRecord(t *testing.T, ledger *routeLedger, ref ports.RouteRef) routeRecord {
+func mustRouteRecord(t *testing.T, ledger *routeLedger, ref protocol.RouteRef) routeRecord {
 	t.Helper()
 	record, ok := ledger.lookup(ref)
 	require.True(t, ok)
 func TestRouteLedgerUpsertChangesGenerationWithoutChangingOpaqueKey(t *testing.T) {
 	ledger := newRouteLedger()
-	candidate := routeTestCandidate(1, ports.RouteOriginRemote)
+	candidate := routeTestCandidate(1, protocol.RouteOriginRemote)
 	first, err := ledger.commit(candidate)
 	require.NoError(t, err)
 	attachCalls   int
 	restoreCalls  int
 	restoreErr    error
-	restoreTarget ports.ExactSessionTarget
+	restoreTarget protocol.ExactSessionTarget
 }
 func (c *routeTestConnector) Resume(context.Context, routeRecord) (routeTransitionCommit, error) {
 		return routeTransitionCommit{}, c.attachErr
 	}
 	return routeTransitionCommit{
-		identity: ports.CommittedRouteIdentity{Target: record.target},
+		identity: protocol.CommittedRouteIdentity{Target: record.target},
 		presentation: routePresentation{
 			name:         record.presentation.name,
 			kind:         record.presentation.kind,
-			reachability: ports.RouteReachabilityReachable,
+			reachability: protocol.RouteReachabilityReachable,
 		},
 		resumeToken: 123,
 	}, nil
 func TestRouteLedgerNavigateResumesThenFallsBackAndRestoresOrigin(t *testing.T) {
 	ledger := newRouteLedger()
-	candidate := routeTestCandidate(2, ports.RouteOriginDiscovery)
+	candidate := routeTestCandidate(2, protocol.RouteOriginDiscovery)
 	candidate.originKey = "daemon-discovered"
 	candidate.resumeToken = 77
 	identity, err := ledger.commit(candidate)
 	require.NoError(t, err)
-	_, err = ledger.commit(routeTestCandidate(4, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(4, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	connector := &routeTestConnector{resumeErr: errRouteResumeUnavailable}
 	active, ok := ledger.lookup(ledger.activeRef())
 	require.True(t, ok)
-	require.Equal(t, ports.RouteOriginDiscovery, active.origin)
+	require.Equal(t, protocol.RouteOriginDiscovery, active.origin)
 	require.Equal(t, "daemon-discovered", active.originKey)
-	require.Equal(t, ports.RouteOriginDiscovery, active.request.Origin)
+	require.Equal(t, protocol.RouteOriginDiscovery, active.request.Origin)
 	require.Equal(t, candidate.target, active.target)
 	require.Greater(t, active.identity.generation, identity.generation)
 }
 func TestRouteLedgerNavigateIsTransactionalOnFailureOrTargetChange(t *testing.T) {
 	ledger := newRouteLedger()
-	identity, err := ledger.commit(routeTestCandidate(3, ports.RouteOriginLocal))
+	identity, err := ledger.commit(routeTestCandidate(3, protocol.RouteOriginLocal))
 	require.NoError(t, err)
-	_, err = ledger.commit(routeTestCandidate(5, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(5, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	before := ledger.snapshot()
 	action := identity.wireNavigationAction(routeGeneration(before.Generation))
 func TestRouteLedgerNavigationRejectsStaleActionsAndActiveNoOp(t *testing.T) {
 	ledger := newRouteLedger()
-	active, err := ledger.commit(routeTestCandidate(6, ports.RouteOriginLocal))
+	active, err := ledger.commit(routeTestCandidate(6, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	firstSnapshot := ledger.snapshot()
 	before := ledger.snapshot()
 	require.NoError(t, ledger.navigate(context.Background(), active.wireNavigationAction(routeGeneration(firstSnapshot.Generation)), nil))
 	require.Equal(t, before, ledger.snapshot())
-	_, err = ledger.commit(routeTestCandidate(7, ports.RouteOriginLocal))
+	_, err = ledger.commit(routeTestCandidate(7, protocol.RouteOriginLocal))
 	require.NoError(t, err)
 	stale := active.wireNavigationAction(routeGeneration(firstSnapshot.Generation))
 	connector := &routeTestConnector{}
 func (c mismatchingRouteConnector) Attach(_ context.Context, record routeRecord) (routeTransitionCommit, error) {
 	return routeTransitionCommit{
-		identity:     ports.CommittedRouteIdentity{Target: routeTestTarget(99)},
+		identity:     protocol.CommittedRouteIdentity{Target: routeTestTarget(99)},
 		presentation: routePresentation{name: record.presentation.name, kind: record.presentation.kind},
 	}, nil
 }
-func (i routeIdentity) wireNavigationAction(snapshotGeneration routeGeneration) ports.RouteNavigationAction {
+func (i routeIdentity) wireNavigationAction(snapshotGeneration routeGeneration) protocol.RouteNavigationAction {
-	return ports.RouteNavigationAction{SnapshotGeneration: uint64(snapshotGeneration), Key: uint64(i.key), Generation: uint64(i.generation)}
+	return protocol.RouteNavigationAction{SnapshotGeneration: uint64(snapshotGeneration), Key: uint64(i.key), Generation: uint64(i.generation)}
 }
 func TestRouteLedgerConcurrentSnapshotsAndCommits(t *testing.T) {
 		go func() {
 			defer wg.Done()
 			for i := byte(0); i < 20; i++ {
-				_, _ = ledger.commit(routeTestCandidate(worker*20+i, ports.RouteOriginLocal))
+				_, _ = ledger.commit(routeTestCandidate(worker*20+i, protocol.RouteOriginLocal))
 				_ = ledger.snapshot()
 			}
 		}()
 func TestRouteLedgerSeparatesRemoteDaemonOrigins(t *testing.T) {
 	ledger := newRouteLedger()
-	firstCandidate := routeTestCandidate(40, ports.RouteOriginRemote)
+	firstCandidate := routeTestCandidate(40, protocol.RouteOriginRemote)
 	firstCandidate.originKey = "daemon-a"
 	secondCandidate := firstCandidate
 	secondCandidate.originKey = "daemon-b"

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


@@ -4,7 +4,7 @@ import (
4		"context"	4		"context"
5		"sync"	5		"sync"
6			6
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol"
8		)	8		)
9			9
10		// samePeerInputGate holds raw input behind a requested in-band switch. It does	10		// samePeerInputGate holds raw input behind a requested in-band switch. It does

@@ -20,7 +20,7 @@ type samePeerInputGate struct {
20			20
21		type samePeerSwitchPending struct {	21		type samePeerSwitchPending struct {
22		requestID uint64	22		requestID uint64
23	-	target ports.ExactSessionTarget	23	+	target protocol.ExactSessionTarget
24		}	24		}
25			25
26		func newSamePeerInputGate() *samePeerInputGate {	26		func newSamePeerInputGate() *samePeerInputGate {

M internal/usecase/client/same_peer_switch_test.go +2 -1

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestCloseAndDialAttachTargetSkipsSamePeerSwitch(t *testing.T) {
 	resultCh := make(chan attachResult, 1)
 	go func() { resultCh <- attempt.run(ctx) }()
-	exact := ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{7}, SessionName: "stopped"}
+	exact := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{7}, SessionName: "stopped"}
 	target := ports.AttachTarget{
 		Session: "stopped", Intent: ports.IntentAttach, ExactTarget: &exact,
 		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,

M internal/usecase/client/transport_observability_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"
 	"github.com/bnema/vev/internal/usecase/client"
 )
 	transport.EXPECT().Send(isType(ports.MsgAck)).Run(func(ports.Frame) { close(acked) }).Return(nil).Once()
 	unblock := scriptRecv(transport,
 		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("flush-before-observe"), New: 3}))},
+		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}))},
 	)
 	defer unblock()
 	transport.EXPECT().Close().Return(nil).Once()
 	transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
 	unblock := scriptRecv(transport,
 		recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},
-		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(ports.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Full: true, Data: []byte("unchanged-by-observer"), New: 3}))},
+		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(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},
 	)
 	defer unblock()

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

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

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

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

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

 	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/usecase/keys"
 )
 		},
 		{
 			name: "theme",
-			frame: ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(ports.Theme{
+			frame: ports.Frame{Type: ports.MsgTheme, Payload: ports.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(ports.Ack{Epoch: 1, State: 1})},
+			frame: ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: 1, State: 1})},
 			assert: func(t *testing.T, ac *attachedClient, _ *transactionalResizePTY) {
 				ac.sendMu.Lock()
 				defer ac.sendMu.Unlock()
 	token.lease = rc.attachmentLease(ac)
 	ac.installTestAttachmentCapability(token)
-	activeRef := ports.RouteRef{Key: 8, Generation: 4}
+	activeRef := protocol.RouteRef{Key: 8, Generation: 4}
 	activeTarget := testRouteTarget(source.name, 8)
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation:  4,
 		Active:      activeRef,
-		ActiveEntry: ports.RecentRouteEntry{Key: 8, Generation: 4, Target: activeTarget, Name: source.name, Kind: ports.RouteKindLocal},
+		ActiveEntry: protocol.RecentRouteEntry{Key: 8, Generation: 4, Target: activeTarget, Name: source.name, Kind: protocol.RouteKindLocal},
 		Home:        activeRef,
-		Entries:     []ports.RecentRouteEntry{testRouteEntry(7, 3, "previous", 7, ports.RouteKindLocal)},
+		Entries:     []protocol.RecentRouteEntry{testRouteEntry(7, 3, "previous", 7, protocol.RouteKindLocal)},
 	}
 	payload, err := ports.MarshalRecentRouteSnapshot(snapshot)
 	require.NoError(t, err)
 	d.mu.Lock()
 	d.sessions[target.id] = target
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation:  2,
-		Active:      ports.RouteRef{Key: 2, Generation: 2},
+		Active:      protocol.RouteRef{Key: 2, Generation: 2},
-		ActiveEntry: testRouteEntry(2, 2, source.name, 2, ports.RouteKindLocal),
+		ActiveEntry: testRouteEntry(2, 2, source.name, 2, protocol.RouteKindLocal),
-		Previous:    ports.RouteRef{Key: 1, Generation: 1},
+		Previous:    protocol.RouteRef{Key: 1, Generation: 1},
-		Entries:     []ports.RecentRouteEntry{testRouteEntry(1, 1, "target", 1, ports.RouteKindLocal)},
+		Entries:     []protocol.RecentRouteEntry{testRouteEntry(1, 1, "target", 1, protocol.RouteKindLocal)},
 	})
 	transport := &closeTrackingTransport{}
 		break
 	}
 	require.True(t, result.OK, result.Text)
-	var action ports.RouteNavigationAction
+	var action protocol.RouteNavigationAction
 	for _, frame := range frames {
 		if frame.Type != ports.MsgNavigateRecentRoute {
 			continue
 		action, err = ports.UnmarshalRouteNavigationAction(frame.Payload)
 		require.NoError(t, err)
 	}
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 2, Key: 1, Generation: 1}, action)
 	require.False(t, transport.Closed(), "client navigation must not tear down the attachment")
 }

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

 	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"
 )
 // attachmentOutput owns the terminal-output dependency chain and emitted
 	forceSnapshot             bool
 	initialized               bool
 	lastCursor                cursorOut
-	lastRoutePosition         ports.RoutePosition
+	lastRoutePosition         protocol.RoutePosition
 	graphicsOutput            *graphicsOutputState
 	graphicsUnsupportedWarned atomic.Bool
 	attachment                *attachedClient
 	}
 	cursor := o.prepareCursorTail(desired, len(ansi.data) > 0)
 	graphicsReset := reset || o.forceSnapshot || !o.initialized
-	graphicsBudget := max(ports.MaxOutputDataLen-len(ansi.data)-len(cursor.data), 0)
+	graphicsBudget := max(protocol.MaxOutputDataLen-len(ansi.data)-len(cursor.data), 0)
 	preparedGraphics, err := graphicsOutputDataWithDaemonLimit(d, state, o.attachment, graphicsReset, graphicsBudget)
 	if err != nil {
 		return nil, err
 }
 func marshalOutputState(data []byte, epoch, base, next, echoAck, viewRevision uint64, size domain.Size, full bool) (ports.Frame, error) {
-	payload, err := ports.MarshalOutput(ports.Output{
+	payload, err := ports.MarshalOutput(protocol.Output{
 		Epoch: epoch, Base: base, New: next, Echo: echoAck, ViewRevision: viewRevision,
 		Size: size, Full: full, Data: data,
 	})
 		return
 	}
 	s.rebase()
-	s.lastRoutePosition = ports.RoutePosition{}
+	s.lastRoutePosition = protocol.RoutePosition{}
 }
 // rebaseLocked is called while the attachment view lock is held. Publishing

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

 	"github.com/bnema/vev-vt/graphics"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/stretchr/testify/require"
 )
 	output.next = 3
 	output.acked = 2
 	output.lastCursor = cursorOut{valid: true, row: 2, col: 3}
-	output.lastRoutePosition = ports.RoutePosition{ActiveTabID: "tab"}
+	output.lastRoutePosition = protocol.RoutePosition{ActiveTabID: "tab"}
 	output.rebaseAttachment()
 	require.Zero(t, output.acked)
 	require.True(t, output.forceSnapshot)
 	require.Equal(t, cursorOut{valid: true, row: 2, col: 3}, output.lastCursor, "the forced frame will reassert cursor state")
-	require.Equal(t, ports.RoutePosition{}, output.lastRoutePosition)
+	require.Equal(t, protocol.RoutePosition{}, output.lastRoutePosition)
 }
 func TestAttachmentOutputDefaultsAndNormalizesWindow(t *testing.T) {

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type resumeWelcomeFailureTransport struct {
 	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	oldToken := ac.resumeToken
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	d.clientGone(sess, ac, oldTransport, false)
 	resumedTransport := &closeTrackingTransport{}

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 		token := sess.captureAttachmentCapability(ac, tr)
 		d.handleAttachmentClientFrame(token, ports.Frame{
 			Type:    ports.MsgResize,
-			Payload: mustMarshalResize(ports.Resize{Size: size}),
+			Payload: mustMarshalResize(protocol.Resize{Size: size}),
 		})
 	}
 	resize(second, secondTransport, domain.Size{Cols: 120, Rows: 50})

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 	token := source.captureAttachmentCapability(ac, transport)
 	token.lease = rc.attachmentLease(ac)
 	ac.installTestAttachmentCapability(token)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	target := &session{
 		sessionCore: sessionCore{
 	require.NoError(t, err)
 	d.deferAttachmentTransitionCleanups(transition)
-	var identity ports.CommittedRouteIdentity
+	var identity protocol.CommittedRouteIdentity
 	found := false
 	for _, frame := range transport.Sends() {
 		if frame.Type != ports.MsgCommittedRouteIdentity {
 	token := source.captureAttachmentCapability(ac, transport)
 	token.lease = rc.attachmentLease(ac)
 	ac.installTestAttachmentCapability(token)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	target := &session{
 		sessionCore: sessionCore{

M internal/usecase/daemon/client.go +19 -18

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/mouse"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	overlayOnce            sync.Once
 	clientID               [16]byte
 	terminalCapabilities   ports.TerminalCapabilities
-	navigationCapabilities ports.NavigationCapabilities
+	navigationCapabilities protocol.NavigationCapabilities
-	startupOverlay         ports.StartupOverlay
+	startupOverlay         protocol.StartupOverlay
 	// lifecycle is the sole authority for attachment capability publication,
 	// effect admission, transition freeze/drain, and connection generation.
 	lifecycle     attachmentLifecycle
 	linkMu                     sync.Mutex
 	sendMu                     sync.Mutex
 	routeMu                    sync.RWMutex
-	routeSnapshot              ports.RecentRouteSnapshot
+	routeSnapshot              protocol.RecentRouteSnapshot
 	pendingRouteIdentity       bool
 	samePeerOfferMu            sync.Mutex
-	samePeerOffer              *ports.ExactSessionTarget
+	samePeerOffer              *protocol.ExactSessionTarget
 	parkedRouteMu              sync.Mutex
 	parkedRoute                *parkedRouteLease
 	parkedRouteOutput          atomic.Bool
 	parkedRouteFullPending     atomic.Bool
-	routeAttentionSubscription ports.RouteAttentionSubscription
+	routeAttentionSubscription protocol.RouteAttentionSubscription
 	// routeCreatedSession marks a session created by this attachment's route.
 	// A handshake that never commits Welcome must tear down that exact empty
 	// session, while an attachment routed to an existing session must not.
 // setRouteSnapshot records a client-owned route view and reports whether a
 // rename identity was deferred until that first usable publication.
-func (ac *attachedClient) setRouteSnapshot(snapshot ports.RecentRouteSnapshot) bool {
+func (ac *attachedClient) setRouteSnapshot(snapshot protocol.RecentRouteSnapshot) bool {
-	snapshot.Entries = append([]ports.RecentRouteEntry(nil), snapshot.Entries...)
+	snapshot.Entries = append([]protocol.RecentRouteEntry(nil), snapshot.Entries...)
 	ac.routeMu.Lock()
 	ac.routeSnapshot = snapshot
 	replayPendingIdentity := snapshot.Generation != 0 && ac.pendingRouteIdentity
 	return true
 }
-func (ac *attachedClient) routeSnapshotCopy() ports.RecentRouteSnapshot {
+func (ac *attachedClient) routeSnapshotCopy() protocol.RecentRouteSnapshot {
 	ac.routeMu.RLock()
 	defer ac.routeMu.RUnlock()
 	snapshot := ac.routeSnapshot
-	snapshot.Entries = append([]ports.RecentRouteEntry(nil), snapshot.Entries...)
+	snapshot.Entries = append([]protocol.RecentRouteEntry(nil), snapshot.Entries...)
 	return snapshot
 }
-func (ac *attachedClient) setRouteAttentionSubscription(subscription ports.RouteAttentionSubscription) {
+func (ac *attachedClient) setRouteAttentionSubscription(subscription protocol.RouteAttentionSubscription) {
-	subscription.Targets = append([]ports.RouteAttentionTarget(nil), subscription.Targets...)
+	subscription.Targets = append([]protocol.RouteAttentionTarget(nil), subscription.Targets...)
 	ac.routeMu.Lock()
 	ac.routeAttentionSubscription = subscription
 	ac.routeMu.Unlock()
 }
-func (ac *attachedClient) routeAttentionTarget(ref ports.RouteRef) (ports.ExactSessionTarget, bool) {
+func (ac *attachedClient) routeAttentionTarget(ref protocol.RouteRef) (protocol.ExactSessionTarget, bool) {
 	ac.routeMu.RLock()
 	defer ac.routeMu.RUnlock()
 	for _, target := range ac.routeAttentionSubscription.Targets {
 			return target.Target, true
 		}
 	}
-	return ports.ExactSessionTarget{}, false
+	return protocol.ExactSessionTarget{}, false
 }
 func (ac *attachedClient) ackOutputState(epoch, state uint64) {
 	maxOutputInFlight      uint8
 	terminalCapabilities   ports.TerminalCapabilities
 	capabilitiesSet        bool
-	navigationCapabilities ports.NavigationCapabilities
+	navigationCapabilities protocol.NavigationCapabilities
-	startupOverlay         ports.StartupOverlay
+	startupOverlay         protocol.StartupOverlay
 }
 func (d *Daemon) attachClient(sess *session, tr ports.Transport, sz domain.Size, opts attachClientOptions) (*attachedClient, error) {
 // detachIfCurrent clears the client iff ac is the current one, reporting
-func themeFromMessage(msg ports.Theme) themeui.Theme {
+func themeFromMessage(msg protocol.Theme) themeui.Theme {
 	return themeui.Theme{
 		Foreground:   msg.Foreground,
 		Background:   msg.Background,
 	}
 }
-func (d *Daemon) applyTheme(sess *session, ac *attachedClient, msg ports.Theme) {
+func (d *Daemon) applyTheme(sess *session, ac *attachedClient, msg protocol.Theme) {
 	clientTheme := themeFromMessage(msg)
 	ac.setClientTheme(clientTheme)
 	d.invalidateRender(sess, ac, true, "client.go")
 }
-func (d *Daemon) applyThemeForAttachment(effect *attachmentEffect, msg ports.Theme) {
+func (d *Daemon) applyThemeForAttachment(effect *attachmentEffect, msg protocol.Theme) {
 	if !effect.current() {
 		return
 	}

M internal/usecase/daemon/client_frame_routing.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/usecase/command"
 )
 		}
 		message := "route navigation failed"
 		switch failure.Code {
-		case ports.RouteFailureStaleSelection:
+		case protocol.RouteFailureStaleSelection:
 			message = "that recent route is no longer available"
-		case ports.RouteFailureTargetChanged:
+		case protocol.RouteFailureTargetChanged:
 			message = "that recent route changed before attach"
-		case ports.RouteFailureOriginUnavailable:
+		case protocol.RouteFailureOriginUnavailable:
 			message = "the original route is no longer available"
-		case ports.RouteFailureUnavailable:
+		case protocol.RouteFailureUnavailable:
 			message = "the selected route is unavailable"
-		case ports.RouteFailureNoSuchRoute:
+		case protocol.RouteFailureNoSuchRoute:
 			message = "that recent route no longer exists"
 		}
 		d.notify(effect.sess, domain.NoticeWarn, domain.NoticeSessionUnavailable, message, nil)

M internal/usecase/daemon/client_transport_errors.go +3 -1

@@ -1,6 +1,8 @@
1		package daemon	1		package daemon
2			2
3	-	import "github.com/bnema/vev/internal/ports"	3	+	import (
			4	+	"github.com/bnema/vev/internal/ports"
			5	+	)
4			6
5		// clientGone detaches ac if it is still the session's current client. The	7		// clientGone detaches ac if it is still the session's current client. The
6		// session remains registered and headless after the client is gone.	8		// session remains registered and headless after the client is gone.

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

 	"os"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 )
 	clipPasteCloseMarker = []byte("\x1b[201~")
 )
-func (d *Daemon) handleSequencedImagePushForAttachment(effect *attachmentEffect, _ uint64, ip ports.ImagePush) {
+func (d *Daemon) handleSequencedImagePushForAttachment(effect *attachmentEffect, _ uint64, ip protocol.ImagePush) {
 	if !effect.current() {
 		return
 	}
 	d.handleImagePushForAttachment(effect, ip)
 }
-func (d *Daemon) handleImagePushForAttachment(effect *attachmentEffect, ip ports.ImagePush) {
+func (d *Daemon) handleImagePushForAttachment(effect *attachmentEffect, ip protocol.ImagePush) {
 	if len(ip.Data) == 0 || len(ip.Data) > maxImagePushSize || !effect.current() {
 		return
 	}
 // failure is logged and the push is dropped: the client has already
 // consumed the Ctrl+V keystroke that triggered it, so there is nothing left
 // to re-trigger from here.
-func (d *Daemon) handleImagePush(sess *session, ip ports.ImagePush) {
+func (d *Daemon) handleImagePush(sess *session, ip protocol.ImagePush) {
 	if len(ip.Data) == 0 {
 		return
 	}
 // writeClipboardImage writes ip's bytes to a new 0600 temp file and records
 // the path on sess for best-effort cleanup at session end (killSession).
-func (d *Daemon) writeClipboardImage(sess *session, ip ports.ImagePush) (string, error) {
+func (d *Daemon) writeClipboardImage(sess *session, ip protocol.ImagePush) (string, error) {
 	path, err := d.createClipboardImage(ip)
 	if err != nil {
 		return "", err
 	return path, nil
 }
-func (d *Daemon) writeClipboardImageForAttachment(effect *attachmentEffect, ip ports.ImagePush) (string, error) {
+func (d *Daemon) writeClipboardImageForAttachment(effect *attachmentEffect, ip protocol.ImagePush) (string, error) {
 	path, err := d.createClipboardImage(ip)
 	if err != nil {
 		return "", err
 	return path, nil
 }
-func (d *Daemon) createClipboardImage(ip ports.ImagePush) (string, error) {
+func (d *Daemon) createClipboardImage(ip protocol.ImagePush) (string, error) {
 	dir := d.tempDir
 	if dir == "" {
 		dir = os.TempDir()

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

 	"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"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 )
 	d.tempDir = t.TempDir()
 	data := []byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a, 0x01, 0x02, 0x03}
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: data})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: data})
 	injected := <-writes
 	path := string(injected)
 	pane := sess.tabs[0].focusedPane()
 	require.False(t, pane.screen.BracketedPasteMode())
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: []byte("x")})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: []byte("x")})
 	injected := <-writes
 	require.False(t, hasBracketedPasteMarkers(injected), "path must not be wrapped when the pane is not in bracketed-paste mode")
 	pane.screen.Write([]byte("\x1b[?2004h"))
 	require.True(t, pane.screen.BracketedPasteMode())
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: []byte("x")})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: []byte("x")})
 	injected := <-writes
 	require.True(t, len(injected) > len(clipPasteOpenMarker)+len(clipPasteCloseMarker))
 	d.tempDir = dir
 	huge := make([]byte, maxImagePushSize+1)
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: huge})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: huge})
 	select {
 	case w := <-writes:
 	dir := t.TempDir()
 	d.tempDir = dir
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: nil})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: nil})
 	select {
 	case w := <-writes:
 	// killSession requires the session to be registered in the daemon's
 	// registry (newManualSessionWithPTYs already does this via d.sessions).
-	d.handleImagePush(sess, ports.ImagePush{Mime: "image/png", Data: []byte("x")})
+	d.handleImagePush(sess, protocol.ImagePush{Mime: "image/png", Data: []byte("x")})
 	injected := <-writes
 	path := string(injected)
 	require.FileExists(t, path)

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


@@ -350,9 +350,9 @@ func TestRemoteInactiveRouteRejectsReplacementDuringCatalogueRead(t *testing.T)
350		d.mu.Unlock()	350		d.mu.Unlock()
351		close(catalogue.release)	351		close(catalogue.release)
352			352
353	-	var protocol *protoErr	353	+	var protocolErr *protoErr
354	-	require.ErrorAs(t, <-result, &protocol)	354	+	require.ErrorAs(t, <-result, &protocolErr)
355	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	355	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
356		require.Empty(t, catalogue.MetadataUpdates())	356		require.Empty(t, catalogue.MetadataUpdates())
357		d.mu.Lock()	357		d.mu.Lock()
358		defer d.mu.Unlock()	358		defer d.mu.Unlock()

@@ -443,9 +443,9 @@ func TestRemoteInactiveRouteRejectsTabAuthorityChangeDuringCatalogueRead(t *test
443		}	443		}
444		close(catalogue.release)	444		close(catalogue.release)
445			445
446	-	var protocol *protoErr	446	+	var protocolErr *protoErr
447	-	require.ErrorAs(t, <-result, &protocol)	447	+	require.ErrorAs(t, <-result, &protocolErr)
448	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	448	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
449		require.Empty(t, catalogue.MetadataUpdates())	449		require.Empty(t, catalogue.MetadataUpdates())
450		d.mu.Lock()	450		d.mu.Lock()
451		defer d.mu.Unlock()	451		defer d.mu.Unlock()

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

 	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/usecase/keys"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 )
 	clientPalette := [16]renderer.RGB{}
 	clientPalette[1] = renderer.RGB{R: 1, G: 2, B: 3}
 	clientPalette[12] = renderer.RGB{R: 4, G: 5, B: 6}
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true,
 		Foreground:    renderer.RGB{R: 7, G: 8, B: 9},
 		HasBackground: true,

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/keys"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 )
 		failAttachment()
 		return
 	}
-	if ac.startupOverlay == ports.StartupOverlaySessionPicker {
+	if ac.startupOverlay == protocol.StartupOverlaySessionPicker {
 		d.enterPicker(sess, ac)
 	}
 	postWelcomeTicket.End()
 // route resolves a Hello to a session and a freshly attached client, creating
 // the session for ephemeral/new intents. Direct package callers retain the
 // daemon lifetime context; inbound handshakes use routeWithContext.
-func (d *Daemon) validateExactSessionTargetLocked(target ports.ExactSessionTarget) error {
+func (d *Daemon) validateExactSessionTargetLocked(target protocol.ExactSessionTarget) error {
 	if sess := d.findByNameLocked(target.SessionName); sess != nil {
 		if sess.incarnation != target.LifecycleID {
 			return &protoErr{ports.ErrNoSuchSession, "session lifecycle has changed: " + target.SessionName}
 	return nil
 }
-func (d *Daemon) validateExactSessionTarget(ctx context.Context, target ports.ExactSessionTarget) error {
+func (d *Daemon) validateExactSessionTarget(ctx context.Context, target protocol.ExactSessionTarget) error {
 	if err := target.Validate(); err != nil {
 		return &protoErr{ports.ErrNoSuchSession, "invalid exact session target"}
 	}

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 	sess.ephemeral = false
 	sess.incarnation = remoteLifecycleForTest()
 	tr, _ := newCapturingTransport(t)
-	target := ports.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
+	target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
 	hello := ports.Hello{
 		Version:     ports.ProtocolVersion,
 		Intent:      ports.IntentAttach,
 		Intent:      ports.IntentAttach,
 		Name:        "other",
 		Size:        domain.Size{Cols: 80, Rows: 24},
-		ExactTarget: &ports.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name},
+		ExactTarget: &protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name},
 	}
 	_, _, err := d.routeWithContext(context.Background(), hello, tr)
-	var protocol *protoErr
+	var protocolErr *protoErr
-	require.ErrorAs(t, err, &protocol)
+	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchSession, protocol.code)
+	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)
 }
 func TestLockedExactSessionTargetRejectsReplacement(t *testing.T) {
 	sess := addControlSession(d, "work", "tab-1", "pane-1")
 	sess.ephemeral = false
 	sess.incarnation = remoteLifecycleForTest()
-	target := ports.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
+	target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
 	replacement := sess.incarnation
 	replacement[0]++
 	sess.incarnation = replacement
 	err := d.validateExactSessionTargetLocked(target)
 	d.mu.Unlock()
-	var protocol *protoErr
+	var protocolErr *protoErr
-	require.ErrorAs(t, err, &protocol)
+	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchSession, protocol.code)
+	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)
 }
 func TestRouteExactSessionTargetRejectsLifecycleReplacement(t *testing.T) {
 		Intent:      ports.IntentAttach,
 		Name:        sess.name,
 		Size:        domain.Size{Cols: 80, Rows: 24},
-		ExactTarget: &ports.ExactSessionTarget{LifecycleID: wrong, SessionName: sess.name},
+		ExactTarget: &protocol.ExactSessionTarget{LifecycleID: wrong, SessionName: sess.name},
 	}
 	_, _, err := d.routeWithContext(context.Background(), hello, tr)
-	var protocol *protoErr
+	var protocolErr *protoErr
-	require.ErrorAs(t, err, &protocol)
+	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchSession, protocol.code)
+	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)
 }

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

 	"github.com/bnema/vev-vt/graphics"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 )
 // attachment-local state is also the ownership boundary for Kitty IDs: raw
 // scene IDs are never sent to the outer terminal.
 const (
-	maxGraphicsRecordBytes   = ports.MaxOutputDataLen
+	maxGraphicsRecordBytes   = protocol.MaxOutputDataLen
-	maxGraphicsOutputBytes   = ports.MaxOutputDataLen
+	maxGraphicsOutputBytes   = protocol.MaxOutputDataLen
 	graphicsUploadChunkBytes = 128 << 10
 )

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

 	"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"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 	effect, admitted := ac.beginAttachmentEffect(token)
 	require.True(t, admitted)
 	defer effect.End()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation: 3,
-		Active:     ports.RouteRef{Key: 3, Generation: 3},
+		Active:     protocol.RouteRef{Key: 3, Generation: 3},
-		Previous:   ports.RouteRef{Key: 2, Generation: 2},
+		Previous:   protocol.RouteRef{Key: 2, Generation: 2},
-		Entries:    []ports.RecentRouteEntry{testRouteEntry(2, 2, "recent", 2, ports.RouteKindLocal)},
+		Entries:    []protocol.RecentRouteEntry{testRouteEntry(2, 2, "recent", 2, protocol.RouteKindLocal)},
 	})
 	require.NoError(t, d.backSessionForAttachment(effect))
 	frame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
 	action, err := ports.UnmarshalRouteNavigationAction(frame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 3, Key: 2, Generation: 2}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 3, Key: 2, Generation: 2}, action)
 }
 func TestBackSessionWithoutClientHistoryIsNoop(t *testing.T) {
 	mustOutputData(t, sends)
 	d.handleInput(sess, ac, []byte("\x1b[<0;2;2m"))
 	d.handleInput(sess, ac, []byte("y"))
-	var msg ports.Output
+	var msg protocol.Output
 	require.Eventually(t, func() bool {
 		frame := awaitFrame(t, sends, ports.MsgOutput)
 		var err error

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


@@ -4,9 +4,8 @@ import (
4		"testing"	4		"testing"
5		"time"	5		"time"
6			6
7	-	"github.com/stretchr/testify/require"
8	-
9		"github.com/bnema/vev/internal/ports"	7		"github.com/bnema/vev/internal/ports"
			8	+	"github.com/stretchr/testify/require"
10		)	9		)
11			10
12		func awaitMoveTeardownState(t testing.T, sess session, reservations, waiters uint) {	11		func awaitMoveTeardownState(t testing.T, sess session, reservations, waiters uint) {

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

 	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/stretchr/testify/require"
 )
 	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(ports.Ack{Epoch: out.Epoch, State: out.New})}
+	tr.recv <- ports.Frame{Type: ports.MsgAck, Payload: mustMarshalAck(protocol.Ack{Epoch: out.Epoch, State: out.New})}
 	require.NoError(t, tr.Close())
 	d.runConnLoop(ac)
 	return string(runes)
 }
-func mustApplyOutput(t *testing.T, screen *vt.Screen, frame ports.Frame) ports.Output {
+func mustApplyOutput(t *testing.T, screen *vt.Screen, frame ports.Frame) protocol.Output {
 	t.Helper()
 	out, err := ports.UnmarshalOutput(frame.Payload)
 	require.NoError(t, err)

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


@@ -6,7 +6,7 @@ import (
6		"time"	6		"time"
7			7
8		"github.com/bnema/vev/internal/domain"	8		"github.com/bnema/vev/internal/domain"
9	-	"github.com/bnema/vev/internal/ports"	9	+	"github.com/bnema/vev/internal/protocol"
10		scopy "github.com/bnema/vev/internal/usecase/copy"	10		scopy "github.com/bnema/vev/internal/usecase/copy"
11		"github.com/bnema/vev/internal/usecase/notices"	11		"github.com/bnema/vev/internal/usecase/notices"
12		"github.com/bnema/vev/internal/usecase/palette"	12		"github.com/bnema/vev/internal/usecase/palette"

@@ -43,7 +43,7 @@ type overlayRuntime struct {
43			43
44		paletteMu sync.Mutex	44		paletteMu sync.Mutex
45		palette *palette.Model	45		palette *palette.Model
46	-	paletteRouteSnapshot ports.RecentRouteSnapshot	46	+	paletteRouteSnapshot protocol.RecentRouteSnapshot
47		paletteGeneration uint64	47		paletteGeneration uint64
48		paletteHints palette.ContextualHints	48		paletteHints palette.ContextualHints
49		palettePreview string	49		palettePreview string

@@ -309,7 +309,7 @@ type overlayRenderSnapshot struct {
309		paletteHints *palette.ContextualHints	309		paletteHints *palette.ContextualHints
310		palettePreview string	310		palettePreview string
311		paletteFeedback string	311		paletteFeedback string
312	-	paletteRouteSnapshot ports.RecentRouteSnapshot	312	+	paletteRouteSnapshot protocol.RecentRouteSnapshot
313		paletteLocked bool	313		paletteLocked bool
314			314
315		promptActive bool	315		promptActive bool

@@ -383,7 +383,7 @@ func (rt overlayRuntime) SnapshotForRender() overlayRenderSnapshot {
383		snap.palettePreview = rt.palettePreview	383		snap.palettePreview = rt.palettePreview
384		snap.paletteFeedback = rt.paletteFeedback	384		snap.paletteFeedback = rt.paletteFeedback
385		snap.paletteRouteSnapshot = rt.paletteRouteSnapshot	385		snap.paletteRouteSnapshot = rt.paletteRouteSnapshot
386	-	snap.paletteRouteSnapshot.Entries = append([]ports.RecentRouteEntry(nil), rt.paletteRouteSnapshot.Entries...)	386	+	snap.paletteRouteSnapshot.Entries = append([]protocol.RecentRouteEntry(nil), rt.paletteRouteSnapshot.Entries...)
387		snap.paletteLocked = true	387		snap.paletteLocked = true
388		} else {	388		} else {
389		rt.paletteMu.Unlock()	389		rt.paletteMu.Unlock()

M internal/usecase/daemon/palette.go +25 -24

 	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/usecase/command"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/palette"
 }
 type paletteSessionIdentity struct {
-	kind      ports.RouteKind
+	kind      protocol.RouteKind
 	endpoint  string
 	lifecycle domain.SessionLifecycleID
 }
 }
 func localPaletteSessionIdentity(lifecycle domain.SessionLifecycleID) paletteSessionIdentity {
-	return paletteSessionIdentity{kind: ports.RouteKindLocal, endpoint: "local", lifecycle: lifecycle}
+	return paletteSessionIdentity{kind: protocol.RouteKindLocal, endpoint: "local", lifecycle: lifecycle}
 }
 func remotePaletteSessionIdentity(endpoint string, lifecycle domain.SessionLifecycleID) paletteSessionIdentity {
-	return paletteSessionIdentity{kind: ports.RouteKindRemote, endpoint: endpoint, lifecycle: lifecycle}
+	return paletteSessionIdentity{kind: protocol.RouteKindRemote, endpoint: endpoint, lifecycle: lifecycle}
 }
 func paletteRemoteDisplayOrigin(hostLabel string) string {
 	return origin
 }
-func paletteDaemonDisplayOrigin(snapshot ports.RecentRouteSnapshot, lifecycle domain.SessionLifecycleID) string {
+func paletteDaemonDisplayOrigin(snapshot protocol.RecentRouteSnapshot, lifecycle domain.SessionLifecycleID) string {
 	active, ok := activeRouteEntryForLifecycle(snapshot, lifecycle)
-	if !ok || active.Kind != ports.RouteKindRemote {
+	if !ok || active.Kind != protocol.RouteKindRemote {
 		return ""
 	}
 	return paletteRemoteDisplayOrigin(active.HostLabel)
 }
-func paletteRouteRepresentsDaemonSession(entry ports.RecentRouteEntry, daemonDisplayOrigin string) bool {
+func paletteRouteRepresentsDaemonSession(entry protocol.RecentRouteEntry, daemonDisplayOrigin string) bool {
-	if entry.Kind == ports.RouteKindLocal {
+	if entry.Kind == protocol.RouteKindLocal {
 		return true
 	}
-	return entry.Kind == ports.RouteKindRemote && daemonDisplayOrigin != "" &&
+	return entry.Kind == protocol.RouteKindRemote && daemonDisplayOrigin != "" &&
 		paletteRemoteDisplayOrigin(entry.HostLabel) == daemonDisplayOrigin
 }
 // paletteResults captures eligible named sessions before paletteMu so the
 // palette has an immutable lifecycle target without violating lock ordering.
-func (d *Daemon) paletteResults(current *session, commands []command.Command, routeSnapshot ports.RecentRouteSnapshot) []palette.Result {
+func (d *Daemon) paletteResults(current *session, commands []command.Command, routeSnapshot protocol.RecentRouteSnapshot) []palette.Result {
 	d.mu.Lock()
 	sessions := d.sessionsSnapshotLocked()
 	stopped := make([]inactiveSession, 0, len(d.inactive))
 		if candidate == current {
 			continue
 		}
-		target := ports.ExactSessionTarget{LifecycleID: snap.incarnation, SessionName: snap.name}
+		target := protocol.ExactSessionTarget{LifecycleID: snap.incarnation, SessionName: snap.name}
 		active = append(active, palette.NewActiveSessionResultWithDisplayOrigin(target, time.Unix(0, snap.createdAt), daemonDisplayOrigin))
 	}
 	sort.Slice(active, func(i, j int) bool {
 	sort.Slice(stopped, func(i, j int) bool { return stopped[i].name < stopped[j].name })
 	results = append(results, active...)
 	for _, candidate := range stopped {
-		target := ports.ExactSessionTarget{LifecycleID: candidate.incarnation, SessionName: candidate.name}
+		target := protocol.ExactSessionTarget{LifecycleID: candidate.incarnation, SessionName: candidate.name}
 		results = append(results, palette.NewStoppedSessionResultWithDisplayOrigin(target, time.Unix(0, candidate.createdAt), daemonDisplayOrigin))
 		represented[localPaletteSessionIdentity(target.LifecycleID)] = struct{}{}
 	}
 		if _, exists := represented[identity]; exists && paletteRouteRepresentsDaemonSession(entry, daemonDisplayOrigin) {
 			continue
 		}
-		results = append(results, palette.NewRecentRouteResult(label, ports.RouteNavigationAction{
+		results = append(results, palette.NewRecentRouteResult(label, protocol.RouteNavigationAction{
 			SnapshotGeneration: routeSnapshot.Generation,
 			Key:                entry.Key,
 			Generation:         entry.Generation,
 		}))
-		if entry.Kind == ports.RouteKindLocal {
+		if entry.Kind == protocol.RouteKindLocal {
 			represented[identity] = struct{}{}
 			continue
 		}
 	model := rt.palette
 	generation := rt.paletteGeneration
 	routeSnapshot := rt.paletteRouteSnapshot
-	routeSnapshot.Entries = append([]ports.RecentRouteEntry(nil), routeSnapshot.Entries...)
+	routeSnapshot.Entries = append([]protocol.RecentRouteEntry(nil), routeSnapshot.Entries...)
 	rt.paletteMu.Unlock()
 	if model == nil {
 		return
 	model.ReplaceResults(results)
 }
-func recentRouteHints(snapshot ports.RecentRouteSnapshot, args []string) palette.ContextualHints {
+func recentRouteHints(snapshot protocol.RecentRouteSnapshot, args []string) palette.ContextualHints {
 	formatted := formatRecentRouteSnapshot(snapshot)
 	names := make([]string, len(formatted))
 	for i, entry := range formatted {
 	var remoteKey domain.RemoteSessionKey
 	var remoteUnavailableReason string
 	var hasRemoteTarget bool
-	var routeTarget ports.RouteNavigationAction
+	var routeTarget protocol.RouteNavigationAction
 	var hasRouteTarget bool
 	var args []string
-	var routeSnapshot ports.RecentRouteSnapshot
+	var routeSnapshot protocol.RecentRouteSnapshot
 	var generation uint64
 	var rawQuery string
 	changed, cancel, execute := false, false, false
 				}
 				if cmd.ContextHint == command.ContextHintRecentSessions {
 					routeSnapshot = ac.overlays.paletteRouteSnapshot
-					routeSnapshot.Entries = append([]ports.RecentRouteEntry(nil), routeSnapshot.Entries...)
+					routeSnapshot.Entries = append([]protocol.RecentRouteEntry(nil), routeSnapshot.Entries...)
 				}
 			} else if target, ok := selected.RemoteSessionTarget(); ok {
 				key, keyOK := selected.RemoteSessionKey()
 	model := ac.overlays.palette
 	ac.overlays.paletteGeneration++
 	ac.overlays.palette = nil
-	ac.overlays.paletteRouteSnapshot = ports.RecentRouteSnapshot{}
+	ac.overlays.paletteRouteSnapshot = protocol.RecentRouteSnapshot{}
 	ac.overlays.paletteHints = palette.ContextualHints{}
 	ac.overlays.palettePreview = ""
 	ac.overlays.paletteFeedback = ""
 	sess                *session
 	attachment          *session
 	ac                  *attachedClient
-	routeSnapshot       ports.RecentRouteSnapshot
+	routeSnapshot       protocol.RecentRouteSnapshot
 	actions             daemonActionRunner
 	effect              *attachmentEffect
 	redrawClosedPalette bool
 }
 func (e paletteExec) OpenSessionPicker() error {
-	if e.ac != nil && e.ac.navigationCapabilities&ports.NavigationCapabilityHomePicker != 0 && e.effect != nil {
+	if e.ac != nil && e.ac.navigationCapabilities&protocol.NavigationCapabilityHomePicker != 0 && e.effect != nil {
-		return e.d.sendNavigationActionForAttachment(e.effect, ports.NavigationOpenHomePicker)
+		return e.d.sendNavigationActionForAttachment(e.effect, protocol.NavigationOpenHomePicker)
 	}
 	e.d.enterPicker(e.sess, e.ac)
 	return nil
 		return command.ErrInvalidArguments
 	}
 	entry := e.routeSnapshot.Entries[rank-1]
-	return e.NavigateRecentRoute(ports.RouteNavigationAction{
+	return e.NavigateRecentRoute(protocol.RouteNavigationAction{
 		SnapshotGeneration: e.routeSnapshot.Generation,
 		Key:                entry.Key,
 		Generation:         entry.Generation,
 	})
 }
-func (e paletteExec) NavigateRecentRoute(action ports.RouteNavigationAction) error {
+func (e paletteExec) NavigateRecentRoute(action protocol.RouteNavigationAction) error {
 	if e.d.beforeRecentSessionHandoff != nil {
 		e.d.beforeRecentSessionHandoff()
 	}

M internal/usecase/daemon/palette_test.go +54 -53

 	"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/usecase/command"
 	"github.com/bnema/vev/internal/usecase/palette"
 	"github.com/bnema/vev/internal/usecase/picker"
 	"github.com/bnema/vev/internal/usecase/ui"
 )
-func testRecentRouteSnapshot() ports.RecentRouteSnapshot {
+func testRecentRouteSnapshot() protocol.RecentRouteSnapshot {
-	return ports.RecentRouteSnapshot{
+	return protocol.RecentRouteSnapshot{
 		Generation:  1,
-		Active:      ports.RouteRef{Key: 1, Generation: 1},
+		Active:      protocol.RouteRef{Key: 1, Generation: 1},
-		ActiveEntry: testRouteEntry(1, 1, "current", 1, ports.RouteKindLocal),
+		ActiveEntry: testRouteEntry(1, 1, "current", 1, protocol.RouteKindLocal),
-		Entries: []ports.RecentRouteEntry{
+		Entries: []protocol.RecentRouteEntry{
-			testRouteEntry(2, 1, "recent", 2, ports.RouteKindLocal),
+			testRouteEntry(2, 1, "recent", 2, protocol.RouteKindLocal),
-			testRouteEntry(3, 1, "older", 3, ports.RouteKindLocal),
+			testRouteEntry(3, 1, "older", 3, protocol.RouteKindLocal),
 		},
 	}
 }
 	d.inactive["purging"] = inactiveSession{name: "purging", createdAt: 13, incarnation: domain.IncarnationID{4}, state: ports.SessionDown, purging: true}
 	d.inactive["broken"] = inactiveSession{name: "broken", createdAt: 14, incarnation: domain.IncarnationID{5}, state: ports.SessionBroken}
 	d.inactive["degraded"] = inactiveSession{name: "degraded", createdAt: 15, incarnation: domain.IncarnationID{6}, state: ports.SessionDown, record: domain.CatalogueRecord{DegradedReason: "checkpoint unavailable"}}
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1, Entries: []ports.RecentRouteEntry{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1, Entries: []protocol.RecentRouteEntry{
-		testRouteEntry(1, 1, "purging", 4, ports.RouteKindLocal),
+		testRouteEntry(1, 1, "purging", 4, protocol.RouteKindLocal),
-		testRouteEntry(2, 1, "broken", 5, ports.RouteKindLocal),
+		testRouteEntry(2, 1, "broken", 5, protocol.RouteKindLocal),
-		testRouteEntry(3, 1, "degraded", 6, ports.RouteKindLocal),
+		testRouteEntry(3, 1, "degraded", 6, protocol.RouteKindLocal),
 	}})
 	d.enterPalette(current, ac)
 	p, release := newBlockingPTY(t)
 	defer release()
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1, Active: ports.RouteRef{Key: 1, Generation: 1}})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1, Active: protocol.RouteRef{Key: 1, Generation: 1}})
 	d.handleInput(sess, ac, []byte("\x1b "))
 	awaitFrame(t, sends, ports.MsgOutput)
 	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
 	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 1, Key: 2, Generation: 1}, action)
+	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.remoteCatalog.status["user@arch"] = remoteHostFresh
 	d.remoteCatalog.mu.Unlock()
-	results := d.paletteResults(current, nil, ports.RecentRouteSnapshot{})
+	results := d.paletteResults(current, nil, protocol.RecentRouteSnapshot{})
 	var matching []palette.Result
 	for _, result := range results {
 		if result.DisplayText() == "Switch to session vev" || result.DisplayText() == "Switch to session vev@arch" {
 	target.ephemeral = false
 	target.incarnation = domain.SessionLifecycleID{42}
-	results := d.paletteResults(current, nil, ports.RecentRouteSnapshot{
+	results := d.paletteResults(current, nil, protocol.RecentRouteSnapshot{
 		Generation: 1,
-		Active:     ports.RouteRef{Key: 1, Generation: 1},
+		Active:     protocol.RouteRef{Key: 1, Generation: 1},
-		ActiveEntry: ports.RecentRouteEntry{
+		ActiveEntry: protocol.RecentRouteEntry{
 			Key: 1, Generation: 1,
-			Target: ports.ExactSessionTarget{LifecycleID: current.incarnation, SessionName: "current"},
+			Target: protocol.ExactSessionTarget{LifecycleID: current.incarnation, SessionName: "current"},
-			Name:   "current", HostLabel: "user@remote-host", Kind: ports.RouteKindRemote,
+			Name:   "current", HostLabel: "user@remote-host", Kind: protocol.RouteKindRemote,
 		},
-		Entries: []ports.RecentRouteEntry{{
+		Entries: []protocol.RecentRouteEntry{{
 			Key: 2, Generation: 1,
-			Target: ports.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: "target"},
+			Target: protocol.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: "target"},
-			Name:   "target", HostLabel: "user@remote-host", Kind: ports.RouteKindRemote,
+			Name:   "target", HostLabel: "user@remote-host", Kind: protocol.RouteKindRemote,
 		}},
 	})
 	require.Len(t, matching, 1)
 	got, ok := matching[0].SessionTarget()
 	require.True(t, ok)
-	require.Equal(t, ports.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: "target"}, got)
+	require.Equal(t, protocol.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: "target"}, got)
 }
 func TestPaletteMatchesRecentRemoteRouteToCatalog(t *testing.T) {
 			}
 			d.remoteCatalog.mu.Unlock()
-			results := d.paletteResults(current, nil, ports.RecentRouteSnapshot{
+			results := d.paletteResults(current, nil, protocol.RecentRouteSnapshot{
 				Generation: 2,
-				Entries: []ports.RecentRouteEntry{{
+				Entries: []protocol.RecentRouteEntry{{
 					Key: 3, Generation: 1,
-					Target: ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "vev"},
+					Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "vev"},
-					Name:   "vev", HostLabel: "arch", Kind: ports.RouteKindRemote,
+					Name:   "vev", HostLabel: "arch", Kind: protocol.RouteKindRemote,
 				}},
 			})
-			var actions []ports.RouteNavigationAction
+			var actions []protocol.RouteNavigationAction
 			var catalogEndpoints []string
 			for _, result := range results {
 				if result.DisplayText() != "Switch to session vev@arch" {
 				require.True(t, ok)
 				catalogEndpoints = append(catalogEndpoints, target.Endpoint)
 			}
-			require.Equal(t, []ports.RouteNavigationAction{{
+			require.Equal(t, []protocol.RouteNavigationAction{{
 				SnapshotGeneration: 2, Key: 3, Generation: 1,
 			}}, actions)
 			require.ElementsMatch(t, test.wantCatalogEndpoints, catalogEndpoints)
 	local := addControlSession(d, "vev", "tab-2", "pane-2")
 	local.ephemeral = false
 	local.incarnation = domain.SessionLifecycleID{2}
-	remoteOne := ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{21}, SessionName: "vev"}
+	remoteOne := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{21}, SessionName: "vev"}
-	remoteTwo := ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{22}, SessionName: "vev"}
+	remoteTwo := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{22}, SessionName: "vev"}
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation: 2,
-		Entries: []ports.RecentRouteEntry{
+		Entries: []protocol.RecentRouteEntry{
-			{Key: 1, Generation: 1, Target: ports.ExactSessionTarget{LifecycleID: current.incarnation, SessionName: "hi"}, Name: "hi", Kind: ports.RouteKindLocal},
+			{Key: 1, Generation: 1, Target: protocol.ExactSessionTarget{LifecycleID: current.incarnation, SessionName: "hi"}, Name: "hi", Kind: protocol.RouteKindLocal},
-			{Key: 2, Generation: 1, Target: ports.ExactSessionTarget{LifecycleID: local.incarnation, SessionName: "vev"}, Name: "vev", Kind: ports.RouteKindLocal},
+			{Key: 2, Generation: 1, Target: protocol.ExactSessionTarget{LifecycleID: local.incarnation, SessionName: "vev"}, Name: "vev", Kind: protocol.RouteKindLocal},
-			{Key: 3, Generation: 1, Target: remoteOne, Name: "vev", HostLabel: "arch", Kind: ports.RouteKindRemote},
+			{Key: 3, Generation: 1, Target: remoteOne, Name: "vev", HostLabel: "arch", Kind: protocol.RouteKindRemote},
-			{Key: 4, Generation: 1, Target: remoteTwo, Name: "vev", HostLabel: "arch", Kind: ports.RouteKindRemote},
+			{Key: 4, Generation: 1, Target: remoteTwo, Name: "vev", HostLabel: "arch", Kind: protocol.RouteKindRemote},
 		},
 	}
 	results := d.paletteResults(current, nil, snapshot)
-	var sessionTargets []ports.ExactSessionTarget
+	var sessionTargets []protocol.ExactSessionTarget
-	var routeActions []ports.RouteNavigationAction
+	var routeActions []protocol.RouteNavigationAction
 	for _, result := range results {
 		if target, ok := result.SessionTarget(); ok {
 			sessionTargets = append(sessionTargets, target)
 			routeActions = append(routeActions, action)
 		}
 	}
-	require.Equal(t, []ports.ExactSessionTarget{{LifecycleID: local.incarnation, SessionName: "vev"}}, sessionTargets)
+	require.Equal(t, []protocol.ExactSessionTarget{{LifecycleID: local.incarnation, SessionName: "vev"}}, sessionTargets)
-	require.Equal(t, []ports.RouteNavigationAction{
+	require.Equal(t, []protocol.RouteNavigationAction{
 		{SnapshotGeneration: 2, Key: 3, Generation: 1},
 		{SnapshotGeneration: 2, Key: 4, Generation: 1},
 	}, routeActions)
 func TestPaletteFuzzyRemoteRecentRouteSendsExactNavigationAction(t *testing.T) {
 	d, current, ac, sends, releases := newRecentNavigationTestSessions(t)
 	defer releaseAll(releases)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation:  9,
-		Active:      ports.RouteRef{Key: 1, Generation: 1},
+		Active:      protocol.RouteRef{Key: 1, Generation: 1},
-		ActiveEntry: testRouteEntry(1, 1, current.name, 1, ports.RouteKindLocal),
+		ActiveEntry: testRouteEntry(1, 1, current.name, 1, protocol.RouteKindLocal),
-		Entries: []ports.RecentRouteEntry{{
+		Entries: []protocol.RecentRouteEntry{{
-			Key: 8, Generation: 4, Target: testRouteTarget("logs", 8), Name: "logs", HostLabel: "edge", Kind: ports.RouteKindRemote,
+			Key: 8, Generation: 4, Target: testRouteTarget("logs", 8), Name: "logs", HostLabel: "edge", Kind: protocol.RouteKindRemote,
 		}},
 	})
 	token := beginRecentRoutePaletteEffect(t, d, current, ac)
 	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
 	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 9, Key: 8, Generation: 4}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 9, Key: 8, Generation: 4}, action)
 	require.False(t, ac.overlays.paletteActive())
 }
 	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
 	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 1, Key: 2, Generation: 1}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 1, Key: 2, Generation: 1}, action)
 	require.Same(t, current, ac.currentSession())
 	require.False(t, ac.overlays.paletteActive())
 }
 	p, release := newBlockingPTY(t)
 	defer release()
 	d, sess, ac, sends := newManualSessionWithPTYs(t, p)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation:  7,
-		Active:      ports.RouteRef{Key: 1, Generation: 1},
+		Active:      protocol.RouteRef{Key: 1, Generation: 1},
-		ActiveEntry: testRouteEntry(1, 1, sess.name, 1, ports.RouteKindLocal),
+		ActiveEntry: testRouteEntry(1, 1, sess.name, 1, protocol.RouteKindLocal),
-		Entries:     []ports.RecentRouteEntry{testRouteEntry(9, 4, "captured", 9, ports.RouteKindLocal)},
+		Entries:     []protocol.RecentRouteEntry{testRouteEntry(9, 4, "captured", 9, protocol.RouteKindLocal)},
 	})
 	validated := make(chan struct{})
 	actionFrame := awaitFrame(t, sends, ports.MsgNavigateRecentRoute)
 	action, err := ports.UnmarshalRouteNavigationAction(actionFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 7, Key: 9, Generation: 4}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 7, Key: 9, Generation: 4}, action)
 	require.False(t, ac.overlays.paletteActive())
 }

M internal/usecase/daemon/parked_route.go +52 -51

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 const parkedRouteLeaseTTL = 15 * time.Minute
 type parkedRouteLease struct {
-	id         ports.ParkedRouteLeaseID
+	id         protocol.ParkedRouteLeaseID
 	generation uint64
 	transport  transportSnapshot
 	expiresAt  time.Time
 	expired    bool
 }
-func (lease *parkedRouteLease) matches(id ports.ParkedRouteLeaseID, generation uint64, transport transportSnapshot) bool {
+func (lease *parkedRouteLease) matches(id protocol.ParkedRouteLeaseID, generation uint64, transport transportSnapshot) bool {
 	return lease != nil && lease.id == id && lease.generation == generation && lease.transport == transport
 }
-func newParkedRouteLeaseID() (ports.ParkedRouteLeaseID, error) {
+func newParkedRouteLeaseID() (protocol.ParkedRouteLeaseID, error) {
-	var id ports.ParkedRouteLeaseID
+	var id protocol.ParkedRouteLeaseID
 	if _, err := io.ReadFull(rand.Reader, id[:]); err != nil {
-		return ports.ParkedRouteLeaseID{}, err
+		return protocol.ParkedRouteLeaseID{}, err
 	}
 	return id, nil
 }
 	}
 }
-func (d *Daemon) armParkedRoute(effect *attachmentEffect) (ports.ParkedRouteLeaseID, error) {
+func (d *Daemon) armParkedRoute(effect *attachmentEffect) (protocol.ParkedRouteLeaseID, error) {
 	if !effect.current() {
-		return ports.ParkedRouteLeaseID{}, errAttachmentTransition
+		return protocol.ParkedRouteLeaseID{}, errAttachmentTransition
 	}
 	ac := effect.ac
-	if ac == nil || ac.navigationCapabilities&ports.NavigationCapabilityHomePicker == 0 {
+	if ac == nil || ac.navigationCapabilities&protocol.NavigationCapabilityHomePicker == 0 {
-		return ports.ParkedRouteLeaseID{}, errAttachmentTransition
+		return protocol.ParkedRouteLeaseID{}, errAttachmentTransition
 	}
 	id, err := newParkedRouteLeaseID()
 	if err != nil {
-		return ports.ParkedRouteLeaseID{}, err
+		return protocol.ParkedRouteLeaseID{}, err
 	}
 	lease := &parkedRouteLease{
 		id: id, generation: effect.generation, transport: effect.transport,
 	ac.parkedRouteMu.Unlock()
 }
-func (ac *attachedClient) parkedRouteStatus(token attachmentCapability, id ports.ParkedRouteLeaseID, now time.Time, suspended bool) ports.ParkedRouteStatus {
+func (ac *attachedClient) parkedRouteStatus(token attachmentCapability, id protocol.ParkedRouteLeaseID, now time.Time, suspended bool) protocol.ParkedRouteStatus {
 	if ac == nil || !token.current() {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	ac.parkedRouteMu.Lock()
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, token.generation, token.transport) {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	if !now.Before(lease.expiresAt) {
 		stopParkedRouteLeaseLocked(lease)
 		ac.parkedRoute = nil
 		ac.parkedRouteOutput.Store(false)
 		ac.parkedRouteFullPending.Store(false)
-		return ports.ParkedRouteExpired
+		return protocol.ParkedRouteExpired
 	}
 	if lease.suspended != suspended {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	return 0
 }
-func (ac *attachedClient) prepareParkedRoute(token attachmentCapability, id ports.ParkedRouteLeaseID, now time.Time) ports.ParkedRouteStatus {
+func (ac *attachedClient) prepareParkedRoute(token attachmentCapability, id protocol.ParkedRouteLeaseID, now time.Time) protocol.ParkedRouteStatus {
 	if status := ac.parkedRouteStatus(token, id, now, false); status != 0 {
 		return status
 	}
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, token.generation, token.transport) || lease.suspended {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	lease.suspended = true
 	ac.parkedRouteOutput.Store(true)
 	return 0
 }
-func (ac *attachedClient) consumeParkedRoute(token attachmentCapability, id ports.ParkedRouteLeaseID, now time.Time) ports.ParkedRouteStatus {
+func (ac *attachedClient) consumeParkedRoute(token attachmentCapability, id protocol.ParkedRouteLeaseID, now time.Time) protocol.ParkedRouteStatus {
 	if status := ac.parkedRouteStatus(token, id, now, true); status != 0 {
 		return status
 	}
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, token.generation, token.transport) || !lease.suspended || lease.inFlight {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	stopParkedRouteLeaseLocked(lease)
 	ac.parkedRoute = nil
 	return 0
 }
-func (ac *attachedClient) beginParkedRouteSwitch(token attachmentCapability, id ports.ParkedRouteLeaseID, now time.Time) ports.ParkedRouteStatus {
+func (ac *attachedClient) beginParkedRouteSwitch(token attachmentCapability, id protocol.ParkedRouteLeaseID, now time.Time) protocol.ParkedRouteStatus {
 	if ac == nil || !token.current() {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	ac.parkedRouteMu.Lock()
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, token.generation, token.transport) || !lease.suspended || lease.inFlight {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	if lease.expired || !now.Before(lease.expiresAt) {
 		stopParkedRouteLeaseLocked(lease)
 		ac.parkedRoute = nil
 		ac.parkedRouteOutput.Store(false)
 		ac.parkedRouteFullPending.Store(false)
-		return ports.ParkedRouteExpired
+		return protocol.ParkedRouteExpired
 	}
 	lease.inFlight = true
 	return 0
 }
-func (ac *attachedClient) rejectParkedRouteSwitch(token attachmentCapability, id ports.ParkedRouteLeaseID, now time.Time) ports.ParkedRouteStatus {
+func (ac *attachedClient) rejectParkedRouteSwitch(token attachmentCapability, id protocol.ParkedRouteLeaseID, now time.Time) protocol.ParkedRouteStatus {
 	if ac == nil {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	ac.parkedRouteMu.Lock()
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, token.generation, token.transport) || !lease.inFlight {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	lease.inFlight = false
 	if lease.expired || !now.Before(lease.expiresAt) {
 		ac.parkedRoute = nil
 		ac.parkedRouteOutput.Store(false)
 		ac.parkedRouteFullPending.Store(false)
-		return ports.ParkedRouteExpired
+		return protocol.ParkedRouteExpired
 	}
 	return 0
 }
-func (ac *attachedClient) consumePublishedParkedRoute(previous, published attachmentCapability, id ports.ParkedRouteLeaseID) ports.ParkedRouteStatus {
+func (ac *attachedClient) consumePublishedParkedRoute(previous, published attachmentCapability, id protocol.ParkedRouteLeaseID) protocol.ParkedRouteStatus {
 	if ac == nil || published.ac != ac || !published.current() {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	ac.parkedRouteMu.Lock()
 	defer ac.parkedRouteMu.Unlock()
 	lease := ac.parkedRoute
 	if !lease.matches(id, previous.generation, previous.transport) || !lease.suspended || !lease.inFlight {
-		return ports.ParkedRouteRejected
+		return protocol.ParkedRouteRejected
 	}
 	// Expiry is checked when the request is admitted. Once publication starts,
 	// the accepted request must commit atomically instead of turning a completed
 	return 0
 }
-func parkedRouteResponseFrame(response ports.ParkedRouteResponse) (ports.Frame, error) {
+func parkedRouteResponseFrame(response protocol.ParkedRouteResponse) (ports.Frame, error) {
 	payload := ports.MarshalParkedRouteResponse(response)
 	if payload == nil {
 		return ports.Frame{}, errAttachmentTransition
 	return ports.Frame{Type: ports.MsgParkedRouteResponse, Payload: payload}, nil
 }
-func (d *Daemon) sendParkedRouteResponse(effect *attachmentEffect, response ports.ParkedRouteResponse) error {
+func (d *Daemon) sendParkedRouteResponse(effect *attachmentEffect, response protocol.ParkedRouteResponse) error {
 	frame, err := parkedRouteResponseFrame(response)
 	if err != nil {
 		return err
 // sendParkedRouteResponseLocked preserves response -> full-output ordering.
 // Caller holds ac.sendMu and keeps parkedRouteOutput set through this send.
-func (d *Daemon) sendParkedRouteResponseLocked(ac *attachedClient, expected transportSnapshot, response ports.ParkedRouteResponse) error {
+func (d *Daemon) sendParkedRouteResponseLocked(ac *attachedClient, expected transportSnapshot, response protocol.ParkedRouteResponse) error {
 	frame, err := parkedRouteResponseFrame(response)
 	if err != nil {
 		return err
 	launch()
 }
-func (d *Daemon) respondParkedRoute(effect *attachmentEffect, response ports.ParkedRouteResponse) bool {
+func (d *Daemon) respondParkedRoute(effect *attachmentEffect, response protocol.ParkedRouteResponse) bool {
 	if effect == nil || effect.ac == nil {
 		return false
 	}
 	return true
 }
-func (d *Daemon) handleParkedRouteRequest(effect *attachmentEffect, request ports.ParkedRouteRequest) {
+func (d *Daemon) handleParkedRouteRequest(effect *attachmentEffect, request protocol.ParkedRouteRequest) {
-	if ports.ValidateParkedRouteRequest(request) != nil || !effect.current() || effect.ac == nil {
+	if protocol.ValidateParkedRouteRequest(request) != nil || !effect.current() || effect.ac == nil {
 		return
 	}
 	capability := effect.capability()
 	switch request.Action {
-	case ports.ParkedRoutePrepare:
+	case protocol.ParkedRoutePrepare:
 		status := effect.ac.prepareParkedRoute(capability, request.LeaseID, d.clock.Now())
 		if status == 0 {
-			status = ports.ParkedRouteReady
+			status = protocol.ParkedRouteReady
 		}
-		d.respondParkedRoute(effect, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: status})
+		d.respondParkedRoute(effect, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: status})
-	case ports.ParkedRouteResume:
+	case protocol.ParkedRouteResume:
 		d.resumeParkedRoute(effect, request)
-	case ports.ParkedRouteSwitch:
+	case protocol.ParkedRouteSwitch:
 		d.switchParkedRoute(effect, request)
 	}
 }
-func (d *Daemon) resumeParkedRoute(effect *attachmentEffect, request ports.ParkedRouteRequest) {
+func (d *Daemon) resumeParkedRoute(effect *attachmentEffect, request protocol.ParkedRouteRequest) {
 	capability := effect.capability()
 	status := effect.ac.consumeParkedRoute(capability, request.LeaseID, d.clock.Now())
 	if status != 0 {
-		d.respondParkedRoute(effect, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: status})
+		d.respondParkedRoute(effect, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: status})
 		return
 	}
 	ac := effect.ac
 	ac.sendMu.Lock()
-	err := d.sendParkedRouteResponseLocked(ac, effect.transport, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: ports.ParkedRouteResumed})
+	err := d.sendParkedRouteResponseLocked(ac, effect.transport, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: protocol.ParkedRouteResumed})
 	if err == nil {
 		ac.releaseParkedOutputLocked()
 	}
 	}
 }
-func (d *Daemon) rejectParkedRouteSwitch(effect *attachmentEffect, request ports.ParkedRouteRequest, fallback ports.ParkedRouteStatus) {
+func (d *Daemon) rejectParkedRouteSwitch(effect *attachmentEffect, request protocol.ParkedRouteRequest, fallback protocol.ParkedRouteStatus) {
 	capability := effect.capability()
 	status := effect.ac.rejectParkedRouteSwitch(capability, request.LeaseID, d.clock.Now())
 	if status == 0 {
 		status = fallback
 	}
-	if d.respondParkedRoute(effect, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: status}) && status == ports.ParkedRouteExpired {
+	if d.respondParkedRoute(effect, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: status}) && status == protocol.ParkedRouteExpired {
 		_ = effect.ac.closeCapturedTransport(effect.transport.transport)
 	}
 }
-func (d *Daemon) switchParkedRoute(effect *attachmentEffect, request ports.ParkedRouteRequest) {
+func (d *Daemon) switchParkedRoute(effect *attachmentEffect, request protocol.ParkedRouteRequest) {
 	capability := effect.capability()
 	if status := effect.ac.beginParkedRouteSwitch(capability, request.LeaseID, d.clock.Now()); status != 0 {
-		if d.respondParkedRoute(effect, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: status}) && status == ports.ParkedRouteExpired {
+		if d.respondParkedRoute(effect, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: status}) && status == protocol.ParkedRouteExpired {
 			_ = effect.ac.closeCapturedTransport(effect.transport.transport)
 		}
 		return
 		ctx = context.Background()
 	}
 	if err := d.waitForParkedTargetRestore(ctx, target.SessionName); err != nil {
-		d.rejectParkedRouteSwitch(effect, request, ports.ParkedRouteStaleTarget)
+		d.rejectParkedRouteSwitch(effect, request, protocol.ParkedRouteStaleTarget)
 		return
 	}
 	transition, targetSession, err := d.transitionParkedRouteTarget(effect, target)
 	if err != nil {
-		d.rejectParkedRouteSwitch(effect, request, ports.ParkedRouteStaleTarget)
+		d.rejectParkedRouteSwitch(effect, request, protocol.ParkedRouteStaleTarget)
 		return
 	}
 	if status := effect.ac.consumePublishedParkedRoute(capability, transition.published, request.LeaseID); status != 0 {
 	freshCapability := fresh.capability()
 	ac := effect.ac
 	ac.sendMu.Lock()
-	responseErr := d.sendParkedRouteResponseLocked(ac, freshCapability.transport, ports.ParkedRouteResponse{RequestID: request.RequestID, Status: ports.ParkedRouteSwitched})
+	responseErr := d.sendParkedRouteResponseLocked(ac, freshCapability.transport, protocol.ParkedRouteResponse{RequestID: request.RequestID, Status: protocol.ParkedRouteSwitched})
 	if responseErr == nil {
 		ac.releaseParkedOutputLocked()
 	}

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

 	"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"
 )
 type parkedRouteFailTransport struct{}
 	c.mu.Unlock()
 }
-func armAndPrepareParkedRoute(t *testing.T, d *Daemon, source *session, ac *attachedClient, sends chan ports.Frame) ports.ParkedRouteLeaseID {
+func armAndPrepareParkedRoute(t *testing.T, d *Daemon, source *session, ac *attachedClient, sends chan ports.Frame) protocol.ParkedRouteLeaseID {
 	t.Helper()
-	ac.navigationCapabilities |= ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities |= protocol.NavigationCapabilityHomePicker
 	token := source.captureAttachmentCapability(ac, ac.transport())
 	effect, admitted := ac.beginAttachmentEffect(token)
 	require.True(t, admitted)
-	require.NoError(t, d.sendNavigationActionForAttachment(effect, ports.NavigationOpenHomePicker))
+	require.NoError(t, d.sendNavigationActionForAttachment(effect, protocol.NavigationOpenHomePicker))
 	effect.End()
 	directiveFrame := awaitFrame(t, sends, ports.MsgNavigationAction)
 	directive, err := ports.UnmarshalNavigationDirective(directiveFrame.Payload)
 	require.NoError(t, err)
-	prepare := ports.ParkedRouteRequest{RequestID: 1, LeaseID: directive.LeaseID, Action: ports.ParkedRoutePrepare}
+	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)}))
 	readyFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	ready, err := ports.UnmarshalParkedRouteResponse(readyFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady}, ready)
+	require.Equal(t, protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady}, ready)
 	return directive.LeaseID
 }
 func TestParkedRouteSwitchesExactLiveTargetOnRetainedTransport(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	targetLifecycle := domain.SessionLifecycleID{7}
 	target := &session{
 	d.mu.Lock()
 	d.sessions[target.id] = target
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 	require.True(t, ac.parkedRouteOutput.Load())
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: targetLifecycle,
 		SessionName: "target", LiveTabID: domain.TabStableID(target.tabs[0].stableID),
 	}
-	switchRequest := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteSwitch, Target: &targetRequest}
+	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.Same(t, target, ac.currentAttachmentSession())
 	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteResponse{RequestID: 2, Status: ports.ParkedRouteSwitched}, response)
+	require.Equal(t, protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}, response)
 }
 func TestParkedRouteSwitchAcceptedBeforeLeaseExpiryCommitsAtomically(t *testing.T) {
 	defer releaseAll(releases)
 	clock := &parkedRouteClock{}
 	d.clock = clock
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	targetLifecycle := domain.SessionLifecycleID{7}
 	target := &session{
 	d.mu.Lock()
 	d.sessions[target.id] = target
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 	d.afterAttachmentEffectsFrozen = func() {
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: targetLifecycle,
 		SessionName: "target", LiveTabID: domain.TabStableID(target.tabs[0].stableID),
 	}
-	switchRequest := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteSwitch, Target: &targetRequest}
+	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)})
 	require.Same(t, target, ac.currentAttachmentSession())
 	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteSwitched, response.Status)
+	require.Equal(t, protocol.ParkedRouteSwitched, response.Status)
 }
 func TestParkedRouteRestoresExactStoppedTargetWithDaemonEnvironment(t *testing.T) {
 	d := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})
 	d.baseEnv = []string{"OWNER=daemon"}
 	source, ac, sends := addRemoteRefreshPickerOwner(t, d, "source")
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	source.mu.Lock()
 	source.env = []string{"OWNER=source"}
 	source.mu.Unlock()
 		},
 	}
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: lifecycle,
 		SessionName: "stopped", Stopped: true, StoppedTab: domain.NewStableTabSelector("tab-b"),
 	}
-	switchRequest := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteSwitch, Target: &target}
+	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)})
 	restored := ac.currentAttachmentSession()
 func TestParkedRouteStaleTargetLeavesSourceResumable(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: domain.SessionLifecycleID{9},
 		SessionName: "missing", LiveTabID: "tab-1",
 	}
-	switchRequest := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteSwitch, Target: &missing}
+	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)})
 	staleFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	stale, err := ports.UnmarshalParkedRouteResponse(staleFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteStaleTarget, stale.Status)
+	require.Equal(t, protocol.ParkedRouteStaleTarget, stale.Status)
 	require.Same(t, source, ac.currentAttachmentSession())
 	require.True(t, ac.parkedRouteOutput.Load())
-	resume := ports.ParkedRouteRequest{RequestID: 3, LeaseID: leaseID, Action: ports.ParkedRouteResume}
+	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)})
 	resumedFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	resumed, err := ports.UnmarshalParkedRouteResponse(resumedFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteResumed, resumed.Status)
+	require.Equal(t, protocol.ParkedRouteResumed, resumed.Status)
 	require.False(t, ac.parkedRouteOutput.Load())
 	outputFrame := awaitFrame(t, sends, ports.MsgOutput)
 	output, err := ports.UnmarshalOutput(outputFrame.Payload)
 func TestParkedRouteDoesNotReplayOneShotEffectsAfterResume(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 	require.NoError(t, d.boundedSendOutputErr(ac, []byte("one-shot effect")))
 	default:
 	}
-	resume := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteResume}
+	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)})
 	_ = awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	outputFrame := awaitFrame(t, sends, ports.MsgOutput)
 func TestParkedRouteExpiredLeaseFailsClosed(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 	ac.parkedRouteMu.Lock()
 	ac.parkedRoute.expiresAt = d.clock.Now()
 	ac.parkedRouteMu.Unlock()
-	resume := ports.ParkedRouteRequest{RequestID: 2, LeaseID: leaseID, Action: ports.ParkedRouteResume}
+	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)})
 	responseFrame := awaitFrame(t, sends, ports.MsgParkedRouteResponse)
 	response, err := ports.UnmarshalParkedRouteResponse(responseFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ParkedRouteExpired, response.Status)
+	require.Equal(t, protocol.ParkedRouteExpired, response.Status)
 	require.Same(t, source, ac.currentAttachmentSession())
 	require.False(t, ac.parkedRouteOutput.Load())
 }
 func TestParkedRouteResumeRejectsSwitchInFlight(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	leaseID := armAndPrepareParkedRoute(t, d, source, ac, sends)
 	ac.parkedRouteMu.Lock()
 	ac.parkedRouteMu.Unlock()
 	status := ac.consumeParkedRoute(source.captureAttachmentCapability(ac, ac.transport()), leaseID, d.clock.Now())
-	require.Equal(t, ports.ParkedRouteRejected, status)
+	require.Equal(t, protocol.ParkedRouteRejected, status)
 	ac.parkedRouteMu.Lock()
 	require.NotNil(t, ac.parkedRoute)
 	ac.parkedRouteMu.Unlock()
 func TestParkedRouteMalformedSwitchRequestsFailClosed(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	leaseID := ports.ParkedRouteLeaseID{1}
+	leaseID := protocol.ParkedRouteLeaseID{1}
-	for _, request := range []ports.ParkedRouteRequest{
+	for _, request := range []protocol.ParkedRouteRequest{
-		{RequestID: 1, LeaseID: leaseID, Action: ports.ParkedRouteSwitch},
+		{RequestID: 1, LeaseID: leaseID, Action: protocol.ParkedRouteSwitch},
-		{RequestID: 2, Action: ports.ParkedRouteSwitch, Target: &domain.RemoteSessionTarget{}},
+		{RequestID: 2, Action: protocol.ParkedRouteSwitch, Target: &domain.RemoteSessionTarget{}},
 		{RequestID: 3, LeaseID: leaseID, Action: 99},
 	} {
 		capability := source.captureAttachmentCapability(ac, ac.transport())
 	result := make(chan bool, 1)
 	go func() {
-		result <- d.respondParkedRoute(effect, ports.ParkedRouteResponse{RequestID: 1, Status: ports.ParkedRouteReady})
+		result <- d.respondParkedRoute(effect, protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})
 	}()
 	require.False(t, awaitTestValue(t, result, "parked-route send failure cleanup"))
 	d.attachmentCleanupWg.Wait()
 func TestParkedRouteDetachClearsLeaseAndSuspension(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+	ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 	_ = armAndPrepareParkedRoute(t, d, source, ac, sends)
 	require.True(t, ac.parkedRouteOutput.Load())

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

 	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/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/picker"
 	"github.com/bnema/vev/internal/usecase/ui"
 	committing := (result.action == '\r' || result.action == '\n') && ok
 	backNavigationSent := false
 	if result.exit && !committing {
-		back := ac.startupOverlay == ports.StartupOverlaySessionPicker && ac.navigationCapabilities&ports.NavigationCapabilityBack != 0
+		back := ac.startupOverlay == protocol.StartupOverlaySessionPicker && ac.navigationCapabilities&protocol.NavigationCapabilityBack != 0
 		if back {
 			if len(effects) == 0 || effects[0] == nil {
 				d.invalidateRender(sess, ac, true, "picker.go")
 				return
 			}
 			effect := effects[0]
-			if err := d.sendNavigationActionForAttachment(effect, ports.NavigationBack); err != nil {
+			if err := d.sendNavigationActionForAttachment(effect, protocol.NavigationBack); err != nil {
 				d.reportAttachmentError(sess, err)
 				d.invalidateRender(sess, ac, true, "picker.go")
 				return
 	if width <= 0 || height <= 0 {
 		return 0, 0
 	}
-	return uint16(min(width, ports.RemotePreviewMaxWidth)), uint16(min(height, ports.RemotePreviewMaxHeight))
+	return uint16(min(width, protocol.RemotePreviewMaxWidth)), uint16(min(height, protocol.RemotePreviewMaxHeight))
 }
 func staticRemotePickerPreview(width, height uint16, message string) picker.Preview {
 	d.mu.Lock()
 	var targetSess *session
 	var sessionName string
-	var exactTarget *ports.ExactSessionTarget
+	var exactTarget *protocol.ExactSessionTarget
 	var matches bool
 	if target.Name != "" {
 		var stopped inactiveSession
 		targetSess, stopped, stoppedTarget, matches = d.resolveNamedLifecycleTargetLocked(target)
 		if stoppedTarget && matches {
 			sessionName = stopped.name
-			exactTarget = &ports.ExactSessionTarget{LifecycleID: stopped.incarnation, SessionName: sessionName}
+			exactTarget = &protocol.ExactSessionTarget{LifecycleID: stopped.incarnation, SessionName: sessionName}
 		}
 	} else {
 		targetSess = d.sessions[target.Session]
 	if matches && targetSess != nil {
 		targetSess.mu.Lock()
 		sessionName = targetSess.name
-		exactTarget = &ports.ExactSessionTarget{LifecycleID: targetSess.incarnation, SessionName: sessionName}
+		exactTarget = &protocol.ExactSessionTarget{LifecycleID: targetSess.incarnation, SessionName: sessionName}
 		targetSess.mu.Unlock()
 	}
 	d.mu.Unlock()

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

 	"github.com/bnema/vev/internal/persist"
 	"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/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/picker"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 	const sendErr = "navigation back send failed"
 	tr := &remotePickerSendErrorTransport{err: errors.New(sendErr)}
 	ac.replaceTransport(tr)
-	ac.startupOverlay = ports.StartupOverlaySessionPicker
+	ac.startupOverlay = protocol.StartupOverlaySessionPicker
-	ac.navigationCapabilities = ports.NavigationCapabilityBack
+	ac.navigationCapabilities = protocol.NavigationCapabilityBack
 	ac.overlays.pickerMu.Lock()
 	ac.overlays.picker = picker.New(nil, picker.SelectionConfig{})
 	ac.overlays.pickerGeneration++
 		t.Run(tc.name, func(t *testing.T) {
 			d, sess, ac, _, releases := newManualTabSession(t, 1)
 			defer releases[0]()
-			ac.startupOverlay = ports.StartupOverlaySessionPicker
+			ac.startupOverlay = protocol.StartupOverlaySessionPicker
-			ac.navigationCapabilities = ports.NavigationCapabilityBack
+			ac.navigationCapabilities = protocol.NavigationCapabilityBack
 			ac.overlays.pickerMu.Lock()
 			ac.overlays.picker = picker.New([]picker.SessionView{{ID: sess.id, Name: sess.name, Tabs: []picker.TabEntry{{Name: "tab"}}, Active: 0}}, picker.SelectionConfig{})
 			ac.overlays.pickerGeneration++

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


@@ -3,7 +3,7 @@ package daemon
3		import (	3		import (
4		"testing"	4		"testing"
5			5
6	-	"github.com/bnema/vev/internal/ports"	6	+	"github.com/bnema/vev/internal/protocol"
7		"github.com/bnema/vev/internal/usecase/command"	7		"github.com/bnema/vev/internal/usecase/command"
8		"github.com/bnema/vev/internal/usecase/palette"	8		"github.com/bnema/vev/internal/usecase/palette"
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"

@@ -76,11 +76,11 @@ func TestFormatRecentRoutePresentations(t *testing.T) {
76		}	76		}
77			77
78		func TestRecentSessionHintsAndRankedRenderingShareCanonicalLabels(t *testing.T) {	78		func TestRecentSessionHintsAndRankedRenderingShareCanonicalLabels(t *testing.T) {
79	-	snapshot := ports.RecentRouteSnapshot{	79	+	snapshot := protocol.RecentRouteSnapshot{
80		Generation: 1,	80		Generation: 1,
81	-	Entries: []ports.RecentRouteEntry{	81	+	Entries: []protocol.RecentRouteEntry{
82	-	{Key: 1, Generation: 1, Target: testRouteTarget("logs", 1), Name: "logs", Kind: ports.RouteKindLocal, Attention: true},	82	+	{Key: 1, Generation: 1, Target: testRouteTarget("logs", 1), Name: "logs", Kind: protocol.RouteKindLocal, Attention: true},
83	-	testRouteEntry(2, 1, "logs", 2, ports.RouteKindLocal),	83	+	testRouteEntry(2, 1, "logs", 2, protocol.RouteKindLocal),
84		},	84		},
85		}	85		}
86			86

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


@@ -2,26 +2,26 @@ package daemon
2			2
3		import (	3		import (
4		"github.com/bnema/vev/internal/domain"	4		"github.com/bnema/vev/internal/domain"
5	-	"github.com/bnema/vev/internal/ports"	5	+	"github.com/bnema/vev/internal/protocol"
6		)	6		)
7			7
8	-	func activeRouteEntryForLifecycle(snapshot ports.RecentRouteSnapshot, lifecycle domain.SessionLifecycleID) (ports.RecentRouteEntry, bool) {	8	+	func activeRouteEntryForLifecycle(snapshot protocol.RecentRouteSnapshot, lifecycle domain.SessionLifecycleID) (protocol.RecentRouteEntry, bool) {
9		active := snapshot.ActiveEntry	9		active := snapshot.ActiveEntry
10	-	activeRef := ports.RouteRef{Key: active.Key, Generation: active.Generation}	10	+	activeRef := protocol.RouteRef{Key: active.Key, Generation: active.Generation}
11		if lifecycle == (domain.SessionLifecycleID{}) \|\| active.Target.LifecycleID != lifecycle \|\| snapshot.Active != activeRef {	11		if lifecycle == (domain.SessionLifecycleID{}) \|\| active.Target.LifecycleID != lifecycle \|\| snapshot.Active != activeRef {
12	-	return ports.RecentRouteEntry{}, false	12	+	return protocol.RecentRouteEntry{}, false
13		}	13		}
14		return active, true	14		return active, true
15		}	15		}
16			16
17	-	func recentRoutePresentationsFromSnapshot(snapshot ports.RecentRouteSnapshot) []recentRoutePresentation {	17	+	func recentRoutePresentationsFromSnapshot(snapshot protocol.RecentRouteSnapshot) []recentRoutePresentation {
18		if snapshot.Entries == nil {	18		if snapshot.Entries == nil {
19		return nil	19		return nil
20		}	20		}
21		out := make([]recentRoutePresentation, len(snapshot.Entries))	21		out := make([]recentRoutePresentation, len(snapshot.Entries))
22		for i, entry := range snapshot.Entries {	22		for i, entry := range snapshot.Entries {
23		kind := recentRouteLocal	23		kind := recentRouteLocal
24	-	if entry.Kind == ports.RouteKindRemote {	24	+	if entry.Kind == protocol.RouteKindRemote {
25		kind = recentRouteRemote	25		kind = recentRouteRemote
26		}	26		}
27		out[i] = recentRoutePresentation{	27		out[i] = recentRoutePresentation{

@@ -35,20 +35,20 @@ func recentRoutePresentationsFromSnapshot(snapshot ports.RecentRouteSnapshot) []
35		return out	35		return out
36		}	36		}
37			37
38	-	func formatRecentRouteSnapshot(snapshot ports.RecentRouteSnapshot) []recentRouteDisplay {	38	+	func formatRecentRouteSnapshot(snapshot protocol.RecentRouteSnapshot) []recentRouteDisplay {
39		return formatRecentRoutePresentations(recentRoutePresentationsFromSnapshot(snapshot))	39		return formatRecentRoutePresentations(recentRoutePresentationsFromSnapshot(snapshot))
40		}	40		}
41			41
42		// formatRecentRouteSnapshotForAttachment resolves attention against this	42		// formatRecentRouteSnapshotForAttachment resolves attention against this
43		// daemon's live sessions. The client retains route ordering and presentation;	43		// daemon's live sessions. The client retains route ordering and presentation;
44		// it subscribes only the exact routes this daemon serves.	44		// it subscribes only the exact routes this daemon serves.
45	-	func (d Daemon) formatRecentRouteSnapshotForAttachment(ac attachedClient, snapshot ports.RecentRouteSnapshot) []recentRouteDisplay {	45	+	func (d Daemon) formatRecentRouteSnapshotForAttachment(ac attachedClient, snapshot protocol.RecentRouteSnapshot) []recentRouteDisplay {
46		presentations := recentRoutePresentationsFromSnapshot(snapshot)	46		presentations := recentRoutePresentationsFromSnapshot(snapshot)
47		if d == nil \|\| ac == nil {	47		if d == nil \|\| ac == nil {
48		return formatRecentRoutePresentations(presentations)	48		return formatRecentRoutePresentations(presentations)
49		}	49		}
50		for i, entry := range snapshot.Entries {	50		for i, entry := range snapshot.Entries {
51	-	target, ok := ac.routeAttentionTarget(ports.RouteRef{Key: entry.Key, Generation: entry.Generation})	51	+	target, ok := ac.routeAttentionTarget(protocol.RouteRef{Key: entry.Key, Generation: entry.Generation})
52		if ok {	52		if ok {
53		presentations[i].attention = d.routeHasAttention(target)	53		presentations[i].attention = d.routeHasAttention(target)
54		}	54		}

@@ -56,7 +56,7 @@ func (d Daemon) formatRecentRouteSnapshotForAttachment(ac attachedClient, snap
56		return formatRecentRoutePresentations(presentations)	56		return formatRecentRoutePresentations(presentations)
57		}	57		}
58			58
59	-	func (d *Daemon) routeHasAttention(target ports.ExactSessionTarget) bool {	59	+	func (d *Daemon) routeHasAttention(target protocol.ExactSessionTarget) bool {
60		d.mu.Lock()	60		d.mu.Lock()
61		sess := d.findByNameLocked(target.SessionName)	61		sess := d.findByNameLocked(target.SessionName)
62		d.mu.Unlock()	62		d.mu.Unlock()

M internal/usecase/daemon/recent_route_snapshot_test.go +25 -24

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 func TestAttachmentStatusUsesClientRouteSnapshot(t *testing.T) {
 	d, sess, ac, _ := newManualSessionWithPTYs(t, nil)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation: 2,
-		Active:     ports.RouteRef{Key: 3, Generation: 2},
+		Active:     protocol.RouteRef{Key: 3, Generation: 2},
-		Entries: []ports.RecentRouteEntry{
+		Entries: []protocol.RecentRouteEntry{
-			{Key: 2, Generation: 1, Target: testRouteTarget("logs", 2), Name: "logs", HostLabel: "user@edge", Kind: ports.RouteKindRemote},
+			{Key: 2, Generation: 1, Target: testRouteTarget("logs", 2), Name: "logs", HostLabel: "user@edge", Kind: protocol.RouteKindRemote},
-			testRouteEntry(1, 1, "work", 1, ports.RouteKindLocal),
+			testRouteEntry(1, 1, "work", 1, protocol.RouteKindLocal),
 		},
 	})
-	state := d.barStateForAttachmentPaletteHintsFor(sess, ac, "", nil, ports.RecentRouteSnapshot{})
+	state := d.barStateForAttachmentPaletteHintsFor(sess, ac, "", nil, protocol.RecentRouteSnapshot{})
 	require.Len(t, state.mru, 2)
 	require.Equal(t, []string{"logs@edge", "work"}, []string{state.mru[0].name, state.mru[1].name})
 			sess.incarnation = domain.SessionLifecycleID{9}
 			sess.tabs[0].attention = true
 			sess.mu.Unlock()
-			ref := ports.RouteRef{Key: 2, Generation: 1}
+			ref := protocol.RouteRef{Key: 2, Generation: 1}
-			ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+			ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 				Generation: 2,
-				Active:     ports.RouteRef{Key: 3, Generation: 2},
+				Active:     protocol.RouteRef{Key: 3, Generation: 2},
-				Entries:    []ports.RecentRouteEntry{{Key: ref.Key, Generation: ref.Generation, Target: ports.ExactSessionTarget{LifecycleID: tt.targetID, SessionName: sess.name}, Name: sess.name, Kind: ports.RouteKindLocal}},
+				Entries:    []protocol.RecentRouteEntry{{Key: ref.Key, Generation: ref.Generation, Target: protocol.ExactSessionTarget{LifecycleID: tt.targetID, SessionName: sess.name}, Name: sess.name, Kind: protocol.RouteKindLocal}},
 			})
-			ac.setRouteAttentionSubscription(ports.RouteAttentionSubscription{Targets: []ports.RouteAttentionTarget{{
+			ac.setRouteAttentionSubscription(protocol.RouteAttentionSubscription{Targets: []protocol.RouteAttentionTarget{{
 				Ref: ref,
-				Target: ports.ExactSessionTarget{
+				Target: protocol.ExactSessionTarget{
 					LifecycleID: tt.targetID,
 					SessionName: sess.name,
 				},
 			}}})
-			state := d.barStateForAttachmentPaletteHintsFor(sess, ac, "", nil, ports.RecentRouteSnapshot{})
+			state := d.barStateForAttachmentPaletteHintsFor(sess, ac, "", nil, protocol.RecentRouteSnapshot{})
 			require.Len(t, state.mru, 1)
 			require.Equal(t, tt.attention, state.mru[0].attention)
 	d, sess, ac, sends := newManualSessionWithPTYs(t, nil)
 	token := sess.captureAttachmentCapability(ac, ac.transport())
 	ac.installTestAttachmentCapability(token)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
-	payload, err := ports.MarshalRecentRouteSnapshot(ports.RecentRouteSnapshot{Generation: 2})
+	payload, err := ports.MarshalRecentRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 2})
 	require.NoError(t, err)
 	require.False(t, d.handleAttachmentClientFrame(token, ports.Frame{Type: ports.MsgRecentRouteSnapshot, Payload: payload}))
 func TestAttachmentRouteSnapshotCopiesPublishedEntries(t *testing.T) {
 	_, _, ac, _ := newManualSessionWithPTYs(t, nil)
-	entries := []ports.RecentRouteEntry{testRouteEntry(1, 2, "before", 1, ports.RouteKindLocal)}
+	entries := []protocol.RecentRouteEntry{testRouteEntry(1, 2, "before", 1, protocol.RouteKindLocal)}
-	snapshot := ports.RecentRouteSnapshot{Generation: 3, Entries: entries}
+	snapshot := protocol.RecentRouteSnapshot{Generation: 3, Entries: entries}
 	ac.setRouteSnapshot(snapshot)
 	entries[0].Name = "after"
 	exec := paletteExec{
 		d: d, sess: source, attachment: source, ac: ac,
-		routeSnapshot: ports.RecentRouteSnapshot{
+		routeSnapshot: protocol.RecentRouteSnapshot{
 			Generation: 4,
-			Entries:    []ports.RecentRouteEntry{testRouteEntry(2, 3, "remote", 2, ports.RouteKindRemote)},
+			Entries:    []protocol.RecentRouteEntry{testRouteEntry(2, 3, "remote", 2, protocol.RouteKindRemote)},
 		},
 		effect: effect,
 	}
 	require.NoError(t, exec.JumpRecentSession(1))
 	frames := transport.Sends()
-	var action ports.RouteNavigationAction
+	var action protocol.RouteNavigationAction
 	found := false
 	for _, frame := range frames {
 		if frame.Type != ports.MsgNavigateRecentRoute {
 		found = true
 	}
 	require.True(t, found)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 3}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 4, Key: 2, Generation: 3}, action)
 }
 func TestRecentRouteHintsRetainSnapshotSelectionIdentity(t *testing.T) {
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation: 8,
-		Entries: []ports.RecentRouteEntry{{
+		Entries: []protocol.RecentRouteEntry{{
-			Key: 11, Generation: 7, Target: testRouteTarget("logs", 11), Name: "logs", HostLabel: "edge", Kind: ports.RouteKindRemote,
+			Key: 11, Generation: 7, Target: testRouteTarget("logs", 11), Name: "logs", HostLabel: "edge", Kind: protocol.RouteKindRemote,
 		}},
 	}

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // routeRemoteTargetWithContext is the exact-target branch for picker handoffs.
 		return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote target requires attach or resume"}
 	}
 	if err := d.waitForTargetRestore(ctx, target.SessionName); err != nil {
-		var protocol *protoErr
+		var protocolErr *protoErr
-		if errors.As(err, &protocol) && protocol.code == ports.ErrInternal {
+		if errors.As(err, &protocolErr) && protocolErr.code == ports.ErrInternal {
 			return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote session is unavailable"}
 		}
 		return nil, nil, remoteTargetError(err)
 	return d.createSessionLockedWithModeAndInactiveFence(target.SessionName, false, cwd, geometry, env, &expected, validate, expected.tabNames)
 }
-func (d *Daemon) sendNavigationActionForAttachment(effect *attachmentEffect, action ports.NavigationAction) error {
+func (d *Daemon) sendNavigationActionForAttachment(effect *attachmentEffect, action protocol.NavigationAction) error {
-	directive := ports.NavigationDirective{Action: action}
+	directive := protocol.NavigationDirective{Action: action}
 	armed := false
-	if action == ports.NavigationOpenHomePicker {
+	if action == protocol.NavigationOpenHomePicker {
 		leaseID, err := d.armParkedRoute(effect)
 		if err != nil {
 			return err
 	return nil
 }
-func (d *Daemon) sendRecentRouteNavigationActionForAttachment(effect *attachmentEffect, action ports.RouteNavigationAction) error {
+func (d *Daemon) sendRecentRouteNavigationActionForAttachment(effect *attachmentEffect, action protocol.RouteNavigationAction) error {
 	payload, err := ports.MarshalRouteNavigationAction(action)
 	if err != nil {
 		return errAttachmentTransition
 		return errAttachmentTransition
 	}
 	effect.sess.mu.Lock()
-	identity := ports.CommittedRouteIdentity{
+	identity := protocol.CommittedRouteIdentity{
-		Target:    ports.ExactSessionTarget{LifecycleID: effect.sess.incarnation, SessionName: effect.sess.name},
+		Target:    protocol.ExactSessionTarget{LifecycleID: effect.sess.incarnation, SessionName: effect.sess.name},
 		Ephemeral: effect.sess.ephemeral,
 	}
 	effect.sess.mu.Unlock()
 }
 func remoteTargetError(err error) error {
-	var protocol *protoErr
+	var protocolErr *protoErr
-	if errors.As(err, &protocol) {
+	if errors.As(err, &protocolErr) {
-		return protocol
+		return protocolErr
 	}
 	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 		return err

M internal/usecase/daemon/remote_attach_test.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/usecase/picker"
 )
 	require.Empty(t, got.Endpoint)
 	require.Equal(t, ports.IntentAttach, got.Intent)
 	require.True(t, got.SamePeer)
-	require.Equal(t, &ports.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: target.name}, got.ExactTarget)
+	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: target.name}, got.ExactTarget)
 	require.Same(t, source, ac.currentAttachmentSession(), "the source remains attached until the client confirms the switch")
 }
 	target, err := ports.UnmarshalAttachTarget(handoff.Payload)
 	require.NoError(t, err)
 	require.False(t, target.SamePeer)
-	require.Equal(t, &ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "stopped"}, target.ExactTarget)
+	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "stopped"}, target.ExactTarget)
 	require.Same(t, source, ac.currentAttachmentSession(), "the source remains attached until the client receives the handoff and closes")
 	require.True(t, attachmentRegistered(source, ac))
 }

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

 	"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/usecase/picker"
 )
 func TestNavigationActionHandoffSendsBoundedAction(t *testing.T) {
 	tests := []struct {
 		name   string
-		action ports.NavigationAction
+		action protocol.NavigationAction
 	}{
-		{name: "home picker", action: ports.NavigationOpenHomePicker},
+		{name: "home picker", action: protocol.NavigationOpenHomePicker},
-		{name: "back", action: ports.NavigationBack},
+		{name: "back", action: protocol.NavigationBack},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			d := newRemotePickerDaemon(nil)
 			sess, ac, sends := addRemoteRefreshPickerOwner(t, d, "local")
-			if tt.action == ports.NavigationOpenHomePicker {
+			if tt.action == protocol.NavigationOpenHomePicker {
-				ac.navigationCapabilities = ports.NavigationCapabilityHomePicker
+				ac.navigationCapabilities = protocol.NavigationCapabilityHomePicker
 			}
 			token := sess.captureAttachmentCapability(ac, ac.transport())
 			effect, admitted := ac.beginAttachmentEffect(token)
 			directive, err := ports.UnmarshalNavigationDirective(frame.Payload)
 			require.NoError(t, err)
 			require.Equal(t, tt.action, directive.Action)
-			if tt.action == ports.NavigationOpenHomePicker {
+			if tt.action == protocol.NavigationOpenHomePicker {
 				require.False(t, directive.LeaseID.IsZero())
 			} else {
 				require.True(t, directive.LeaseID.IsZero())

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

 	renderer "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func (d *Daemon) handleRemotePreview(tr ports.Transport, frame ports.Frame) error {
 	defer func() { _ = tr.Close() }()
 	request, err := ports.UnmarshalRemotePreviewRequest(frame.Payload)
 	if err != nil {
-		return d.sendRemotePreview(tr, ports.RemotePreview{Version: ports.RemotePreviewSchemaVersion, Status: ports.RemotePreviewMalformed})
+		return d.sendRemotePreview(tr, protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewMalformed})
 	}
 	preview, err := d.captureRemotePreview(request)
 	if err != nil {
-		status := ports.RemotePreviewUnavailable
+		status := protocol.RemotePreviewUnavailable
 		if errors.Is(err, errRemotePreviewNoSuchTarget) {
-			status = ports.RemotePreviewNoSuchTarget
+			status = protocol.RemotePreviewNoSuchTarget
 		}
-		preview = ports.RemotePreview{Version: ports.RemotePreviewSchemaVersion, Status: status}
+		preview = protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: status}
 	}
 	return d.sendRemotePreview(tr, preview)
 }
-func (d *Daemon) sendRemotePreview(tr ports.Transport, preview ports.RemotePreview) error {
+func (d *Daemon) sendRemotePreview(tr ports.Transport, preview protocol.RemotePreview) error {
 	payload := ports.MarshalRemotePreview(preview)
 	if payload == nil {
-		payload = ports.MarshalRemotePreview(ports.RemotePreview{Version: ports.RemotePreviewSchemaVersion, Status: ports.RemotePreviewMalformed})
+		payload = ports.MarshalRemotePreview(protocol.RemotePreview{Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewMalformed})
 	}
 	return d.boundedControlSend(tr, ports.Frame{Type: ports.MsgRemotePreviewResponse, Payload: payload})
 }
 var errRemotePreviewNoSuchTarget = errors.New("daemon: remote preview target does not exist")
-func (d *Daemon) captureRemotePreview(request ports.RemotePreviewRequest) (ports.RemotePreview, error) {
+func (d *Daemon) captureRemotePreview(request protocol.RemotePreviewRequest) (protocol.RemotePreview, error) {
 	target := request.Target
 	d.mu.Lock()
 	sess := d.findByNameLocked(target.SessionName)
 	if sess == nil || sess.incarnation != target.LifecycleID {
 		d.mu.Unlock()
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	index, ok := remoteTargetTabIndexLocked(sess, target)
 	d.mu.Unlock()
 	if !ok {
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	sess.mu.Lock()
 	if index < 0 || index >= len(sess.tabs) {
 		sess.mu.Unlock()
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	tab := sess.tabs[index]
 	if tab == nil || domain.TabStableID(tab.stableID) != target.LiveTabID {
 		sess.mu.Unlock()
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	sess.mu.Unlock()
 	tab.mu.Lock()
 	pane := tab.focusedPane()
 	if pane == nil {
 		tab.mu.Unlock()
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	pane.mu.Lock()
 	if pane.screen == nil {
 		pane.mu.Unlock()
 		tab.mu.Unlock()
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	source := pane.screen.Frame.Clone()
 	revision := pane.syncGen
 	width := min(int(request.Width), source.Width)
 	height := min(int(request.Height), source.Height)
 	if width <= 0 || height <= 0 {
-		return ports.RemotePreview{}, errRemotePreviewNoSuchTarget
+		return protocol.RemotePreview{}, errRemotePreviewNoSuchTarget
 	}
 	startY, endY := source.Height-height, source.Height
 	if last := remotePreviewLastContentRow(source, width, startY, endY); last >= startY {
 			cells = append(cells, cell)
 		}
 	}
-	preview := ports.RemotePreview{
+	preview := protocol.RemotePreview{
-		Version:     ports.RemotePreviewSchemaVersion,
+		Version:     protocol.RemotePreviewSchemaVersion,
-		Status:      ports.RemotePreviewOK,
+		Status:      protocol.RemotePreviewOK,
 		LifecycleID: target.LifecycleID,
 		TabID:       target.LiveTabID,
 		Revision:    revision,
 		Height:      uint16(height),
 		Cells:       cells,
 	}
-	if err := ports.ValidateRemotePreview(preview); err != nil {
+	if err := protocol.ValidateRemotePreview(preview); err != nil {
 		// A crop must not split a wide cell. Return a safe unavailable response
 		// instead of exposing a malformed cell stream.
-		return ports.RemotePreview{}, err
+		return protocol.RemotePreview{}, err
 	}
 	return preview, nil
 }

M internal/usecase/daemon/remote_preview_cache.go +22 -22


@@ -9,7 +9,7 @@ import (
9		"time"	9		"time"
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"
13		)	13		)
14			14
15		const (	15		const (

@@ -34,14 +34,14 @@ type remotePreviewCacheKey struct {
34		}	34		}
35			35
36		type remotePreviewCacheEntry struct {	36		type remotePreviewCacheEntry struct {
37	-	Preview ports.RemotePreview	37	+	Preview protocol.RemotePreview
38		Fetched time.Time	38		Fetched time.Time
39		Used time.Time	39		Used time.Time
40		}	40		}
41			41
42		type remotePreviewFlight struct {	42		type remotePreviewFlight struct {
43		done chan struct{}	43		done chan struct{}
44	-	preview ports.RemotePreview	44	+	preview protocol.RemotePreview
45		err error	45		err error
46		}	46		}
47			47

@@ -53,7 +53,7 @@ type remotePreviewState struct {
53		slots chan struct{}	53		slots chan struct{}
54		}	54		}
55			55
56	-	func cloneRemotePreview(preview ports.RemotePreview) ports.RemotePreview {	56	+	func cloneRemotePreview(preview protocol.RemotePreview) protocol.RemotePreview {
57		preview.Cells = slices.Clone(preview.Cells)	57		preview.Cells = slices.Clone(preview.Cells)
58		return preview	58		return preview
59		}	59		}

@@ -82,24 +82,24 @@ func remotePreviewKeyFor(target domain.RemoteSessionTarget, width, height uint16
82		}	82		}
83		}	83		}
84			84
85	-	func (d *Daemon) fetchRemotePreview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (ports.RemotePreview, error) {	85	+	func (d *Daemon) fetchRemotePreview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error) {
86		if d == nil \|\| d.remotePreviewClient == nil {	86		if d == nil \|\| d.remotePreviewClient == nil {
87	-	return ports.RemotePreview{}, errors.New("remote preview client unavailable")	87	+	return protocol.RemotePreview{}, errors.New("remote preview client unavailable")
88		}	88		}
89		if ctx == nil {	89		if ctx == nil {
90		ctx = context.Background()	90		ctx = context.Background()
91		}	91		}
92		if err := ctx.Err(); err != nil {	92		if err := ctx.Err(); err != nil {
93	-	return ports.RemotePreview{}, err	93	+	return protocol.RemotePreview{}, err
94		}	94		}
95	-	request := ports.RemotePreviewRequest{	95	+	request := protocol.RemotePreviewRequest{
96	-	Version: ports.RemotePreviewSchemaVersion,	96	+	Version: protocol.RemotePreviewSchemaVersion,
97		Target: target,	97		Target: target,
98		Width: width,	98		Width: width,
99		Height: height,	99		Height: height,
100		}	100		}
101	-	if err := ports.ValidateRemotePreviewRequest(request); err != nil {	101	+	if err := protocol.ValidateRemotePreviewRequest(request); err != nil {
102	-	return ports.RemotePreview{}, err	102	+	return protocol.RemotePreview{}, err
103		}	103		}
104			104
105		key := remotePreviewKeyFor(target, width, height)	105		key := remotePreviewKeyFor(target, width, height)

@@ -139,7 +139,7 @@ func (d *Daemon) fetchRemotePreview(ctx context.Context, target domain.RemoteSes
139			139
140		if until, cooling := d.remotePreview.cooldowns[key]; cooling && now.Before(until) {	140		if until, cooling := d.remotePreview.cooldowns[key]; cooling && now.Before(until) {
141		d.remotePreview.mu.Unlock()	141		d.remotePreview.mu.Unlock()
142	-	return ports.RemotePreview{}, errRemotePreviewCooldown	142	+	return protocol.RemotePreview{}, errRemotePreviewCooldown
143		}	143		}
144		if flight := d.remotePreview.flights[key]; flight != nil {	144		if flight := d.remotePreview.flights[key]; flight != nil {
145		d.remotePreview.mu.Unlock()	145		d.remotePreview.mu.Unlock()

@@ -160,12 +160,12 @@ func (d *Daemon) remotePreviewContext() context.Context {
160		return context.Background()	160		return context.Background()
161		}	161		}
162			162
163	-	func waitRemotePreviewFlight(ctx context.Context, flight *remotePreviewFlight) (ports.RemotePreview, error) {	163	+	func waitRemotePreviewFlight(ctx context.Context, flight *remotePreviewFlight) (protocol.RemotePreview, error) {
164		select {	164		select {
165		case <-flight.done:	165		case <-flight.done:
166		return cloneRemotePreview(flight.preview), flight.err	166		return cloneRemotePreview(flight.preview), flight.err
167		case <-ctx.Done():	167		case <-ctx.Done():
168	-	return ports.RemotePreview{}, ctx.Err()	168	+	return protocol.RemotePreview{}, ctx.Err()
169		}	169		}
170		}	170		}
171			171

@@ -173,7 +173,7 @@ func waitRemotePreviewFlight(ctx context.Context, flight *remotePreviewFlight) (
173		// while still publishing the refreshed result once the same-key flight finishes.	173		// while still publishing the refreshed result once the same-key flight finishes.
174		// A completed flight is read from the cache without starting a second remote	174		// A completed flight is read from the cache without starting a second remote
175		// request.	175		// request.
176	-	func (d *Daemon) awaitRemotePreviewRefresh(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (ports.RemotePreview, error) {	176	+	func (d *Daemon) awaitRemotePreviewRefresh(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error) {
177		key := remotePreviewKeyFor(target, width, height)	177		key := remotePreviewKeyFor(target, width, height)
178		d.remotePreview.mu.Lock()	178		d.remotePreview.mu.Lock()
179		flight := d.remotePreview.flights[key]	179		flight := d.remotePreview.flights[key]

@@ -188,20 +188,20 @@ func (d *Daemon) runRemotePreviewFlight(ctx context.Context, key remotePreviewCa
188		select {	188		select {
189		case d.remotePreview.slots <- struct{}{}:	189		case d.remotePreview.slots <- struct{}{}:
190		case <-ctx.Done():	190		case <-ctx.Done():
191	-	d.finishRemotePreviewFlight(key, flight, ports.RemotePreview{}, ctx.Err())	191	+	d.finishRemotePreviewFlight(key, flight, protocol.RemotePreview{}, ctx.Err())
192		return	192		return
193		}	193		}
194	-	var preview ports.RemotePreview	194	+	var preview protocol.RemotePreview
195		var err error	195		var err error
196		defer func() {	196		defer func() {
197		if recovered := recover(); recovered != nil {	197		if recovered := recover(); recovered != nil {
198		err = fmt.Errorf("remote preview flight panicked: %v", recovered)	198		err = fmt.Errorf("remote preview flight panicked: %v", recovered)
199	-	preview = ports.RemotePreview{}	199	+	preview = protocol.RemotePreview{}
200		d.finishRemotePreviewFlight(key, flight, preview, err)	200		d.finishRemotePreviewFlight(key, flight, preview, err)
201		panic(recovered)	201		panic(recovered)
202		}	202		}
203		if err != nil {	203		if err != nil {
204	-	preview = ports.RemotePreview{}	204	+	preview = protocol.RemotePreview{}
205		}	205		}
206		d.finishRemotePreviewFlight(key, flight, preview, err)	206		d.finishRemotePreviewFlight(key, flight, preview, err)
207		}()	207		}()

@@ -209,9 +209,9 @@ func (d *Daemon) runRemotePreviewFlight(ctx context.Context, key remotePreviewCa
209			209
210		preview, err = d.remotePreviewClient.Preview(ctx, target, width, height)	210		preview, err = d.remotePreviewClient.Preview(ctx, target, width, height)
211		if err == nil {	211		if err == nil {
212	-	if validationErr := ports.ValidateRemotePreview(preview); validationErr != nil {	212	+	if validationErr := protocol.ValidateRemotePreview(preview); validationErr != nil {
213		err = validationErr	213		err = validationErr
214	-	} else if preview.Status != ports.RemotePreviewOK {	214	+	} else if preview.Status != protocol.RemotePreviewOK {
215		err = fmt.Errorf("remote preview returned status %d", preview.Status)	215		err = fmt.Errorf("remote preview returned status %d", preview.Status)
216		} else if preview.LifecycleID != target.LifecycleID \|\| preview.TabID != target.LiveTabID {	216		} else if preview.LifecycleID != target.LifecycleID \|\| preview.TabID != target.LiveTabID {
217		err = errors.New("remote preview identity changed")	217		err = errors.New("remote preview identity changed")

@@ -219,7 +219,7 @@ func (d *Daemon) runRemotePreviewFlight(ctx context.Context, key remotePreviewCa
219		}	219		}
220		}	220		}
221			221
222	-	func (d Daemon) finishRemotePreviewFlight(key remotePreviewCacheKey, flight remotePreviewFlight, preview ports.RemotePreview, err error) {	222	+	func (d Daemon) finishRemotePreviewFlight(key remotePreviewCacheKey, flight remotePreviewFlight, preview protocol.RemotePreview, err error) {
223		now := d.clock.Now()	223		now := d.clock.Now()
224		d.remotePreview.mu.Lock()	224		d.remotePreview.mu.Lock()
225		for cooldownKey, until := range d.remotePreview.cooldowns {	225		for cooldownKey, until := range d.remotePreview.cooldowns {

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

 	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/usecase/picker"
 )
 type remotePreviewTestClient struct {
 	mu             sync.Mutex
 	calls          int
-	result         ports.RemotePreview
+	result         protocol.RemotePreview
 	err            error
 	started        chan struct{}
 	finished       chan struct{}
 	finishedSignal bool
 }
-func (c *remotePreviewTestClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (ports.RemotePreview, error) {
+func (c *remotePreviewTestClient) Preview(ctx context.Context, target domain.RemoteSessionTarget, width, height uint16) (protocol.RemotePreview, error) {
 	c.mu.Lock()
 	c.calls++
 	c.lastTarget = target
 			select {
 			case <-release:
 			case <-ctx.Done():
-				return ports.RemotePreview{}, ctx.Err()
+				return protocol.RemotePreview{}, ctx.Err()
 			}
 		}
 	}
 	}
 }
-func remotePreviewCacheResult(target domain.RemoteSessionTarget, revision uint64) ports.RemotePreview {
+func remotePreviewCacheResult(target domain.RemoteSessionTarget, revision uint64) protocol.RemotePreview {
 	return remotePreviewCacheResultRune(target, revision, 'x')
 }
-func remotePreviewCacheResultRune(target domain.RemoteSessionTarget, revision uint64, value rune) ports.RemotePreview {
+func remotePreviewCacheResultRune(target domain.RemoteSessionTarget, revision uint64, value rune) protocol.RemotePreview {
-	return ports.RemotePreview{
+	return protocol.RemotePreview{
-		Version: ports.RemotePreviewSchemaVersion, Status: ports.RemotePreviewOK,
+		Version: protocol.RemotePreviewSchemaVersion, Status: protocol.RemotePreviewOK,
 		LifecycleID: target.LifecycleID, TabID: target.LiveTabID,
 		Revision: revision, Width: 1, Height: 1,
 		Cells: []renderer.Cell{{Rune: value, Style: renderer.DefaultStyle()}},
 	d.remotePreviewClient = client
 	firstDone := make(chan struct{})
-	var first ports.RemotePreview
+	var first protocol.RemotePreview
 	var firstErr error
 	go func() {
 		first, firstErr = d.fetchRemotePreview(context.Background(), target, 1, 1)
 	<-client.started
 	secondDone := make(chan struct{})
-	var second ports.RemotePreview
+	var second protocol.RemotePreview
 	var secondErr error
 	go func() {
 		second, secondErr = d.fetchRemotePreview(context.Background(), target, 1, 1)
 func TestFetchRemotePreviewAdapterTimeoutAppliesCooldown(t *testing.T) {
 	clock := &remotePreviewTestClock{now: time.Unix(250, 0)}
 	target := remotePreviewCacheTarget()
-	client := &remotePreviewTestClient{err: ports.ErrRemotePreviewTimeout}
+	client := &remotePreviewTestClient{err: protocol.ErrRemotePreviewTimeout}
 	d := newTestDaemon(t, nil, clock)
 	d.remotePreviewClient = client
 	_, firstErr := d.fetchRemotePreview(context.Background(), target, 1, 1)
-	require.ErrorIs(t, firstErr, ports.ErrRemotePreviewTimeout)
+	require.ErrorIs(t, firstErr, protocol.ErrRemotePreviewTimeout)
 	_, secondErr := d.fetchRemotePreview(context.Background(), target, 1, 1)
 	require.ErrorIs(t, secondErr, errRemotePreviewCooldown)
 	require.Equal(t, 1, client.Calls())
 	d := newTestDaemon(t, nil, clock)
 	d.remotePreviewClient = client
-	_, err := d.fetchRemotePreview(context.Background(), remotePreviewCacheTarget(), ports.RemotePreviewMaxWidth+1, 1)
+	_, err := d.fetchRemotePreview(context.Background(), remotePreviewCacheTarget(), protocol.RemotePreviewMaxWidth+1, 1)
-	require.ErrorIs(t, err, ports.ErrInvalidRemotePreviewRequest)
+	require.ErrorIs(t, err, protocol.ErrInvalidRemotePreviewRequest)
 	require.Zero(t, client.Calls())
 }

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


@@ -8,7 +8,7 @@ import (
8		vt "github.com/bnema/vev-vt"	8		vt "github.com/bnema/vev-vt"
9		renderer "github.com/bnema/vev-vt/ansi"	9		renderer "github.com/bnema/vev-vt/ansi"
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"
12		)	12		)
13			13
14		func TestCaptureRemotePreviewUsesBottomRowsForShorterPreview(t *testing.T) {	14		func TestCaptureRemotePreviewUsesBottomRowsForShorterPreview(t *testing.T) {

@@ -28,8 +28,8 @@ func TestCaptureRemotePreviewUsesBottomRowsForShorterPreview(t *testing.T) {
28		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,	28		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,
29		SessionName: "work", LiveTabID: "tab-1",	29		SessionName: "work", LiveTabID: "tab-1",
30		}	30		}
31	-	preview, err := d.captureRemotePreview(ports.RemotePreviewRequest{	31	+	preview, err := d.captureRemotePreview(protocol.RemotePreviewRequest{
32	-	Version: ports.RemotePreviewSchemaVersion, Target: target, Width: 1, Height: 2,	32	+	Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: 1, Height: 2,
33		})	33		})
34		require.NoError(t, err)	34		require.NoError(t, err)
35		require.Equal(t, []rune{'b', 'c'}, []rune{preview.Cells[0].Rune, preview.Cells[1].Rune})	35		require.Equal(t, []rune{'b', 'c'}, []rune{preview.Cells[0].Rune, preview.Cells[1].Rune})

@@ -112,8 +112,8 @@ func TestCaptureRemotePreviewCompactsBlankTail(t *testing.T) {
112		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,	112		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,
113		SessionName: "work", LiveTabID: "tab-1",	113		SessionName: "work", LiveTabID: "tab-1",
114		}	114		}
115	-	preview, err := d.captureRemotePreview(ports.RemotePreviewRequest{	115	+	preview, err := d.captureRemotePreview(protocol.RemotePreviewRequest{
116	-	Version: ports.RemotePreviewSchemaVersion, Target: target, Width: test.width, Height: test.height,	116	+	Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: test.width, Height: test.height,
117		})	117		})
118		require.NoError(t, err)	118		require.NoError(t, err)
119		require.Equal(t, test.wantHeight, preview.Height)	119		require.Equal(t, test.wantHeight, preview.Height)

@@ -156,13 +156,13 @@ func TestCaptureRemotePreviewDoesNotSplitWideRuneAtCropBoundary(t *testing.T) {
156		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,	156		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation,
157		SessionName: "work", LiveTabID: "tab-1",	157		SessionName: "work", LiveTabID: "tab-1",
158		}	158		}
159	-	preview, err := d.captureRemotePreview(ports.RemotePreviewRequest{	159	+	preview, err := d.captureRemotePreview(protocol.RemotePreviewRequest{
160	-	Version: ports.RemotePreviewSchemaVersion, Target: target, Width: 2, Height: 1,	160	+	Version: protocol.RemotePreviewSchemaVersion, Target: target, Width: 2, Height: 1,
161		})	161		})
162		require.NoError(t, err)	162		require.NoError(t, err)
163		require.Equal(t, uint16(2), preview.Width)	163		require.Equal(t, uint16(2), preview.Width)
164		require.Equal(t, rune(' '), preview.Cells[1].Rune, "a crop cannot expose a dangling wide rune")	164		require.Equal(t, rune(' '), preview.Cells[1].Rune, "a crop cannot expose a dangling wide rune")
165		require.False(t, preview.Cells[1].Continuation)	165		require.False(t, preview.Cells[1].Continuation)
166		require.True(t, preview.Cells[1].Style.Equal(style), "boundary replacement preserves the cell style")	166		require.True(t, preview.Cells[1].Style.Equal(style), "boundary replacement preserves the cell style")
167	-	require.NoError(t, ports.ValidateRemotePreview(preview))	167	+	require.NoError(t, protocol.ValidateRemotePreview(preview))
168		}	168		}

M internal/usecase/daemon/remote_route_test.go +9 -9


@@ -122,9 +122,9 @@ func TestFinishRouteAttachRollsBackCreatedSession(t *testing.T) {
122		// both success and error paths before returning.	122		// both success and error paths before returning.
123		d.mu.Lock()	123		d.mu.Lock()
124		_, err = d.finishRouteAttach(sess, &closeTrackingTransport{}, defaultSize, hello, true, true)	124		_, err = d.finishRouteAttach(sess, &closeTrackingTransport{}, defaultSize, hello, true, true)
125	-	var protocol *protoErr	125	+	var protocolErr *protoErr
126	-	require.ErrorAs(t, err, &protocol)	126	+	require.ErrorAs(t, err, &protocolErr)
127	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	127	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
128		d.mu.Lock()	128		d.mu.Lock()
129		_, retained := d.sessions[sess.id]	129		_, retained := d.sessions[sess.id]
130		d.mu.Unlock()	130		d.mu.Unlock()

@@ -146,9 +146,9 @@ func TestFinishRouteAttachPreservesConcurrentAttachment(t *testing.T) {
146		RemoteTarget: &missing, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	146		RemoteTarget: &missing, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
147		}, true, true)	147		}, true, true)
148			148
149	-	var protocol *protoErr	149	+	var protocolErr *protoErr
150	-	require.ErrorAs(t, err, &protocol)	150	+	require.ErrorAs(t, err, &protocolErr)
151	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	151	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
152		require.Same(t, sess, winner().currentAttachmentSession())	152		require.Same(t, sess, winner().currentAttachmentSession())
153		d.mu.Lock()	153		d.mu.Lock()
154		require.Same(t, sess, d.sessions[sess.id])	154		require.Same(t, sess, d.sessions[sess.id])

@@ -217,7 +217,7 @@ func TestRouteRemoteTargetRejectsSameNameReplacement(t *testing.T) {
217		target := domain.RemoteSessionTarget{Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: old, SessionName: "work", LiveTabID: "tab-new"}	217		target := domain.RemoteSessionTarget{Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: old, SessionName: "work", LiveTabID: "tab-new"}
218		hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}	218		hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}
219		_, _, err := d.routeWithContext(context.Background(), hello, tr)	219		_, _, err := d.routeWithContext(context.Background(), hello, tr)
220	-	var protocol *protoErr	220	+	var protocolErr *protoErr
221	-	require.ErrorAs(t, err, &protocol)	221	+	require.ErrorAs(t, err, &protocolErr)
222	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	222	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
223		}	223		}

M internal/usecase/daemon/remote_stopped_route_test.go +16 -16


@@ -30,9 +30,9 @@ func TestDaemonOwnedNoExactTargetRejectsNewAndEphemeral(t *testing.T) {
30		Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	30		Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
31		}	31		}
32		_, _, err := d.route(hello, &closeTrackingTransport{})	32		_, _, err := d.route(hello, &closeTrackingTransport{})
33	-	var protocol *protoErr	33	+	var protocolErr *protoErr
34	-	require.ErrorAs(t, err, &protocol)	34	+	require.ErrorAs(t, err, &protocolErr)
35	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	35	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
36		d.mu.Lock()	36		d.mu.Lock()
37		sessions := len(d.sessions)	37		sessions := len(d.sessions)
38		d.mu.Unlock()	38		d.mu.Unlock()

@@ -83,9 +83,9 @@ func TestRouteRemoteTargetRejectsLiveIntentForInactiveSession(t *testing.T) {
83		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	83		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
84		}, &closeTrackingTransport{})	84		}, &closeTrackingTransport{})
85			85
86	-	var protocol *protoErr	86	+	var protocolErr *protoErr
87	-	require.ErrorAs(t, err, &protocol)	87	+	require.ErrorAs(t, err, &protocolErr)
88	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	88	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
89		d.mu.Lock()	89		d.mu.Lock()
90		defer d.mu.Unlock()	90		defer d.mu.Unlock()
91		require.Empty(t, d.sessions)	91		require.Empty(t, d.sessions)

@@ -115,9 +115,9 @@ func TestRouteRemoteTargetMapsUnavailableInactiveStatesToNoSuchTarget(t *testing
115		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	115		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
116		}, &closeTrackingTransport{})	116		}, &closeTrackingTransport{})
117			117
118	-	var protocol *protoErr	118	+	var protocolErr *protoErr
119	-	require.ErrorAs(t, err, &protocol)	119	+	require.ErrorAs(t, err, &protocolErr)
120	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	120	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
121		})	121		})
122		}	122		}
123		}	123		}

@@ -138,9 +138,9 @@ func TestRouteRemoteTargetMapsConcurrentInactiveResumeToNoSuchTarget(t *testing.
138		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	138		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
139		}, &closeTrackingTransport{})	139		}, &closeTrackingTransport{})
140			140
141	-	var protocol *protoErr	141	+	var protocolErr *protoErr
142	-	require.ErrorAs(t, err, &protocol)	142	+	require.ErrorAs(t, err, &protocolErr)
143	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	143	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
144		}	144		}
145			145
146		func TestRouteRemoteTargetPreservesInactiveResumeFailures(t *testing.T) {	146		func TestRouteRemoteTargetPreservesInactiveResumeFailures(t *testing.T) {

@@ -172,8 +172,8 @@ func TestRouteRemoteTargetPreservesInactiveResumeFailures(t *testing.T) {
172			172
173		err := route(d, newTarget(record))	173		err := route(d, newTarget(record))
174		require.ErrorIs(t, err, cause)	174		require.ErrorIs(t, err, cause)
175	-	var protocol *protoErr	175	+	var protocolErr *protoErr
176	-	require.False(t, errors.As(err, &protocol))	176	+	require.False(t, errors.As(err, &protocolErr))
177		})	177		})
178			178
179		t.Run("catalogue read", func(t *testing.T) {	179		t.Run("catalogue read", func(t *testing.T) {

@@ -191,8 +191,8 @@ func TestRouteRemoteTargetPreservesInactiveResumeFailures(t *testing.T) {
191			191
192		err := route(d, newTarget(record))	192		err := route(d, newTarget(record))
193		require.ErrorIs(t, err, cause)	193		require.ErrorIs(t, err, cause)
194	-	var protocol *protoErr	194	+	var protocolErr *protoErr
195	-	require.False(t, errors.As(err, &protocol))	195	+	require.False(t, errors.As(err, &protocolErr))
196		})	196		})
197		}	197		}
198			198

M internal/usecase/daemon/render_coordinator_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"
 	"github.com/bnema/vev/internal/usecase/keys"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 			file: "client.go",
 			name: "client theme application",
 			run: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient) {
-				d.applyTheme(sess, ac, ports.Theme{TrueColor: true})
+				d.applyTheme(sess, ac, protocol.Theme{TrueColor: true})
 			},
 		},
 		{

M internal/usecase/daemon/render_pipeline.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"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/notices"
 	"github.com/bnema/vev/internal/usecase/palette"
 	}
 	entry.core().mu.Lock()
 	_, owned := entry.core().attachments[ac]
-	position := ports.RoutePosition{
+	position := protocol.RoutePosition{
-		Target: ports.ExactSessionTarget{
+		Target: protocol.ExactSessionTarget{
 			LifecycleID: entry.core().incarnation,
 			SessionName: entry.core().name,
 		},

M internal/usecase/daemon/resume_test.go +9 -9


@@ -101,9 +101,9 @@ func TestTokenlessResumeIsRejectedBeforeNameRouting(t *testing.T) {
101		d := newTestDaemon(t, nil, stubClock{})	101		d := newTestDaemon(t, nil, stubClock{})
102		tr, _ := newCapturingTransport(t)	102		tr, _ := newCapturingTransport(t)
103		_, _, err := d.route(helloResumeCapable(ports.IntentResume, "work", 0), tr)	103		_, _, err := d.route(helloResumeCapable(ports.IntentResume, "work", 0), tr)
104	-	var protocol *protoErr	104	+	var protocolErr *protoErr
105	-	require.ErrorAs(t, err, &protocol)	105	+	require.ErrorAs(t, err, &protocolErr)
106	-	require.Equal(t, ports.ErrNoSuchSession, protocol.code)	106	+	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)
107		d.mu.Lock()	107		d.mu.Lock()
108		sessionCount := len(d.sessions)	108		sessionCount := len(d.sessions)
109		d.mu.Unlock()	109		d.mu.Unlock()

@@ -126,9 +126,9 @@ func TestResumeRejectsMismatchedRemoteTargetBeforeOwnershipMutation(t *testing.T
126		resume.RemoteTarget = &target	126		resume.RemoteTarget = &target
127		resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned	127		resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
128		_, _, err = d.route(resume, &closeTrackingTransport{})	128		_, _, err = d.route(resume, &closeTrackingTransport{})
129	-	var protocol *protoErr	129	+	var protocolErr *protoErr
130	-	require.ErrorAs(t, err, &protocol)	130	+	require.ErrorAs(t, err, &protocolErr)
131	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	131	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
132		require.Same(t, oldTransport, ac.transport())	132		require.Same(t, oldTransport, ac.transport())
133		d.mu.Lock()	133		d.mu.Lock()
134		_, parked := d.parked[token]	134		_, parked := d.parked[token]

@@ -155,9 +155,9 @@ func TestParkedResumeRejectsMismatchedRemoteTargetBeforeClaim(t *testing.T) {
155		resume.RemoteTarget = &target	155		resume.RemoteTarget = &target
156		resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned	156		resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
157		_, _, err = d.route(resume, &closeTrackingTransport{})	157		_, _, err = d.route(resume, &closeTrackingTransport{})
158	-	var protocol *protoErr	158	+	var protocolErr *protoErr
159	-	require.ErrorAs(t, err, &protocol)	159	+	require.ErrorAs(t, err, &protocolErr)
160	-	require.Equal(t, ports.ErrNoSuchTarget, protocol.code)	160	+	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
161		d.mu.Lock()	161		d.mu.Lock()
162		parked := d.parked[token]	162		parked := d.parked[token]
163		claimed := parked != nil && parked.claimed	163		claimed := parked != nil && parked.claimed

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


@@ -2,15 +2,15 @@ package daemon
2			2
3		import (	3		import (
4		"github.com/bnema/vev/internal/domain"	4		"github.com/bnema/vev/internal/domain"
5	-	"github.com/bnema/vev/internal/ports"	5	+	"github.com/bnema/vev/internal/protocol"
6		)	6		)
7			7
8	-	func testRouteTarget(name string, marker byte) ports.ExactSessionTarget {	8	+	func testRouteTarget(name string, marker byte) protocol.ExactSessionTarget {
9	-	return ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{marker}, SessionName: name}	9	+	return protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{marker}, SessionName: name}
10		}	10		}
11			11
12	-	func testRouteEntry(key, generation uint64, name string, marker byte, kind ports.RouteKind) ports.RecentRouteEntry {	12	+	func testRouteEntry(key, generation uint64, name string, marker byte, kind protocol.RouteKind) protocol.RecentRouteEntry {
13	-	return ports.RecentRouteEntry{	13	+	return protocol.RecentRouteEntry{
14		Key: key, Generation: generation, Target: testRouteTarget(name, marker),	14		Key: key, Generation: generation, Target: testRouteTarget(name, marker),
15		Name: name, Kind: kind,	15		Name: name, Kind: kind,
16		}	16		}

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestRouteAppliesPreferredTabPerAttachment(t *testing.T) {
 			sess.tabs = append(sess.tabs, second)
 			sess.mu.Unlock()
 			tr := &closeTrackingTransport{}
-			target := ports.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
+			target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
 			hello := ports.Hello{
 				Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: sess.name,
 				Size: defaultSize, ExactTarget: &target, PreferredTabID: test.preferred,
 	sess.tabs = append(sess.tabs, second)
 	sess.mu.Unlock()
 	tr := &closeTrackingTransport{}
-	target := ports.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
+	target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
 	hello := ports.Hello{
 		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: sess.name,
 		Size: defaultSize, ExactTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,
 	sess.selectAttachmentTab(ac, "tab-2")
 	d.paint(sess, ac, false, nil)
-	var positions []ports.RoutePosition
+	var positions []protocol.RoutePosition
 	for _, frame := range tr.Sends() {
 		if frame.Type != ports.MsgRoutePosition {
 			continue
 		require.NoError(t, err)
 		positions = append(positions, position)
 	}
-	require.Equal(t, []ports.RoutePosition{
+	require.Equal(t, []protocol.RoutePosition{
 		{Target: target, ActiveTabID: "tab-1"},
 		{Target: target, ActiveTabID: "tab-2"},
 	}, positions)

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

 import (
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
-func (ac *attachedClient) offerSamePeerTarget(target ports.ExactSessionTarget) {
+func (ac *attachedClient) offerSamePeerTarget(target protocol.ExactSessionTarget) {
 	ac.samePeerOfferMu.Lock()
 	ac.samePeerOffer = &target
 	ac.samePeerOfferMu.Unlock()
 // consumeSamePeerOffer linearizes the client confirmation with the daemon's
 // endpoint-empty offer. A client cannot select an arbitrary local session by
 // manufacturing this frame.
-func (ac *attachedClient) consumeSamePeerOffer(target ports.ExactSessionTarget) bool {
+func (ac *attachedClient) consumeSamePeerOffer(target protocol.ExactSessionTarget) bool {
 	ac.samePeerOfferMu.Lock()
 	defer ac.samePeerOfferMu.Unlock()
 	if ac.samePeerOffer == nil || *ac.samePeerOffer != target {
 // switchSamePeerForAttachment commits one client-confirmed endpoint-empty
 // target. The request never names an endpoint: its authority is the current
 // authenticated attachment plus the target's exact lifecycle identity.
-func (d *Daemon) switchSamePeerForAttachment(effect *attachmentEffect, request ports.SamePeerSwitchRequest) {
+func (d *Daemon) switchSamePeerForAttachment(effect *attachmentEffect, request protocol.SamePeerSwitchRequest) {
 	if err := request.Validate(); err != nil || !effect.current() || effect.sess == nil || effect.ac == nil {
 		return
 	}
 	if !effect.ac.consumeSamePeerOffer(request.Target) {
-		d.sendSamePeerSwitchFailure(effect, request.RequestID, ports.SamePeerSwitchStaleTarget)
+		d.sendSamePeerSwitchFailure(effect, request.RequestID, protocol.SamePeerSwitchStaleTarget)
 		return
 	}
 	target, targetTabIndex, ok := d.samePeerTarget(request)
 	if !ok || target == effect.sess {
-		d.sendSamePeerSwitchFailure(effect, request.RequestID, ports.SamePeerSwitchStaleTarget)
+		d.sendSamePeerSwitchFailure(effect, request.RequestID, protocol.SamePeerSwitchStaleTarget)
 		return
 	}
 		ready:             true,
 	})
 	if err != nil {
-		d.sendSamePeerSwitchFailure(effect, request.RequestID, ports.SamePeerSwitchStaleTarget)
+		d.sendSamePeerSwitchFailure(effect, request.RequestID, protocol.SamePeerSwitchStaleTarget)
 		return
 	}
 // samePeerTarget resolves the exact target and the client-owned tab cursor
 // under the daemon/session locks. A missing cursor deliberately falls back to
 // the target session's current default rather than leaking the source view.
-func (d *Daemon) samePeerTarget(request ports.SamePeerSwitchRequest) (*session, int, bool) {
+func (d *Daemon) samePeerTarget(request protocol.SamePeerSwitchRequest) (*session, int, bool) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	return target, tabIndex, true
 }
-func (d *Daemon) sendSamePeerSwitchFailure(effect *attachmentEffect, requestID uint64, code ports.SamePeerSwitchFailureCode) {
+func (d *Daemon) sendSamePeerSwitchFailure(effect *attachmentEffect, requestID uint64, code protocol.SamePeerSwitchFailureCode) {
 	if effect == nil || effect.ac == nil {
 		return
 	}
 		}
 		defer sender.End()
 	}
-	payload, err := ports.MarshalSamePeerSwitchFailure(ports.SamePeerSwitchFailure{RequestID: requestID, Code: code})
+	payload, err := ports.MarshalSamePeerSwitchFailure(protocol.SamePeerSwitchFailure{RequestID: requestID, Code: code})
 	if err != nil {
 		return
 	}

M internal/usecase/daemon/same_peer_switch_test.go +13 -12

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestPaletteSessionSelectionCompletesSamePeerSwitch(t *testing.T) {
 	d.mu.Lock()
 	d.sessions[target.id] = target
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	token := beginRecentRoutePaletteEffect(t, d, source, ac)
 	d.handleInputForAttachment(token, []byte("\x1b "))
 	targetFrame := awaitFrame(t, sends, ports.MsgAttachTarget)
 	attachTarget, err := ports.UnmarshalAttachTarget(targetFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, &ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, attachTarget.ExactTarget)
+	require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, attachTarget.ExactTarget)
-	d.switchSamePeerForAttachment(token, ports.SamePeerSwitchRequest{
+	d.switchSamePeerForAttachment(token, protocol.SamePeerSwitchRequest{
 		RequestID: 1, Target: *attachTarget.ExactTarget,
 	})
 	d.mu.Lock()
 	d.sessions[target.id] = target
 	d.mu.Unlock()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	token := source.captureAttachmentCapability(ac, ac.transport())
 	effect, admitted := ac.beginAttachmentEffect(token)
 	require.True(t, admitted)
 	defer effect.End()
-	requestTarget := ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}
+	requestTarget := protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}
 	ac.offerSamePeerTarget(requestTarget)
-	d.switchSamePeerForAttachment(effect, ports.SamePeerSwitchRequest{
+	d.switchSamePeerForAttachment(effect, protocol.SamePeerSwitchRequest{
 		RequestID:      1,
 		Target:         requestTarget,
 		PreferredTabID: domain.TabStableID(target.tabs[1].stableID),
 	identityFrame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
 	identity, err := ports.UnmarshalCommittedRouteIdentity(identityFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, identity.Target)
+	require.Equal(t, protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "target"}, identity.Target)
 }
 func TestFinishSendErrorDetachClearsSamePeerOffer(t *testing.T) {
 	d, sess, ac, _, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.offerSamePeerTarget(ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "target"})
+	ac.offerSamePeerTarget(protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "target"})
 	d.finishSendErrorDetach(sess, ac, ac.transport())
 func TestSamePeerSwitchRejectsStaleTargetWithoutMutation(t *testing.T) {
 	d, source, ac, sends, releases := newManualTabSession(t, 1)
 	defer releaseAll(releases)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	token := source.captureAttachmentCapability(ac, ac.transport())
 	effect, admitted := ac.beginAttachmentEffect(token)
 	require.True(t, admitted)
 	defer effect.End()
-	d.switchSamePeerForAttachment(effect, ports.SamePeerSwitchRequest{
+	d.switchSamePeerForAttachment(effect, protocol.SamePeerSwitchRequest{
 		RequestID: 1,
-		Target:    ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{9}, SessionName: "missing"},
+		Target:    protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{9}, SessionName: "missing"},
 	})
 	require.Same(t, source, ac.currentAttachmentSession())
 	failureFrame := awaitFrame(t, sends, ports.MsgSamePeerSwitchFailure)
 	failure, err := ports.UnmarshalSamePeerSwitchFailure(failureFrame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.SamePeerSwitchFailure{RequestID: 1, Code: ports.SamePeerSwitchStaleTarget}, failure)
+	require.Equal(t, protocol.SamePeerSwitchFailure{RequestID: 1, Code: protocol.SamePeerSwitchStaleTarget}, failure)
 }

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


@@ -2,7 +2,7 @@ package daemon
2			2
3		import (	3		import (
4		"github.com/bnema/vev/internal/domain"	4		"github.com/bnema/vev/internal/domain"
5	-	"github.com/bnema/vev/internal/ports"	5	+	"github.com/bnema/vev/internal/protocol"
6		)	6		)
7			7
8		// backSessionForAttachment delegates previous-route ownership to the client	8		// backSessionForAttachment delegates previous-route ownership to the client

@@ -22,7 +22,7 @@ func (d Daemon) backSessionForAttachment(effect attachmentEffect) error {
22		if snapshot.Previous.Key == 0 \|\| snapshot.Previous.Generation == 0 {	22		if snapshot.Previous.Key == 0 \|\| snapshot.Previous.Generation == 0 {
23		return nil	23		return nil
24		}	24		}
25	-	return d.sendRecentRouteNavigationActionForAttachment(effect, ports.RouteNavigationAction{	25	+	return d.sendRecentRouteNavigationActionForAttachment(effect, protocol.RouteNavigationAction{
26		SnapshotGeneration: snapshot.Generation,	26		SnapshotGeneration: snapshot.Generation,
27		Key: snapshot.Previous.Key,	27		Key: snapshot.Previous.Key,
28		Generation: snapshot.Previous.Generation,	28		Generation: snapshot.Previous.Generation,

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

 	"testing"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 	effect, admitted := ac.beginAttachmentEffect(token)
 	require.True(t, admitted)
 	defer effect.End()
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 		Generation: 5,
-		Active:     ports.RouteRef{Key: 9, Generation: 5},
+		Active:     protocol.RouteRef{Key: 9, Generation: 5},
-		Previous:   ports.RouteRef{Key: 7, Generation: 3},
+		Previous:   protocol.RouteRef{Key: 7, Generation: 3},
-		Entries:    []ports.RecentRouteEntry{testRouteEntry(7, 3, "previous", 7, ports.RouteKindLocal)},
+		Entries:    []protocol.RecentRouteEntry{testRouteEntry(7, 3, "previous", 7, protocol.RouteKindLocal)},
 	})
 	require.NoError(t, d.backSessionForAttachment(effect))
 	frames := transport.Sends()
 	require.NotEmpty(t, frames)
-	var action ports.RouteNavigationAction
+	var action protocol.RouteNavigationAction
 	found := false
 	for _, frame := range frames {
 		if frame.Type != ports.MsgNavigateRecentRoute {
 		found = true
 	}
 	require.True(t, found)
-	require.Equal(t, ports.RouteNavigationAction{SnapshotGeneration: 5, Key: 7, Generation: 3}, action)
+	require.Equal(t, protocol.RouteNavigationAction{SnapshotGeneration: 5, Key: 7, Generation: 3}, action)
 }

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

 	"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"
 )
 func TestRenamePublishesCommittedRouteIdentityToAttachedClients(t *testing.T) {
 	sess.mu.Unlock()
 	token := sess.captureAttachmentCapability(ac, ac.transport())
 	ac.installTestAttachmentCapability(token)
-	ac.setRouteSnapshot(ports.RecentRouteSnapshot{Generation: 1})
+	ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
 	require.NoError(t, d.renameSession(sess, "vps-infra"))
 	frame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
 	identity, err := ports.UnmarshalCommittedRouteIdentity(frame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ExactSessionTarget{
+	require.Equal(t, protocol.ExactSessionTarget{
 		LifecycleID: domain.IncarnationID{1},
 		SessionName: "vps-infra",
 	}, identity.Target)
 	require.NoError(t, d.renameSession(sess, "vps-infra"))
 	require.Empty(t, sends, "the route ledger must be published before its identity can be updated")
-	activeRef := ports.RouteRef{Key: 1, Generation: 1}
+	activeRef := protocol.RouteRef{Key: 1, Generation: 1}
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation:  1,
 		Active:      activeRef,
-		ActiveEntry: ports.RecentRouteEntry{Key: 1, Generation: 1, Target: testRouteTarget("0", 1), Name: "0", Kind: ports.RouteKindLocal},
+		ActiveEntry: protocol.RecentRouteEntry{Key: 1, Generation: 1, Target: testRouteTarget("0", 1), Name: "0", Kind: protocol.RouteKindLocal},
 		Home:        activeRef,
 	}
 	payload, err := ports.MarshalRecentRouteSnapshot(snapshot)
 	frame := awaitFrame(t, sends, ports.MsgCommittedRouteIdentity)
 	identity, err := ports.UnmarshalCommittedRouteIdentity(frame.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ExactSessionTarget{
+	require.Equal(t, protocol.ExactSessionTarget{
 		LifecycleID: domain.IncarnationID{1},
 		SessionName: "vps-infra",
 	}, identity.Target)

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


@@ -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"
12		"github.com/bnema/vev/internal/usecase/command"	12		"github.com/bnema/vev/internal/usecase/command"
13		"github.com/bnema/vev/internal/usecase/palette"	13		"github.com/bnema/vev/internal/usecase/palette"
14		themeui "github.com/bnema/vev/internal/usecase/theme"	14		themeui "github.com/bnema/vev/internal/usecase/theme"

@@ -189,7 +189,7 @@ func (s *session) statusSegments(includeTerminalTitle bool) statusSnapshot {
189		}	189		}
190			190
191		func (s session) statusSegmentsFor(ac attachedClient, includeTerminalTitle bool) statusSnapshot {	191		func (s session) statusSegmentsFor(ac attachedClient, includeTerminalTitle bool) statusSnapshot {
192	-	var routeSnapshot ports.RecentRouteSnapshot	192	+	var routeSnapshot protocol.RecentRouteSnapshot
193		if ac != nil {	193		if ac != nil {
194		routeSnapshot = ac.routeSnapshotCopy()	194		routeSnapshot = ac.routeSnapshotCopy()
195		}	195		}

@@ -199,7 +199,7 @@ func (s session) statusSegmentsFor(ac attachedClient, includeTerminalTitle boo
199		presentation := recentRoutePresentation{name: s.name, ephemeral: s.ephemeral}	199		presentation := recentRoutePresentation{name: s.name, ephemeral: s.ephemeral}
200		if active, ok := activeRouteEntryForLifecycle(routeSnapshot, s.incarnation); ok {	200		if active, ok := activeRouteEntryForLifecycle(routeSnapshot, s.incarnation); ok {
201		presentation.hostLabel = domain.RemoteDisplayOrigin(active.HostLabel)	201		presentation.hostLabel = domain.RemoteDisplayOrigin(active.HostLabel)
202	-	if active.Kind == ports.RouteKindRemote {	202	+	if active.Kind == protocol.RouteKindRemote {
203		presentation.kind = recentRouteRemote	203		presentation.kind = recentRouteRemote
204		}	204		}
205		}	205		}

@@ -231,7 +231,7 @@ func tabDisplayName(tb *tab, index int) string {
231		return strconv.Itoa(index + 1)	231		return strconv.Itoa(index + 1)
232		}	232		}
233			233
234	-	func rankedRecentForHintsWithSnapshot(hints *palette.ContextualHints, snapshot ports.RecentRouteSnapshot) []rankedRecent {	234	+	func rankedRecentForHintsWithSnapshot(hints *palette.ContextualHints, snapshot protocol.RecentRouteSnapshot) []rankedRecent {
235		if hints == nil \|\| hints.Kind != command.ContextHintRecentSessions {	235		if hints == nil \|\| hints.Kind != command.ContextHintRecentSessions {
236		return nil	236		return nil
237		}	237		}

@@ -270,10 +270,10 @@ func (d Daemon) barStateForPaletteHints(cur session, statusFeedback string, hi
270		// attachment. Bar scripts remain local-session-only because	270		// attachment. Bar scripts remain local-session-only because
271		// their existing execution contract depends on local tabs and PTYs.	271		// their existing execution contract depends on local tabs and PTYs.
272		func (d Daemon) barStateForAttachmentPaletteHints(cur session, statusFeedback string, hints *palette.ContextualHints) barState {	272		func (d Daemon) barStateForAttachmentPaletteHints(cur session, statusFeedback string, hints *palette.ContextualHints) barState {
273	-	return d.barStateForAttachmentPaletteHintsFor(cur, nil, statusFeedback, hints, ports.RecentRouteSnapshot{})	273	+	return d.barStateForAttachmentPaletteHintsFor(cur, nil, statusFeedback, hints, protocol.RecentRouteSnapshot{})
274		}	274		}
275			275
276	-	func (d Daemon) barStateForAttachmentPaletteHintsFor(cur session, ac attachedClient, statusFeedback string, hints palette.ContextualHints, capturedRouteSnapshot ports.RecentRouteSnapshot) barState {	276	+	func (d Daemon) barStateForAttachmentPaletteHintsFor(cur session, ac attachedClient, statusFeedback string, hints palette.ContextualHints, capturedRouteSnapshot protocol.RecentRouteSnapshot) barState {
277		routeSnapshot := capturedRouteSnapshot	277		routeSnapshot := capturedRouteSnapshot
278		if routeSnapshot.Generation == 0 && ac != nil {	278		if routeSnapshot.Generation == 0 && ac != nil {
279		routeSnapshot = ac.routeSnapshotCopy()	279		routeSnapshot = ac.routeSnapshotCopy()

M internal/usecase/daemon/status_test.go +21 -20

 	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/usecase/command"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/palette"
 			sess.name = "vive"
 			sess.incarnation = domain.SessionLifecycleID{1}
-			ref := ports.RouteRef{Key: 1, Generation: 1}
+			ref := protocol.RouteRef{Key: 1, Generation: 1}
-			ac.setRouteSnapshot(ports.RecentRouteSnapshot{
+			ac.setRouteSnapshot(protocol.RecentRouteSnapshot{
 				Generation: 1,
 				Active:     ref,
-				ActiveEntry: ports.RecentRouteEntry{
+				ActiveEntry: protocol.RecentRouteEntry{
 					Key: ref.Key, Generation: ref.Generation,
-					Target: ports.ExactSessionTarget{LifecycleID: tt.routeLifecycle, SessionName: sess.name},
+					Target: protocol.ExactSessionTarget{LifecycleID: tt.routeLifecycle, SessionName: sess.name},
-					Name:   "vive", HostLabel: "user@arch", Kind: ports.RouteKindRemote,
+					Name:   "vive", HostLabel: "user@arch", Kind: protocol.RouteKindRemote,
 				},
 			})
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p1, p2)
 	defer releasePTY1()
 	defer releasePTY2()
-	msg := ports.Theme{HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3}, HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6}, SchemeKnown: true, Light: true}
+	msg := protocol.Theme{HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3}, HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6}, SchemeKnown: true, Light: true}
 	d.applyTheme(sess, ac, msg)
 	tb := testAttachmentTab(sess)
 	floating := newPane("floating", nil, domain.Size{Cols: 20, Rows: 5})
 	installTestFloating(tb, floating, true)
-	clientTheme := ports.Theme{
+	clientTheme := protocol.Theme{
 		HasForeground: true,
 		Foreground:    renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true,
 			defer releasePTY2()
 			d.ApplyConfig(domain.Config{Theme: tc.mode})
-			d.applyTheme(sess, ac, ports.Theme{
+			d.applyTheme(sess, ac, protocol.Theme{
 				HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 				HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 				TrueColor: true, SchemeKnown: true, Light: !tc.want.Light,
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer releasePTY()
 	d.ApplyConfig(domain.Config{Theme: domain.ThemeAuto})
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 		TrueColor: true, SchemeKnown: true, Light: true,
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer releasePTY()
 	d.ApplyConfig(domain.Config{Theme: domain.ThemeAuto})
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 		TrueColor: true, SchemeKnown: true, Light: true,
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer releasePTY()
 	d.ApplyConfig(domain.Config{Theme: domain.ThemeDark})
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 		TrueColor: true, SchemeKnown: true, Light: true,
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer releasePTY()
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 		TrueColor: true, SchemeKnown: true, Light: true,
 	})
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 7, G: 8, B: 9},
 		HasBackground: true, Background: renderer.RGB{R: 10, G: 11, B: 12},
 		TrueColor: true,
 	p, release := newBlockingPTY(t)
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer release()
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 	})
 	p, release := newBlockingPTY(t)
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer release()
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 	})
 	p, release := newBlockingPTY(t)
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer release()
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 7, G: 8, B: 9},
 		HasBackground: true, Background: renderer.RGB{R: 10, G: 11, B: 12},
 	})
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer release()
 	ac.resumeCapable = true
-	d.applyTheme(sess, ac, ports.Theme{
+	d.applyTheme(sess, ac, protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 7, G: 8, B: 9},
 		HasBackground: true, Background: renderer.RGB{R: 10, G: 11, B: 12},
 	})
 	d, sess, ac, _ := newManualSessionWithPTYs(t, p)
 	defer releasePTY()
-	snapshot := ports.RecentRouteSnapshot{
+	snapshot := protocol.RecentRouteSnapshot{
 		Generation: 1,
-		Entries:    []ports.RecentRouteEntry{{Key: 2, Generation: 1, Target: testRouteTarget("captured", 2), Name: "captured", Kind: ports.RouteKindLocal, Attention: true}},
+		Entries:    []protocol.RecentRouteEntry{{Key: 2, Generation: 1, Target: testRouteTarget("captured", 2), Name: "captured", Kind: protocol.RouteKindLocal, Attention: true}},
 	}
 	hints := palette.ContextualHints{
 		Kind:         command.ContextHintRecentSessions,
 		frameInput([]byte("\x1b ")),
 		frameInput([]byte("CNT\r")),
 		frameInput([]byte("\x1b1")),
-		ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(ports.Resize{Size: domain.Size{Cols: 22, Rows: 6}})},
+		ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 22, Rows: 6}})},
 	)
 	var hg sync.WaitGroup

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


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

@@ -26,7 +26,7 @@ func cacheTheme() themeui.Theme {
26		func TestThemeAccentHotReloadRebuildsAppliedSnapshot(t *testing.T) {	26		func TestThemeAccentHotReloadRebuildsAppliedSnapshot(t *testing.T) {
27		d, sess, ac, _ := newManualSessionWithPTYs(t)	27		d, sess, ac, _ := newManualSessionWithPTYs(t)
28		raw := cacheTheme()	28		raw := cacheTheme()
29	-	d.applyTheme(sess, ac, ports.Theme{Foreground: raw.Foreground, Background: raw.Background, HasForeground: true, HasBackground: true, TrueColor: true, Palette: raw.Palette, PaletteKnown: raw.PaletteKnown})	29	+	d.applyTheme(sess, ac, protocol.Theme{Foreground: raw.Foreground, Background: raw.Background, HasForeground: true, HasBackground: true, TrueColor: true, Palette: raw.Palette, PaletteKnown: raw.PaletteKnown})
30		before := ac.getAppliedTheme()	30		before := ac.getAppliedTheme()
31			31
32		cfg := domain.Defaults()	32		cfg := domain.Defaults()

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


@@ -7,12 +7,12 @@ import (
7			7
8		renderer "github.com/bnema/vev-vt/ansi"	8		renderer "github.com/bnema/vev-vt/ansi"
9		"github.com/bnema/vev/internal/domain"	9		"github.com/bnema/vev/internal/domain"
10	-	"github.com/bnema/vev/internal/ports"	10	+	"github.com/bnema/vev/internal/protocol"
11		themeui "github.com/bnema/vev/internal/usecase/theme"	11		themeui "github.com/bnema/vev/internal/usecase/theme"
12		)	12		)
13			13
14	-	func lifecycleTheme(foreground, background renderer.RGB, palette map[uint8]renderer.RGB) ports.Theme {	14	+	func lifecycleTheme(foreground, background renderer.RGB, palette map[uint8]renderer.RGB) protocol.Theme {
15	-	out := ports.Theme{	15	+	out := protocol.Theme{
16		Foreground: foreground, Background: background,	16		Foreground: foreground, Background: background,
17		HasForeground: true, HasBackground: true, TrueColor: true,	17		HasForeground: true, HasBackground: true, TrueColor: true,
18		SchemeKnown: true,	18		SchemeKnown: true,

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

 import (
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func frameWelcome(s *session, resumeToken uint64) (ports.Frame, error) {
 	s.mu.Lock()
-	var identity *ports.CommittedRouteIdentity
+	var identity *protocol.CommittedRouteIdentity
 	if s.incarnation != (domain.SessionLifecycleID{}) {
-		identity = &ports.CommittedRouteIdentity{
+		identity = &protocol.CommittedRouteIdentity{
-			Target:    ports.ExactSessionTarget{LifecycleID: s.incarnation, SessionName: s.name},
+			Target:    protocol.ExactSessionTarget{LifecycleID: s.incarnation, SessionName: s.name},
 			Ephemeral: s.ephemeral,
 		}
 	}
 	w.ResumeToken = resumeToken
 	payload := ports.MarshalWelcome(w)
 	if payload == nil {
-		return ports.Frame{}, ports.ErrInvalidRouteWire
+		return ports.Frame{}, protocol.ErrInvalidRouteWire
 	}
 	return ports.Frame{Type: ports.MsgWelcome, Payload: payload}, nil
 }
 }
 func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64) (ports.Frame, error) {
-	payload, err := ports.MarshalOutput(ports.Output{
+	payload, err := ports.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,
 	})

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

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

M internal/usecase/palette/fuzzy_test.go +3 -3


@@ -4,7 +4,7 @@ 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"
8		"github.com/bnema/vev/internal/usecase/command"	8		"github.com/bnema/vev/internal/usecase/command"
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10		)	10		)

@@ -87,7 +87,7 @@ func TestFuzzyOrdersMixedResults(t *testing.T) {
87		wantText []string	87		wantText []string
88		wantKinds []ResultKind	88		wantKinds []ResultKind
89		wantPositions [][]int	89		wantPositions [][]int
90	-	wantActiveTargets map[int]ports.ExactSessionTarget	90	+	wantActiveTargets map[int]protocol.ExactSessionTarget
91		}{	91		}{
92		{	92		{
93		name: "command shortcode precedes sessions and description matches",	93		name: "command shortcode precedes sessions and description matches",

@@ -128,7 +128,7 @@ func TestFuzzyOrdersMixedResults(t *testing.T) {
128		wantText: []string{"AX", "Resume session aAlpha", "Resume session aBravo", "Switch to session aEcho", "Switch to session aEcho", "Switch to session aZulu"},	128		wantText: []string{"AX", "Resume session aAlpha", "Resume session aBravo", "Switch to session aEcho", "Switch to session aEcho", "Switch to session aZulu"},
129		wantKinds: []ResultKind{ResultKindCommand, ResultKindStoppedSession, ResultKindStoppedSession, ResultKindActiveSession, ResultKindActiveSession, ResultKindActiveSession},	129		wantKinds: []ResultKind{ResultKindCommand, ResultKindStoppedSession, ResultKindStoppedSession, ResultKindActiveSession, ResultKindActiveSession, ResultKindActiveSession},
130		wantPositions: [][]int{{0}, {15}, {15}, {18}, {18}, {18}},	130		wantPositions: [][]int{{0}, {15}, {15}, {18}, {18}, {18}},
131	-	wantActiveTargets: map[int]ports.ExactSessionTarget{	131	+	wantActiveTargets: map[int]protocol.ExactSessionTarget{
132		3: testExactTarget("aEcho", 4), 4: testExactTarget("aEcho", 5), 5: testExactTarget("aZulu", 3),	132		3: testExactTarget("aEcho", 4), 4: testExactTarget("aEcho", 5), 5: testExactTarget("aZulu", 3),
133		},	133		},
134		},	134		},

M internal/usecase/palette/result.go +11 -11


@@ -4,7 +4,7 @@ import (
4		"time"	4		"time"
5			5
6		"github.com/bnema/vev/internal/domain"	6		"github.com/bnema/vev/internal/domain"
7	-	"github.com/bnema/vev/internal/ports"	7	+	"github.com/bnema/vev/internal/protocol"
8		"github.com/bnema/vev/internal/usecase/command"	8		"github.com/bnema/vev/internal/usecase/command"
9		)	9		)
10			10

@@ -32,7 +32,7 @@ type Result struct {
32		type sessionPayload struct {	32		type sessionPayload struct {
33		display string	33		display string
34		createdAt time.Time	34		createdAt time.Time
35	-	target ports.ExactSessionTarget	35	+	target protocol.ExactSessionTarget
36		}	36		}
37			37
38		type remoteSessionPayload struct {	38		type remoteSessionPayload struct {

@@ -43,7 +43,7 @@ type remoteSessionPayload struct {
43			43
44		type routePayload struct {	44		type routePayload struct {
45		label string	45		label string
46	-	action ports.RouteNavigationAction	46	+	action protocol.RouteNavigationAction
47		}	47		}
48			48
49		// NewCommandResult creates a static command palette target.	49		// NewCommandResult creates a static command palette target.

@@ -52,13 +52,13 @@ func NewCommandResult(cmd command.Command) Result {
52		}	52		}
53			53
54		// NewActiveSessionResult creates an immutable active named-session target.	54		// NewActiveSessionResult creates an immutable active named-session target.
55	-	func NewActiveSessionResult(target ports.ExactSessionTarget, createdAt time.Time) Result {	55	+	func NewActiveSessionResult(target protocol.ExactSessionTarget, createdAt time.Time) Result {
56		return NewActiveSessionResultWithDisplayOrigin(target, createdAt, "")	56		return NewActiveSessionResultWithDisplayOrigin(target, createdAt, "")
57		}	57		}
58			58
59		// NewActiveSessionResultWithDisplayOrigin creates an active named-session target	59		// NewActiveSessionResultWithDisplayOrigin creates an active named-session target
60		// qualified for presentation through a remote attachment origin.	60		// qualified for presentation through a remote attachment origin.
61	-	func NewActiveSessionResultWithDisplayOrigin(target ports.ExactSessionTarget, createdAt time.Time, displayOrigin string) Result {	61	+	func NewActiveSessionResultWithDisplayOrigin(target protocol.ExactSessionTarget, createdAt time.Time, displayOrigin string) Result {
62		return Result{	62		return Result{
63		kind: ResultKindActiveSession,	63		kind: ResultKindActiveSession,
64		session: newSessionPayload(target, createdAt, displayOrigin),	64		session: newSessionPayload(target, createdAt, displayOrigin),

@@ -66,20 +66,20 @@ func NewActiveSessionResultWithDisplayOrigin(target ports.ExactSessionTarget, cr
66		}	66		}
67			67
68		// NewStoppedSessionResult creates an immutable stopped named-session target.	68		// NewStoppedSessionResult creates an immutable stopped named-session target.
69	-	func NewStoppedSessionResult(target ports.ExactSessionTarget, createdAt time.Time) Result {	69	+	func NewStoppedSessionResult(target protocol.ExactSessionTarget, createdAt time.Time) Result {
70		return NewStoppedSessionResultWithDisplayOrigin(target, createdAt, "")	70		return NewStoppedSessionResultWithDisplayOrigin(target, createdAt, "")
71		}	71		}
72			72
73		// NewStoppedSessionResultWithDisplayOrigin creates a stopped named-session target	73		// NewStoppedSessionResultWithDisplayOrigin creates a stopped named-session target
74		// qualified for presentation through a remote attachment origin.	74		// qualified for presentation through a remote attachment origin.
75	-	func NewStoppedSessionResultWithDisplayOrigin(target ports.ExactSessionTarget, createdAt time.Time, displayOrigin string) Result {	75	+	func NewStoppedSessionResultWithDisplayOrigin(target protocol.ExactSessionTarget, createdAt time.Time, displayOrigin string) Result {
76		return Result{	76		return Result{
77		kind: ResultKindStoppedSession,	77		kind: ResultKindStoppedSession,
78		session: newSessionPayload(target, createdAt, displayOrigin),	78		session: newSessionPayload(target, createdAt, displayOrigin),
79		}	79		}
80		}	80		}
81			81
82	-	func newSessionPayload(target ports.ExactSessionTarget, createdAt time.Time, displayOrigin string) sessionPayload {	82	+	func newSessionPayload(target protocol.ExactSessionTarget, createdAt time.Time, displayOrigin string) sessionPayload {
83		display := target.SessionName	83		display := target.SessionName
84		if displayOrigin != "" {	84		if displayOrigin != "" {
85		display = domain.RemoteSessionDisplay(target.SessionName, displayOrigin)	85		display = domain.RemoteSessionDisplay(target.SessionName, displayOrigin)

@@ -98,7 +98,7 @@ func NewRemoteSessionResult(key domain.RemoteSessionKey, target domain.RemoteSes
98		}	98		}
99			99
100		// NewRecentRouteResult creates an immutable client-ledger route target.	100		// NewRecentRouteResult creates an immutable client-ledger route target.
101	-	func NewRecentRouteResult(label string, action ports.RouteNavigationAction) Result {	101	+	func NewRecentRouteResult(label string, action protocol.RouteNavigationAction) Result {
102		return Result{kind: ResultKindRecentRoute, route: routePayload{label: label, action: action}}	102		return Result{kind: ResultKindRecentRoute, route: routePayload{label: label, action: action}}
103		}	103		}
104			104

@@ -163,7 +163,7 @@ func (r Result) SessionCreatedAt() (time.Time, bool) {
163			163
164		// SessionTarget returns the exact lifecycle UUID and name for local active and	164		// SessionTarget returns the exact lifecycle UUID and name for local active and
165		// stopped session results.	165		// stopped session results.
166	-	func (r Result) SessionTarget() (ports.ExactSessionTarget, bool) {	166	+	func (r Result) SessionTarget() (protocol.ExactSessionTarget, bool) {
167		return r.session.target, r.kind == ResultKindActiveSession \|\| r.kind == ResultKindStoppedSession	167		return r.session.target, r.kind == ResultKindActiveSession \|\| r.kind == ResultKindStoppedSession
168		}	168		}
169			169

@@ -187,7 +187,7 @@ func (r Result) RemoteSessionUnavailableReason() (string, bool) {
187			187
188		// RouteNavigationAction returns the exact client-ledger target only for a	188		// RouteNavigationAction returns the exact client-ledger target only for a
189		// recent-route result.	189		// recent-route result.
190	-	func (r Result) RouteNavigationAction() (ports.RouteNavigationAction, bool) {	190	+	func (r Result) RouteNavigationAction() (protocol.RouteNavigationAction, bool) {
191		return r.route.action, r.kind == ResultKindRecentRoute	191		return r.route.action, r.kind == ResultKindRecentRoute
192		}	192		}
193			193

M internal/usecase/palette/result_test.go +4 -4


@@ -5,13 +5,13 @@ import (
5		"time"	5		"time"
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"
9		"github.com/bnema/vev/internal/usecase/command"	9		"github.com/bnema/vev/internal/usecase/command"
10		"github.com/stretchr/testify/require"	10		"github.com/stretchr/testify/require"
11		)	11		)
12			12
13	-	func testExactTarget(name string, marker byte) ports.ExactSessionTarget {	13	+	func testExactTarget(name string, marker byte) protocol.ExactSessionTarget {
14	-	return ports.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{marker}, SessionName: name}	14	+	return protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{marker}, SessionName: name}
15		}	15		}
16			16
17		func TestResultKindsAndSessionLifecycleTargets(t *testing.T) {	17		func TestResultKindsAndSessionLifecycleTargets(t *testing.T) {

@@ -73,7 +73,7 @@ func TestResultKindsAndSessionLifecycleTargets(t *testing.T) {
73		}	73		}
74			74
75		func TestRecentRouteResultCarriesExactNavigationAction(t *testing.T) {	75		func TestRecentRouteResultCarriesExactNavigationAction(t *testing.T) {
76	-	action := ports.RouteNavigationAction{SnapshotGeneration: 4, Key: 7, Generation: 3}	76	+	action := protocol.RouteNavigationAction{SnapshotGeneration: 4, Key: 7, Generation: 3}
77		result := NewRecentRouteResult("logs@edge", action)	77		result := NewRecentRouteResult("logs@edge", action)
78			78
79		require.Equal(t, ResultKindRecentRoute, result.Kind())	79		require.Equal(t, ResultKindRecentRoute, result.Kind())

M scripts/remote-picker-harness/main.go +3 -2

 	"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"
 )
 const (
 		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(ports.Theme{TrueColor: hello.TrueColor, SchemeKnown: true})}); err != nil {
+	if err := tr.Send(ports.Frame{Type: ports.MsgTheme, Payload: ports.MarshalTheme(protocol.Theme{TrueColor: hello.TrueColor, SchemeKnown: true})}); err != nil {
 		return fmt.Errorf("send initial theme: %w", err)
 	}
 	return nil
 	}
 }
-func remotePreviewContains(preview ports.RemotePreview, want string) bool {
+func remotePreviewContains(preview protocol.RemotePreview, want string) bool {
 	var text strings.Builder
 	for _, cell := range preview.Cells {
 		if !cell.Continuation {

M scripts/remote-picker-harness/visual_probe.go +6 -5

 	vt "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 const (
 	initialized  bool
 }
-func (s visualOutputState) next(output ports.Output) (visualOutputState, bool) {
+func (s visualOutputState) next(output protocol.Output) (visualOutputState, bool) {
 	if output.Epoch == 0 {
 		return visualOutputState{}, false
 	}
 type visualOutputResult struct {
 	Accepted     bool
 	StateBearing bool
-	Ack          ports.Ack
+	Ack          protocol.Ack
 	event        *probeEvent
 }
 	p.record(probeEvent{Kind: kind, Accepted: true})
 }
-func (p *visualProbe) apply(output ports.Output) visualOutputResult {
+func (p *visualProbe) apply(output protocol.Output) visualOutputResult {
 	if p == nil {
 		return visualOutputResult{}
 	}
 	p.outputFrames++
 	p.outputBytes += len(output.Data)
-	accepted := ports.ValidateOutput(output) == nil
+	accepted := protocol.ValidateOutput(output) == nil
 	next := visualOutputState{}
 	if accepted {
 		next, accepted = p.state.next(output)
 	p.checkpoints = append(p.checkpoints, checkpoint)
 	result := visualOutputResult{Accepted: true, StateBearing: output.New != 0, event: event}
 	if result.StateBearing {
-		result.Ack = ports.Ack{Epoch: output.Epoch, State: output.New}
+		result.Ack = protocol.Ack{Epoch: output.Epoch, State: output.New}
 	}
 	return result
 }

M scripts/remote-picker-harness/visual_probe_test.go +27 -26

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 func (*probeTestTransport) Recv() (ports.Frame, error) { return ports.Frame{}, errors.New("not used") }
 func (*probeTestTransport) Close() error               { return nil }
-func probeTestOutput(t *testing.T, output ports.Output) ports.Frame {
+func probeTestOutput(t *testing.T, output protocol.Output) ports.Frame {
 	t.Helper()
 	payload, err := ports.MarshalOutput(output)
 	if err != nil {
 	probe := newVisualProbe(size)
 	for _, tt := range []struct {
 		name   string
-		output ports.Output
+		output protocol.Output
 		want   string
 		state  uint64
 	}{
 		{
 			name:   "full",
-			output: ports.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("full")},
+			output: protocol.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("full")},
 			want:   "full",
 			state:  1,
 		},
 		{
 			name:   "incremental",
-			output: ports.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 4, Size: size, Data: []byte(" incremental")},
+			output: protocol.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 4, Size: size, Data: []byte(" incremental")},
 			want:   "full incremental",
 			state:  2,
 		},
 func TestVisualProbeResizesToAcceptedOutput(t *testing.T) {
 	probe := newVisualProbe(domain.Size{Cols: probeTestCols, Rows: probeTestRows})
 	outputSize := domain.Size{Cols: 48, Rows: 3}
-	result := probe.apply(ports.Output{
+	result := probe.apply(protocol.Output{
 		Epoch: 1, New: 1, Full: true, ViewRevision: 1, Size: outputSize, Data: []byte("resized"),
 	})
 	size := domain.Size{Cols: probeTestCols, Rows: probeTestRows}
 	for _, tt := range []struct {
 		name   string
-		output ports.Output
+		output protocol.Output
 	}{
 		{
 			name:   "base gap",
-			output: ports.Output{Epoch: 1, Base: 0, New: 3, Full: true, ViewRevision: 4, Size: size, Data: []byte("rejected")},
+			output: protocol.Output{Epoch: 1, Base: 0, New: 3, Full: true, ViewRevision: 4, Size: size, Data: []byte("rejected")},
 		},
 		{
 			name:   "revision gap",
-			output: ports.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 5, Size: size, Data: []byte("rejected")},
+			output: protocol.Output{Epoch: 1, Base: 1, New: 2, ViewRevision: 5, Size: size, Data: []byte("rejected")},
 		},
 		{
 			name:   "stale epoch",
-			output: ports.Output{Epoch: 0, Base: 1, New: 2, ViewRevision: 4, Size: size, Data: []byte("rejected")},
+			output: protocol.Output{Epoch: 0, Base: 1, New: 2, ViewRevision: 4, Size: size, Data: []byte("rejected")},
 		},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			probe := newVisualProbe(size)
-			first := ports.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("keep")}
+			first := protocol.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("keep")}
 			if result := probe.apply(first); !result.Accepted {
 				t.Fatal("seed output was rejected")
 			}
 			beforeText, beforeState, beforeCheckpoints := probe.text(), probe.state, len(probe.checkpoints)
 			result := probe.apply(tt.output)
-			if result.Accepted || result.StateBearing || result.Ack != (ports.Ack{}) {
+			if result.Accepted || result.StateBearing || result.Ack != (protocol.Ack{}) {
 				t.Fatalf("result = %+v, want rejected output without ACK", result)
 			}
 			if got := probe.text(); got != beforeText {
 func TestVisualProbeRejectsInvalidUninitializedSideEffects(t *testing.T) {
 	size := domain.Size{Cols: probeTestCols, Rows: probeTestRows}
-	for _, output := range []ports.Output{
+	for _, output := range []protocol.Output{
 		{Epoch: 1, Base: 1, Size: size, Data: []byte("invalid base")},
 		{Epoch: 1, Full: true, Size: size, Data: []byte("invalid full")},
 	} {
 		probe := newVisualProbe(size)
 		result := probe.apply(output)
-		if result.Accepted || result.StateBearing || result.Ack != (ports.Ack{}) {
+		if result.Accepted || result.StateBearing || result.Ack != (protocol.Ack{}) {
 			t.Fatalf("result = %+v, want rejected uninitialized side effect", result)
 		}
 		require.Len(t, probe.events, 1)
 	size := domain.Size{Cols: probeTestCols, Rows: probeTestRows}
 	for _, tt := range []struct {
 		name   string
-		seed   *ports.Output
+		seed   *protocol.Output
-		effect ports.Output
+		effect protocol.Output
 	}{
 		{
 			name:   "before state-bearing output",
-			effect: ports.Output{Epoch: 1, Size: size, Data: []byte("side effect")},
+			effect: protocol.Output{Epoch: 1, Size: size, Data: []byte("side effect")},
 		},
 		{
 			name:   "after state-bearing output",
-			seed:   &ports.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("seed")},
+			seed:   &protocol.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("seed")},
-			effect: ports.Output{Epoch: 1, ViewRevision: 4, Size: size, Data: []byte(" side effect")},
+			effect: protocol.Output{Epoch: 1, ViewRevision: 4, Size: size, Data: []byte(" side effect")},
 		},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			}
 			beforeState, beforeCheckpoints := probe.state, len(probe.checkpoints)
 			result := probe.apply(tt.effect)
-			if !result.Accepted || result.StateBearing || result.Ack != (ports.Ack{}) {
+			if !result.Accepted || result.StateBearing || result.Ack != (protocol.Ack{}) {
 				t.Fatalf("result = %+v, want accepted side effect without ACK", result)
 			}
 			if !strings.Contains(probe.text(), string(tt.effect.Data)) {
 	size := domain.Size{Cols: probeTestCols, Rows: probeTestRows}
 	for _, tt := range []struct {
 		name       string
-		seed       *ports.Output
+		seed       *protocol.Output
-		output     ports.Output
+		output     protocol.Output
 		wantACKs   int
 		wantResets int
 	}{
 		{
 			name:     "accepted full",
-			output:   ports.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("full")},
+			output:   protocol.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("full")},
 			wantACKs: 1,
 		},
 		{
 			name:   "accepted side effect",
-			output: ports.Output{Epoch: 1, Size: size, Data: []byte("side effect")},
+			output: protocol.Output{Epoch: 1, Size: size, Data: []byte("side effect")},
 		},
 		{
 			name:       "rejected state",
-			seed:       &ports.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("seed")},
+			seed:       &protocol.Output{Epoch: 1, New: 1, Full: true, ViewRevision: 4, Size: size, Data: []byte("seed")},
-			output:     ports.Output{Epoch: 1, New: 3, Full: true, ViewRevision: 4, Size: size, Data: []byte("gap")},
+			output:     protocol.Output{Epoch: 1, New: 3, Full: true, ViewRevision: 4, Size: size, Data: []byte("gap")},
 			wantResets: 1,
 		},
 	} {
 	artifact.registerProbe(probe)
 	secret := "not-for-artifact"
 	for state := uint64(1); state <= maxProbeEvents+1; state++ {
-		output := ports.Output{Epoch: 1, Base: state - 1, New: state, Size: size, Data: []byte(secret)}
+		output := protocol.Output{Epoch: 1, Base: state - 1, New: state, Size: size, Data: []byte(secret)}
 		if state == 1 {
 			output.Full = true
 		}

M transport_replay_integration_test.go +3 -2

 	"github.com/bnema/vev/internal/adapters/ipc"
 	"github.com/bnema/vev/internal/adapters/sshstdio"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/testutil/replaytest"
 	"github.com/stretchr/testify/require"
 )
 // SSH-stdio transports. The transports only carry frames; neither can infer
 // or alter the palette lifecycle.
 func TestThemeGenerationTransportSequences(t *testing.T) {
-	cleared := ports.Theme{
+	cleared := protocol.Theme{
 		HasForeground: true, Foreground: renderer.RGB{R: 1, G: 2, B: 3},
 		HasBackground: true, Background: renderer.RGB{R: 4, G: 5, B: 6},
 		TrueColor: true, SchemeKnown: true,
 	definitive := cleared
 	definitive.Palette = palette
 	definitive.PaletteKnown = 1<<2 | 1<<10
-	sequence := []ports.Theme{cleared, definitive}
+	sequence := []protocol.Theme{cleared, definitive}
 	tests := []struct {
 		name string