b21386d refactor(protocol): extract session control contracts (#233) · 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	-	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`.	64	+	Semantic presentation, route, and session-control values live in `internal/protocol`. Frame IDs and codecs live in `internal/ports/frame.go`, `internal/ports/wire.go`, `internal/ports/routes_wire.go`, and `internal/ports/wire_command.go`. Connection framing lives in `internal/adapters/ipc/transport.go`.
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/proxy_test.go +4 -4


@@ -89,7 +89,7 @@ func TestProxyRuntimeClampsDatagramHelloOutputWindowAndPreservesControl(t *testi
89		daemon := newFakeTransport()	89		daemon := newFakeTransport()
90		errCh := make(chan error, 1)	90		errCh := make(chan error, 1)
91		go func() { errCh <- ProxyRuntime{Client: client, Daemon: daemon, IdleTTL: time.Hour}.Run(t.Context()) }()	91		go func() { errCh <- ProxyRuntime{Client: client, Daemon: daemon, IdleTTL: time.Hour}.Run(t.Context()) }()
92	-	hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: requested}	92	+	hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: requested}
93		client.recv <- recvResult{frame: ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}}	93		client.recv <- recvResult{frame: ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}}
94			94
95		select {	95		select {

@@ -490,7 +490,7 @@ func TestProxyCopierStopsRetryingWhenContextCanceled(t *testing.T) {
490			490
491		func TestClampDatagramHelloOutputWindowPreservesProtocolValidation(t *testing.T) {	491		func TestClampDatagramHelloOutputWindowPreservesProtocolValidation(t *testing.T) {
492		t.Run("malformed payload remains malformed", func(t *testing.T) {	492		t.Run("malformed payload remains malformed", func(t *testing.T) {
493	-	payload := append(ports.MarshalHello(ports.Hello{Version: ports.ProtocolVersion, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8}), 0xff)	493	+	payload := append(ports.MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8}), 0xff)
494		frame := ports.Frame{Type: ports.MsgHello, Payload: payload}	494		frame := ports.Frame{Type: ports.MsgHello, Payload: payload}
495		got := clampDatagramHelloOutputWindow(frame)	495		got := clampDatagramHelloOutputWindow(frame)
496		if !reflect.DeepEqual(got, frame) {	496		if !reflect.DeepEqual(got, frame) {

@@ -502,8 +502,8 @@ func TestClampDatagramHelloOutputWindowPreservesProtocolValidation(t *testing.T)
502		})	502		})
503			503
504		t.Run("mismatched version remains mismatched", func(t *testing.T) {	504		t.Run("mismatched version remains mismatched", func(t *testing.T) {
505	-	wantVersion := ports.ProtocolVersion + 1	505	+	wantVersion := protocol.Version + 1
506	-	frame := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(ports.Hello{	506	+	frame := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
507		Version: wantVersion, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8,	507		Version: wantVersion, Size: domain.Size{Cols: 80, Rows: 24}, MaxOutputInFlight: 8,
508		})}	508		})}
509		got, err := ports.UnmarshalHello(clampDatagramHelloOutputWindow(frame).Payload)	509		got, err := ports.UnmarshalHello(clampDatagramHelloOutputWindow(frame).Payload)

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


@@ -24,8 +24,8 @@ func TestTransportSendRecvBothDirections(t *testing.T) {
24		client := NewTransport(c1)	24		client := NewTransport(c1)
25		server := NewTransport(c2)	25		server := NewTransport(c2)
26			26
27	-	clientToServer := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(ports.Hello{Version: 1, Intent: ports.IntentNew, Name: "w0"})}	27	+	clientToServer := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{Version: 1, Intent: protocol.IntentNew, Name: "w0"})}
28	-	serverToClient := ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(ports.Welcome{SessionID: "s1", SessionName: "main"})}	28	+	serverToClient := ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"})}
29			29
30		var wg sync.WaitGroup	30		var wg sync.WaitGroup
31		wg.Go(func() {	31		wg.Go(func() {

@@ -140,7 +140,7 @@ func TestTransportManySmallFramesBackToBack(t *testing.T) {
140		frames[i] = ports.Frame{Type: ports.MsgPing, Payload: nil}	140		frames[i] = ports.Frame{Type: ports.MsgPing, Payload: nil}
141		}	141		}
142		// Vary a couple to prove ordering and content are both preserved.	142		// Vary a couple to prove ordering and content are both preserved.
143	-	frames[7] = ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("hop")})}	143	+	frames[7] = ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("hop")})}
144		frames[150] = ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}	144		frames[150] = ports.Frame{Type: ports.MsgResize, Payload: mustMarshalResize(protocol.Resize{Size: domain.Size{Cols: 5, Rows: 6}})}
145			145
146		var wg sync.WaitGroup	146		var wg sync.WaitGroup

M internal/adapters/remote/catalog.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 (
 			Kind: "catalog",
 		}
 	}
-	if *version.ProtocolVersion != ports.ProtocolVersion {
+	if *version.ProtocolVersion != protocol.Version {
 		return ports.RemoteCatalog{}, &ports.RemoteCatalogVersionMismatchError{
 			Got:  *version.ProtocolVersion,
-			Want: ports.ProtocolVersion,
+			Want: protocol.Version,
 			Kind: "protocol",
 		}
 	}

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

 	"github.com/bnema/vev/internal/adapters/sshstdio"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestRemoteCatalogClientCommandConstruction(t *testing.T) {
 					gotPath = name
 					gotArgs = append([]string(nil), args...)
 					return stdoutCmd(ctx, mustCatalogJSON(t, ports.RemoteCatalog{
-						ProtocolVersion: ports.ProtocolVersion,
+						ProtocolVersion: protocol.Version,
 						SchemaVersion:   ports.RemoteCatalogSchemaVersion,
 						Sessions:        []ports.RemoteCatalogSession{},
 					}))
 	t.Parallel()
 	valid := ports.RemoteCatalog{
-		ProtocolVersion: ports.ProtocolVersion,
+		ProtocolVersion: protocol.Version,
 		SchemaVersion:   ports.RemoteCatalogSchemaVersion,
 		Sessions: []ports.RemoteCatalogSession{
 			{LifecycleID: [16]byte{1}, Name: "work", State: "up", Ephemeral: false, Tabs: []ports.RemoteCatalogTab{{ID: "tab-1"}, {ID: "tab-2", Index: 1}}, Attached: true},
 		},
 		{
 			name:   "mismatching protocol version",
-			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: ports.ProtocolVersion + 1, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{}}),
+			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: protocol.Version + 1, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{}}),
 			check: func(t *testing.T, err error) {
 				t.Helper()
 				var mismatch *ports.RemoteCatalogVersionMismatchError
 				if !errors.As(err, &mismatch) {
 					t.Fatalf("error = %v, want RemoteCatalogVersionMismatchError", err)
 				}
-				if mismatch.Kind != "protocol" || mismatch.Got != ports.ProtocolVersion+1 || mismatch.Want != ports.ProtocolVersion {
+				if mismatch.Kind != "protocol" || mismatch.Got != protocol.Version+1 || mismatch.Want != protocol.Version {
 					t.Fatalf("mismatch = %#v", mismatch)
 				}
 			},
 		{
 			name: "obsolete count-only schema is classified before session decoding",
 			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":2,"sessions":[{"tabs":1}]}`,
-				ports.ProtocolVersion),
+				protocol.Version),
 			check: func(t *testing.T, err error) {
 				t.Helper()
 				var mismatch *ports.RemoteCatalogVersionMismatchError
 		},
 		{
 			name:   "unknown catalogue schema",
-			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":4,"sessions":[]}`, ports.ProtocolVersion),
+			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":4,"sessions":[]}`, protocol.Version),
 			check: func(t *testing.T, err error) {
 				t.Helper()
 				var mismatch *ports.RemoteCatalogVersionMismatchError
 		{
 			name: "count-only tabs rejected",
 			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":%d,"sessions":[{"lifecycle_id":"01000000000000000000000000000000","name":"work","state":"up","ephemeral":false,"tabs":1,"attached":false}]}`,
-				ports.ProtocolVersion, ports.RemoteCatalogSchemaVersion),
+				protocol.Version, ports.RemoteCatalogSchemaVersion),
 			wantErr: errCatalogDecode,
 		},
 		{
 			name: "unknown fields rejected",
 			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":%d,"sessions":[],"future":true}`,
-				ports.ProtocolVersion, ports.RemoteCatalogSchemaVersion),
+				protocol.Version, ports.RemoteCatalogSchemaVersion),
 			wantErr: errCatalogDecode,
 		},
 		{
 			name: "missing required session field",
 			stdout: fmt.Sprintf(`{"protocol_version":%d,"schema_version":%d,"sessions":[{"lifecycle_id":"01000000000000000000000000000000","name":"work","state":"up","tabs":[],"attached":false}]}`,
-				ports.ProtocolVersion, ports.RemoteCatalogSchemaVersion),
+				protocol.Version, ports.RemoteCatalogSchemaVersion),
 			wantErr: errCatalogRequired,
 		},
 		{
 		},
 		{
 			name:   "missing catalogue schema",
-			stdout: fmt.Sprintf(`{"protocol_version":%d,"sessions":[]}`+"\n", ports.ProtocolVersion),
+			stdout: fmt.Sprintf(`{"protocol_version":%d,"sessions":[]}`+"\n", protocol.Version),
 			check: func(t *testing.T, err error) {
 				t.Helper()
 				var mismatch *ports.RemoteCatalogVersionMismatchError
 		},
 		{
 			name:    "missing sessions",
-			stdout:  fmt.Sprintf(`{"protocol_version":%d,"schema_version":%d}`+"\n", ports.ProtocolVersion, ports.RemoteCatalogSchemaVersion),
+			stdout:  fmt.Sprintf(`{"protocol_version":%d,"schema_version":%d}`+"\n", protocol.Version, ports.RemoteCatalogSchemaVersion),
 			wantErr: errCatalogRequired,
 		},
 		{
 			name: "invalid session name",
-			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: ports.ProtocolVersion, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{{
+			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: protocol.Version, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{{
 				LifecycleID: [16]byte{1}, Name: "bad name", State: "up", Tabs: []ports.RemoteCatalogTab{},
 			}}}),
 			wantErr: ports.ErrInvalidRemoteCatalog,
 		},
 		{
 			name: "invalid session state",
-			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: ports.ProtocolVersion, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{{
+			stdout: mustCatalogJSON(t, ports.RemoteCatalog{ProtocolVersion: protocol.Version, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{{
 				LifecycleID: [16]byte{1}, Name: "work", State: "weird", Tabs: []ports.RemoteCatalogTab{},
 			}}}),
 			wantErr: ports.ErrRemoteCatalogUnknownState,
 		command: func(ctx context.Context, name string, args ...string) *exec.Cmd {
 			commandCtx = ctx
 			cmd = stdoutCmd(ctx, mustCatalogJSON(t, ports.RemoteCatalog{
-				ProtocolVersion: ports.ProtocolVersion,
+				ProtocolVersion: protocol.Version,
 				SchemaVersion:   ports.RemoteCatalogSchemaVersion,
 				Sessions:        []ports.RemoteCatalogSession{},
 			}))

M internal/adapters/sshstdio/transport_test.go +5 -4

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestBuildCommandUsesExecArgs(t *testing.T) {
 	defer func() { _ = client.Close() }()
 	defer func() { _ = server.Close() }()
-	hello := ports.Hello{Version: ports.ProtocolVersion + 1, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}}
+	hello := protocol.Hello{Version: protocol.Version + 1, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}}
 	go func() {
 		f, err := server.Recv()
 		if err != nil {
 			t.Errorf("UnmarshalHello: %v", err)
 			return
 		}
-		if got.Version == ports.ProtocolVersion {
+		if got.Version == protocol.Version {
 			t.Errorf("test did not send a mismatched version")
 		}
-		_ = server.Send(ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(ports.ErrorMsg{Code: ports.ErrVersionMismatch, Text: "protocol version mismatch"})})
+		_ = server.Send(ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "protocol version mismatch"})})
 	}()
 	if err := client.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}); err != nil {
 	if err != nil {
 		t.Fatalf("UnmarshalErrorMsg: %v", err)
 	}
-	if em.Code != ports.ErrVersionMismatch {
+	if em.Code != protocol.ErrVersionMismatch {
 		t.Fatalf("error code = %d, want ErrVersionMismatch", em.Code)
 	}
 }

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

 	"github.com/bnema/vev/internal/adapters/clock"
 	"github.com/bnema/vev/internal/adapters/ipc"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	commandusecase "github.com/bnema/vev/internal/usecase/command"
 	"github.com/bnema/vev/internal/usecase/daemon"
 )
 		_, err := fmt.Fprintln(deps.stdout, cmdHelp(invocation))
 		return err
 	}
-	request := ports.CommandRequest{
+	request := protocol.CommandRequest{
-		Version:       ports.ProtocolVersion,
+		Version:       protocol.Version,
 		Self:          invocation.self,
 		Slug:          invocation.slug,
 		Args:          invocation.args,
 		return &exitCoded{code: 3, err: err}
 	}
 	if !result.OK {
-		if result.Code == ports.ErrInvalidCommandArgs {
+		if result.Code == protocol.ErrInvalidCommandArgs {
 			return &exitCoded{code: 2, err: errors.New(result.Text)}
 		}
 		return errors.New(result.Text)

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

 	"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/daemon"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 		t.Run(tt.slug, func(t *testing.T) {
 			parsed, err := parseArgs(append([]string{"cmd", tt.slug}, tt.args...))
 			require.NoError(t, err)
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true})}}
+			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 			require.NoError(t, runCmdWithDeps(context.Background(), parsed.cmd, cmdDeps{
 				stdout: io.Discard,
 				getenv: func(string) string { return "" },
 			require.NoError(t, err)
 			require.Equal(t, tt.slug, request.Slug)
 			require.Equal(t, tt.args, request.Args)
-			require.Equal(t, ports.ProtocolVersion, request.Version)
+			require.Equal(t, protocol.Version, request.Version)
 		})
 	}
 }
 func TestRemoteCatalogCommandEnsuresDaemon(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	ensureCalls := 0
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "remote-catalog", jsonOut: true}, cmdDeps{
 		stdout: io.Discard,
 		{slug: "move-tab", args: []string{"work", "extra"}},
 	} {
 		t.Run(invocation.slug+"/"+strconv.Itoa(len(invocation.args)), func(t *testing.T) {
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{
+			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{
-				Code: ports.ErrInvalidCommandArgs, Text: "invalid command arguments",
+				Code: protocol.ErrInvalidCommandArgs, Text: "invalid command arguments",
 			})}}
 			err := runCmdWithDeps(context.Background(), invocation, cmdDeps{
 				stdout: io.Discard,
 		t.Run(slug, func(t *testing.T) {
 			invocation, err := parseArgs([]string{"cmd", "--self", slug})
 			require.NoError(t, err)
-			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true})}}
+			transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 			require.NoError(t, runCmdWithDeps(context.Background(), invocation.cmd, cmdDeps{
 				stdout: io.Discard,
 				getenv: func(string) string { return "session=work,tab=t_abc,pane=p_def" },
 }
 func TestRunCmdBuildsOneShotTargetedRequest(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true, Output: "done"})}}
+	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true, Output: "done"})}}
 	out := new(strings.Builder)
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right", self: true}, cmdDeps{
 		stdout: out,
 }
 func TestRunCmdVEVWithoutSelfUsesIDsOnlyAsSessionLocator(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right"}, cmdDeps{
 		stdout: io.Discard,
 		getenv: func(string) string { return "session=old,tab=t_abc,pane=p_def" },
 }
 func TestRunCmdExplicitSessionDoesNotUseEnvIDsWithoutSelf(t *testing.T) {
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{OK: true})}}
+	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{OK: true})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "new-tab", session: "current"}, cmdDeps{
 		stdout: io.Discard,
 		getenv: func(string) string { return "session=old,tab=t_abc,pane=p_def" },
 func TestRunCmdZeroRequestIDReplyReturnsDaemonError(t *testing.T) {
 	const want = "daemon error"
-	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(ports.CommandResult{
+	transport := &cmdTestTransport{recv: ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(protocol.CommandResult{
-		Code: ports.ErrInternal, Text: want,
+		Code: protocol.ErrInternal, Text: want,
 	})}}
 	err := runCmdWithDeps(context.Background(), cmdInvocation{slug: "split-right"}, cmdDeps{
 		stdout: io.Discard,
 func TestRunCmdClassifiesDaemonCommandErrors(t *testing.T) {
 	tests := []struct {
 		name     string
-		result   ports.CommandResult
+		result   protocol.CommandResult
 		wantCode int
 	}{
 		{
 			name:     "invalid command arguments are usage errors",
-			result:   ports.CommandResult{Code: ports.ErrInvalidCommandArgs, Text: "usage: toast [-l level] <message>"},
+			result:   protocol.CommandResult{Code: protocol.ErrInvalidCommandArgs, Text: "usage: toast [-l level] <message>"},
 			wantCode: 2,
 		},
 		{
 			name:     "missing runtime target is a command failure",
-			result:   ports.CommandResult{Code: ports.ErrNoSuchTarget, Text: "no live sessions"},
+			result:   protocol.CommandResult{Code: protocol.ErrNoSuchTarget, Text: "no live sessions"},
 			wantCode: 1,
 		},
 		{
 			name:     "resize not in split remains an exit one failure",
-			result:   ports.CommandResult{Code: ports.ErrNoSuchTarget, Text: "pane is not in a split"},
+			result:   protocol.CommandResult{Code: protocol.ErrNoSuchTarget, Text: "pane is not in a split"},
 			wantCode: 1,
 		},
 		{
 			name:     "resize minimum remains an exit one failure",
-			result:   ports.CommandResult{Code: ports.ErrNoSuchTarget, Text: "pane cannot be resized further"},
+			result:   protocol.CommandResult{Code: protocol.ErrNoSuchTarget, Text: "pane cannot be resized further"},
 			wantCode: 1,
 		},
 	}

M internal/app/daemon_integration_test.go +41 -40

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/persist"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/daemon"
 	"github.com/bnema/vev/internal/usecase/recovery"
 )
 	t.Helper()
 	tr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
-	hello := ports.Hello{Version: ports.ProtocolVersion, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color", TrueColor: true, Env: env}
+	hello := protocol.Hello{Version: protocol.Version, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color", TrueColor: true, Env: env}
 	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)}))
 	p := recvPump(tr)
 	select {
 	return tr, p
 }
-func listRemoteSessions(t *testing.T, dir string) ports.Sessions {
+func listRemoteSessions(t *testing.T, dir string) protocol.Sessions {
 	t.Helper()
 	tr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = tr.Close() }()
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(ports.List{})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}))
 	f, err := tr.Recv()
 	require.NoError(t, err)
 	require.Equal(t, ports.MsgSessions, f.Type)
 		return err
 	}
 	defer func() { _ = tr.Close() }()
-	if err := tr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(ports.Kill{All: true})}); err != nil {
+	if err := tr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}); err != nil {
 		return err
 	}
 	_, err = tr.Recv()
 func assertChildEnvironment(t *testing.T, tr ports.Transport, p *pump, sz domain.Size, wantTestEnv, wantShell, wantRuntimeDir, wantWayland string) {
 	t.Helper()
 	command := "printf '\\033[2J\\033[H'; printf 'VEV_TEST_ENV=%s SHELL=%s XDG_RUNTIME_DIR=%s WAYLAND_DISPLAY=%s TERM=%s COLORTERM=%s TERM_PROGRAM=%s VEV_PREFIX=%.24s\\n' \"$VEV_TEST_ENV\" \"${SHELL##*/}\" \"$XDG_RUNTIME_DIR\" \"$WAYLAND_DISPLAY\" \"$TERM\" \"$COLORTERM\" \"$TERM_PROGRAM\" \"$VEV\"\n"
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte(command)})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(command)})}))
 	text := awaitScreenText(t, p, sz, "TERM_PROGRAM=vev")
 	for _, want := range []string{
 		"VEV_TEST_ENV=" + wantTestEnv,
 		"TERM=client", "COLORTERM=client", "TERM_PROGRAM=client", "VEV=client",
 	}
-	tr1, p1 := attachWithEnvironment(t, dir, ports.IntentNew, "environment", sz, firstEnv)
+	tr1, p1 := attachWithEnvironment(t, dir, protocol.IntentNew, "environment", sz, firstEnv)
 	defer func() { _ = tr1.Close() }()
 	awaitText(t, p1, sz, "SHELL_COMMAND=first")
 	assertChildEnvironment(t, tr1, p1, sz, "first", firstShell, "/run/first", "wayland-first")
 		"VEV_TEST_ENV=second", "SHELL=" + secondShell, "XDG_RUNTIME_DIR=/run/second", "WAYLAND_DISPLAY=wayland-second",
 		"TERM=client", "COLORTERM=client", "TERM_PROGRAM=client", "VEV=client",
 	}
-	tr2, p2 := attachWithEnvironment(t, dir, ports.IntentAttach, "environment", sz, secondEnv)
+	tr2, p2 := attachWithEnvironment(t, dir, protocol.IntentAttach, "environment", sz, secondEnv)
 	defer func() { _ = tr2.Close() }()
 	// The first shell was already running, so it retains its original environment.
 	assertChildEnvironment(t, tr2, p2, sz, "first", firstShell, "/run/first", "wayland-first")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p2, sz, "Commands")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	awaitText(t, p2, sz, "SHELL_COMMAND=second")
 	assertChildEnvironment(t, tr2, p2, sz, "second", secondShell, "/run/second", "wayland-second")
 }
 		"VEV_TEST_ENV=first", "SHELL=" + firstShell, "XDG_RUNTIME_DIR=/run/first", "WAYLAND_DISPLAY=wayland-first",
 		"TERM=client", "COLORTERM=client", "TERM_PROGRAM=client", "VEV=client",
 	}
-	tr1, p1 := attachWithEnvironment(t, dir, ports.IntentNew, "environment", sz, firstEnv)
+	tr1, p1 := attachWithEnvironment(t, dir, protocol.IntentNew, "environment", sz, firstEnv)
 	defer func() { _ = tr1.Close() }()
 	awaitText(t, p1, sz, "SHELL_COMMAND=first")
 	assertChildEnvironment(t, tr1, p1, sz, "first", firstShell, "/run/first", "wayland-first")
 		"VEV_TEST_ENV=second", "SHELL=" + secondShell, "XDG_RUNTIME_DIR=/run/second", "WAYLAND_DISPLAY=wayland-second",
 		"TERM=client", "COLORTERM=client", "TERM_PROGRAM=client", "VEV=client",
 	}
-	tr2, p2 := attachWithEnvironment(t, dir, ports.IntentAttach, "environment", sz, secondEnv)
+	tr2, p2 := attachWithEnvironment(t, dir, protocol.IntentAttach, "environment", sz, secondEnv)
 	defer func() { _ = tr2.Close() }()
 	assertChildEnvironment(t, tr2, p2, sz, "first", firstShell, "/run/first", "wayland-first")
 	// The second attachment mutates shared tab state. Its newly opened PTY must
 	// also be rendered to that attachment, not only to the coordinator primary.
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p2, sz, "Commands")
-	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr2.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	awaitText(t, p2, sz, "SHELL_COMMAND=second")
 	// Each attachment owns its selected tab. Move the first attachment to the
 	// new PTY before releasing its gate, so the fresh PTY output must reach both
 	// views rather than only being recovered by a later first paint.
-	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1b2")})}))
+	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b2")})}))
 	awaitText(t, p1, sz, "SHELL_COMMAND=second")
-	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("go\n")})}))
+	require.NoError(t, tr1.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("go\n")})}))
 	awaitText(t, p2, sz, sharedOutput)
 	awaitText(t, p1, sz, sharedOutput)
 }
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, _ := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf HELLO; sleep 30"}))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
 	awaitText(t, p, sz, "HELLO")
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, _ := startDaemon(t, daemon.WithShell("/bin/cat", nil))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("PINGPONG\n")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("PINGPONG\n")})}))
 	awaitText(t, p, sz, "PINGPONG")
 }
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, _ := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf READY; sleep 30"}))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
 	awaitText(t, p, sz, "READY")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p, sz, "Commands")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("CNT\r")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("CNT\r")})}))
 	// Tab labels are enriched with the focused pane's title; with no process
 	// inspector wired in this test, that title falls back to the shell's
 	// basename ("sh").
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, _ := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf READY; sleep 30"}))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
 	text := awaitScreenText(t, p, sz, "READY")
 	require.Contains(t, text, " 0* ")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1b ")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1b ")})}))
 	awaitText(t, p, sz, "Commands")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("RNS\r")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("RNS\r")})}))
 	awaitText(t, p, sz, "Rename session")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x7fwork\r")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x7fwork\r")})}))
 	text = awaitScreenText(t, p, sz, " work ")
 	require.NotContains(t, text, "work*")
 	listTr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = listTr.Close() }()
-	require.NoError(t, listTr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(ports.List{})}))
+	require.NoError(t, listTr.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}))
 	f, err := listTr.Recv()
 	require.NoError(t, err)
 	require.Equal(t, ports.MsgSessions, f.Type)
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, _ := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf READY; sleep 30"}))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	defer func() { _ = tr.Close() }()
 	text := awaitScreenText(t, p, sz, "READY")
 	require.NotContains(t, text, " 1  2 ")
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("\x1bc")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("\x1bc")})}))
 	assertNoTextAfterInput(t, p, sz, " 1  2 ")
 }
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, served := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf MARKER; sleep 30"}))
-	tr1, p1 := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr1, p1 := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	awaitText(t, p1, sz, "MARKER")
 	require.NoError(t, tr1.Close())
 	case <-time.After(300 * time.Millisecond):
 	}
-	tr2, p2 := attach(t, dir, ports.IntentAttach, "0", sz)
+	tr2, p2 := attach(t, dir, protocol.IntentAttach, "0", sz)
 	defer func() { _ = tr2.Close() }()
 	awaitText(t, p2, sz, "MARKER")
 	dir := ipc.SocketDir()
 	_, served := startDaemonInDir(t, dir, daemon.WithShell("/bin/sh", []string{"-c", "printf TEMP; sleep 30"}))
-	tr, p := attach(t, dir, ports.IntentEphemeral, "", sz)
+	tr, p := attach(t, dir, protocol.IntentEphemeral, "", sz)
 	awaitText(t, p, sz, "TEMP")
 	require.NoError(t, tr.Close())
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, served := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "printf MARKER; sleep 30"}))
-	tr1, p1 := attach(t, dir, ports.IntentNew, "work", sz)
+	tr1, p1 := attach(t, dir, protocol.IntentNew, "work", sz)
 	awaitText(t, p1, sz, "MARKER")
 	// Detach: a named session must survive.
 	}
 	// Re-attach: the first paint must reproduce the retained screen state.
-	tr2, p2 := attach(t, dir, ports.IntentAttach, "work", sz)
+	tr2, p2 := attach(t, dir, protocol.IntentAttach, "work", sz)
 	defer func() { _ = tr2.Close() }()
 	awaitText(t, p2, sz, "MARKER")
 }
 	served := make(chan error, 1)
 	go func() { served <- d.Serve(ctx, listener) }()
-	tr, _ := attach(t, runtimeDir, ports.IntentNew, name, domain.Size{Cols: 80, Rows: 24})
+	tr, _ := attach(t, runtimeDir, protocol.IntentNew, name, domain.Size{Cols: 80, Rows: 24})
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("checkpoint me\n")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("checkpoint me\n")})}))
 	require.Eventually(t, func() bool {
 		record, ok, _ := opened.Catalogue.Record(name)
 		return ok && record.Committed != nil && record.DegradedReason == ""
 	}()
 	awaitLifecycleStage(t, listenerReady, "daemon listener")
-	tr, _ := attach(t, runtimeDir, ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24})
+	tr, _ := attach(t, runtimeDir, protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24})
-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte("dirty state\n")})}))
+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte("dirty state\n")})}))
 	awaitLifecycleStage(t, repository.entered, "snapshot publication")
 	require.NoError(t, tr.Close())
 	require.Eventually(t, func() bool {
 	sz := domain.Size{Cols: 80, Rows: 24}
 	dir, served := startDaemon(t, daemon.WithShell("/bin/sh", []string{"-c", "sleep 30"}))
-	tr1, _ := attach(t, dir, ports.IntentNew, "one", sz)
+	tr1, _ := attach(t, dir, protocol.IntentNew, "one", sz)
 	require.NoError(t, tr1.Close())
-	tr2, _ := attach(t, dir, ports.IntentNew, "two", sz)
+	tr2, _ := attach(t, dir, protocol.IntentNew, "two", sz)
 	require.NoError(t, tr2.Close())
 	killTr, err := ipc.DialContext(context.Background(), dir)
 	require.NoError(t, err)
 	defer func() { _ = killTr.Close() }()
-	require.NoError(t, killTr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(ports.Kill{All: true})}))
+	require.NoError(t, killTr.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}))
 	_, err = killTr.Recv()
 	require.ErrorIs(t, err, io.EOF)

M internal/app/final_acceptance_test.go +12 -12


@@ -15,7 +15,7 @@ import (
15			15
16		func sendAcceptanceInput(t *testing.T, tr ports.Transport, data string) {	16		func sendAcceptanceInput(t *testing.T, tr ports.Transport, data string) {
17		t.Helper()	17		t.Helper()
18	-	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte(data)})}))	18	+	require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(data)})}))
19		}	19		}
20			20
21		func awaitAcceptanceFrame(t testing.T, p pump, typ ports.MsgType, predicate func(ports.Frame) bool) ports.Frame {	21		func awaitAcceptanceFrame(t testing.T, p pump, typ ports.MsgType, predicate func(ports.Frame) bool) ports.Frame {

@@ -35,7 +35,7 @@ func awaitAcceptanceFrame(t testing.T, p pump, typ ports.MsgType, predicate fu
35		}	35		}
36		}	36		}
37			37
38	-	func awaitAcceptanceCommand(t testing.T, p pump, requestID uint64) ports.CommandResult {	38	+	func awaitAcceptanceCommand(t testing.T, p pump, requestID uint64) protocol.CommandResult {
39		t.Helper()	39		t.Helper()
40		frame := awaitAcceptanceFrame(t, p, ports.MsgCommandResult, func(frame ports.Frame) bool {	40		frame := awaitAcceptanceFrame(t, p, ports.MsgCommandResult, func(frame ports.Frame) bool {
41		result, err := ports.UnmarshalCommandResult(frame.Payload)	41		result, err := ports.UnmarshalCommandResult(frame.Payload)

@@ -59,10 +59,10 @@ func awaitAcceptanceOutput(t testing.T, p pump, predicate func(protocol.Output
59		return output	59		return output
60		}	60		}
61			61
62	-	func awaitAcceptanceCommandResult(t testing.T, tr ports.Transport, p pump, requestID uint64, slug string) ports.CommandResult {	62	+	func awaitAcceptanceCommandResult(t testing.T, tr ports.Transport, p pump, requestID uint64, slug string) protocol.CommandResult {
63		t.Helper()	63		t.Helper()
64	-	payload, err := ports.MarshalCommandRequest(ports.CommandRequest{	64	+	payload, err := ports.MarshalCommandRequest(protocol.CommandRequest{
65	-	Version: ports.ProtocolVersion, RequestID: requestID, Attached: true, Slug: slug,	65	+	Version: protocol.Version, RequestID: requestID, Attached: true, Slug: slug,
66		})	66		})
67		require.NoError(t, err)	67		require.NoError(t, err)
68		require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgCommand, Payload: payload}))	68		require.NoError(t, tr.Send(ports.Frame{Type: ports.MsgCommand, Payload: payload}))

@@ -72,8 +72,8 @@ func awaitAcceptanceCommandResult(t testing.T, tr ports.Transport, p pump, req
72		func TestAcceptanceTwoLocalAttachmentsKeepViewsOverTransports(t *testing.T) {	72		func TestAcceptanceTwoLocalAttachmentsKeepViewsOverTransports(t *testing.T) {
73		size := domain.Size{Cols: 80, Rows: 24}	73		size := domain.Size{Cols: 80, Rows: 24}
74		dir, _ := startDaemon(t, daemon.WithShell("/bin/cat", nil))	74		dir, _ := startDaemon(t, daemon.WithShell("/bin/cat", nil))
75	-	first, firstPump := attach(t, dir, ports.IntentNew, "shared", size)	75	+	first, firstPump := attach(t, dir, protocol.IntentNew, "shared", size)
76	-	second, secondPump := attach(t, dir, ports.IntentAttach, "shared", size)	76	+	second, secondPump := attach(t, dir, protocol.IntentAttach, "shared", size)
77		t.Cleanup(func() { _ = first.Close() })	77		t.Cleanup(func() { _ = first.Close() })
78		t.Cleanup(func() { _ = second.Close() })	78		t.Cleanup(func() { _ = second.Close() })
79			79

@@ -121,12 +121,12 @@ func TestAcceptanceTwoLocalAttachmentsKeepViewsOverTransports(t *testing.T) {
121		require.Equal(t, domain.Size{Cols: 100, Rows: 30}, resized.Size)	121		require.Equal(t, domain.Size{Cols: 100, Rows: 30}, resized.Size)
122		assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")	122		assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")
123			123
124	-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}))	124	+	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
125		reset := awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Base == 0 && output.Full })	125		reset := awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Base == 0 && output.Full })
126		require.True(t, reset.Full)	126		require.True(t, reset.Full)
127		assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")	127		assertNoTextAfterInput(t, secondPump, size, "FIRST_PANE_INPUT")
128			128
129	-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})}))	129	+	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}))
130		deadline := time.NewTimer(5 * time.Second)	130		deadline := time.NewTimer(5 * time.Second)
131		defer deadline.Stop()	131		defer deadline.Stop()
132		for {	132		for {

@@ -149,8 +149,8 @@ detached:
149		func TestAcceptanceAttachedCommandUsesItsConnectionOnly(t *testing.T) {	149		func TestAcceptanceAttachedCommandUsesItsConnectionOnly(t *testing.T) {
150		size := domain.Size{Cols: 80, Rows: 24}	150		size := domain.Size{Cols: 80, Rows: 24}
151		dir, _ := startDaemon(t, daemon.WithShell("/bin/cat", nil))	151		dir, _ := startDaemon(t, daemon.WithShell("/bin/cat", nil))
152	-	first, firstPump := attach(t, dir, ports.IntentNew, "commands", size)	152	+	first, firstPump := attach(t, dir, protocol.IntentNew, "commands", size)
153	-	second, secondPump := attach(t, dir, ports.IntentAttach, "commands", size)	153	+	second, secondPump := attach(t, dir, protocol.IntentAttach, "commands", size)
154		t.Cleanup(func() { _ = first.Close() })	154		t.Cleanup(func() { _ = first.Close() })
155		t.Cleanup(func() { _ = second.Close() })	155		t.Cleanup(func() { _ = second.Close() })
156			156

@@ -173,7 +173,7 @@ func TestAcceptanceAttachedCommandUsesItsConnectionOnly(t *testing.T) {
173		}	173		}
174			174
175		drained:	175		drained:
176	-	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}))	176	+	require.NoError(t, first.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}))
177		awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Full && output.Base == 0 })	177		awaitAcceptanceOutput(t, firstPump, func(output protocol.Output) bool { return output.Full && output.Base == 0 })
178		assertNoTextAfterInput(t, secondPump, size, "Commands")	178		assertNoTextAfterInput(t, secondPump, size, "Commands")
179		}	179		}

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


@@ -23,7 +23,7 @@ import (
23		type acceptanceRemoteFactory struct {	23		type acceptanceRemoteFactory struct {
24		mu sync.Mutex	24		mu sync.Mutex
25		calls []string	25		calls []string
26	-	handoff map[string]ports.AttachTarget	26	+	handoff map[string]protocol.AttachTarget
27		outputs chan string	27		outputs chan string
28		}	28		}
29			29

@@ -37,7 +37,7 @@ func (f *acceptanceRemoteFactory) DialerForRemote(target string, _ string, _ por
37			37
38		type acceptanceRemoteDialer struct {	38		type acceptanceRemoteDialer struct {
39		target string	39		target string
40	-	handoff ports.AttachTarget	40	+	handoff protocol.AttachTarget
41		outputs chan<- string	41		outputs chan<- string
42		}	42		}
43			43

@@ -49,7 +49,7 @@ func (d acceptanceRemoteDialer) Dial(context.Context) (ports.Transport, error) {
49		return clientTransport, nil	49		return clientTransport, nil
50		}	50		}
51			51
52	-	func serveAcceptanceRemote(tr ports.Transport, target string, handoff ports.AttachTarget, outputs chan<- string) {	52	+	func serveAcceptanceRemote(tr ports.Transport, target string, handoff protocol.AttachTarget, outputs chan<- string) {
53		defer func() { _ = tr.Close() }()	53		defer func() { _ = tr.Close() }()
54		welcomed := false	54		welcomed := false
55		for {	55		for {

@@ -61,7 +61,7 @@ func serveAcceptanceRemote(tr ports.Transport, target string, handoff ports.Atta
61		if frame.Type != ports.MsgHello {	61		if frame.Type != ports.MsgHello {
62		continue	62		continue
63		}	63		}
64	-	if err := tr.Send(ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(ports.Welcome{SessionID: target})}); err != nil {	64	+	if err := tr.Send(ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: target})}); err != nil {
65		return	65		return
66		}	66		}
67		welcomed = true	67		welcomed = true

@@ -88,7 +88,7 @@ func serveAcceptanceRemote(tr ports.Transport, target string, handoff ports.Atta
88		if err := tr.Send(ports.Frame{Type: ports.MsgOutput, Payload: payload}); err != nil {	88		if err := tr.Send(ports.Frame{Type: ports.MsgOutput, Payload: payload}); err != nil {
89		return	89		return
90		}	90		}
91	-	_ = tr.Send(ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach})})	91	+	_ = tr.Send(ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})})
92		for {	92		for {
93		if _, err := tr.Recv(); err != nil {	93		if _, err := tr.Recv(); err != nil {
94		return	94		return

@@ -139,7 +139,7 @@ func TestAcceptanceRemoteDirectAndPickerUseOnlyRemoteTransports(t *testing.T) {
139		result := client.NewRunner(deps).Run(ctx, request)	139		result := client.NewRunner(deps).Run(ctx, request)
140		if request.SessionName == "work" {	140		if request.SessionName == "work" {
141		require.NoError(t, result, "the client handoff completes before the test injects the composition-root handoff")	141		require.NoError(t, result, "the client handoff completes before the test injects the composition-root handoff")
142	-	return &client.AttachTargetError{Target: ports.AttachTarget{Endpoint: "picked.example", Session: "picked", Intent: ports.IntentAttach}}	142	+	return &client.AttachTargetError{Target: protocol.AttachTarget{Endpoint: "picked.example", Session: "picked", Intent: protocol.IntentAttach}}
143		}	143		}
144		return result	144		return result
145		},	145		},

@@ -147,11 +147,11 @@ func TestAcceptanceRemoteDirectAndPickerUseOnlyRemoteTransports(t *testing.T) {
147			147
148		wireTransport, err := (acceptanceRemoteDialer{	148		wireTransport, err := (acceptanceRemoteDialer{
149		target: "picker-wire.example",	149		target: "picker-wire.example",
150	-	handoff: ports.AttachTarget{Endpoint: "picked.example", Session: "picked", Intent: ports.IntentAttach},	150	+	handoff: protocol.AttachTarget{Endpoint: "picked.example", Session: "picked", Intent: protocol.IntentAttach},
151		}).Dial(context.Background())	151		}).Dial(context.Background())
152		require.NoError(t, err)	152		require.NoError(t, err)
153	-	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(ports.Hello{	153	+	require.NoError(t, wireTransport.Send(ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
154	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24},	154	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24},
155		})}))	155		})}))
156		welcome, err := wireTransport.Recv()	156		welcome, err := wireTransport.Recv()
157		require.NoError(t, err)	157		require.NoError(t, err)

@@ -165,8 +165,8 @@ func TestAcceptanceRemoteDirectAndPickerUseOnlyRemoteTransports(t *testing.T) {
165		require.Equal(t, "picked.example", target.Endpoint)	165		require.Equal(t, "picked.example", target.Endpoint)
166		require.NoError(t, wireTransport.Close())	166		require.NoError(t, wireTransport.Close())
167			167
168	-	require.NoError(t, runAttachWithDeps(context.Background(), ports.IntentAttach, "direct", "direct.example", "", nil, deps))	168	+	require.NoError(t, runAttachWithDeps(context.Background(), protocol.IntentAttach, "direct", "direct.example", "", nil, deps))
169	-	require.NoError(t, runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "picker.example", "", nil, deps))	169	+	require.NoError(t, runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "picker.example", "", nil, deps))
170		factory.mu.Lock()	170		factory.mu.Lock()
171		calls := append([]string(nil), factory.calls...)	171		calls := append([]string(nil), factory.calls...)
172		factory.mu.Unlock()	172		factory.mu.Unlock()

M internal/app/remote_hosts.go +10 -9

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/platform"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 const (
 	stateDir  func() string
 	store     ports.RemoteHostStore
 	catalog   ports.RemoteCatalogClient
-	localList func(context.Context) ([]ports.SessionInfo, error)
+	localList func(context.Context) ([]protocol.SessionInfo, error)
 	stdout    io.Writer
 }
 		}
 		return err
 	}
-	all := append([]ports.SessionInfo(nil), local...)
+	all := append([]protocol.SessionInfo(nil), local...)
 	var hostErrs []error
 	for _, host := range hosts {
 		if err := ctx.Err(); err != nil {
 	return nil
 }
-func catalogSessionsAsInfo(host string, sessions []ports.RemoteCatalogSession) []ports.SessionInfo {
+func catalogSessionsAsInfo(host string, sessions []ports.RemoteCatalogSession) []protocol.SessionInfo {
-	out := make([]ports.SessionInfo, 0, len(sessions))
+	out := make([]protocol.SessionInfo, 0, len(sessions))
 	for _, session := range sessions {
-		info := ports.SessionInfo{
+		info := protocol.SessionInfo{
 			Name:      domain.RemoteSessionDisplay(session.Name, host),
 			Ephemeral: session.Ephemeral,
 			Tabs:      ports.SaturateUint16(ports.CatalogTabCount(session)),
 		}
 		switch session.State {
 		case ports.RemoteCatalogSessionUp:
-			info.State = ports.SessionUp
+			info.State = protocol.SessionUp
 		case ports.RemoteCatalogSessionDown:
-			info.State = ports.SessionDown
+			info.State = protocol.SessionDown
 		case ports.RemoteCatalogSessionBroken:
-			info.State = ports.SessionBroken
+			info.State = protocol.SessionBroken
 		default:
 			slog.Debug("remote catalog session has unknown state", "host", host, "session", session.Name, "state", session.State)
-			info.State = ports.SessionBroken
+			info.State = protocol.SessionBroken
 		}
 		out = append(out, info)
 	}

M internal/app/remote_test.go +15 -14

 	"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/mock"
 	"github.com/stretchr/testify/require"
 	t.Run("valid", func(t *testing.T) {
 		_, err := decodeSessionListReply(ports.Frame{
 			Type:    ports.MsgError,
-			Payload: ports.MarshalErrorMsg(ports.ErrorMsg{Text: "denied"}),
+			Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Text: "denied"}),
 		})
 		require.EqualError(t, err, "vev: denied")
 	})
 				localErr := errors.New("local release failed")
 				var out bytes.Buffer
 				err := listAllSessions(context.Background(), remoteHostDeps{
-					localList: func(context.Context) ([]ports.SessionInfo, error) {
+					localList: func(context.Context) ([]protocol.SessionInfo, error) {
-						return []ports.SessionInfo{{Name: "local", State: ports.SessionUp}}, localErr
+						return []protocol.SessionInfo{{Name: "local", State: protocol.SessionUp}}, localErr
 					},
 					stdout: &out,
 				}, nil)
 				var out bytes.Buffer
 				err := listAllSessions(ctx, remoteHostDeps{
 					catalog: catalog,
-					localList: func(context.Context) ([]ports.SessionInfo, error) {
+					localList: func(context.Context) ([]protocol.SessionInfo, error) {
-						return []ports.SessionInfo{{Name: "local", State: ports.SessionUp}}, nil
+						return []protocol.SessionInfo{{Name: "local", State: protocol.SessionUp}}, nil
 					},
 					stdout: &out,
 				}, []domain.RemoteHost{{Target: "arch"}, {Target: "mule"}})
 				var out bytes.Buffer
 				err := listAllSessions(context.Background(), remoteHostDeps{
 					catalog: catalog,
-					localList: func(context.Context) ([]ports.SessionInfo, error) {
+					localList: func(context.Context) ([]protocol.SessionInfo, error) {
-						return []ports.SessionInfo{{Name: "local", State: ports.SessionUp}}, nil
+						return []protocol.SessionInfo{{Name: "local", State: protocol.SessionUp}}, nil
 					},
 					stdout: &out,
 				}, []domain.RemoteHost{{Target: "arch"}, {Target: "mule"}})
 	tests := []struct {
 		name      string
 		session   ports.RemoteCatalogSession
-		wantState ports.SessionState
+		wantState protocol.SessionState
 		wantTabs  uint16
 	}{
-		{name: "up", session: ports.RemoteCatalogSession{Name: "dev", State: "up", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: ports.SessionUp, wantTabs: 2},
+		{name: "up", session: ports.RemoteCatalogSession{Name: "dev", State: "up", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: protocol.SessionUp, wantTabs: 2},
-		{name: "down", session: ports.RemoteCatalogSession{Name: "dev", State: "down", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: ports.SessionDown, wantTabs: 2},
+		{name: "down", session: ports.RemoteCatalogSession{Name: "dev", State: "down", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: protocol.SessionDown, wantTabs: 2},
-		{name: "broken", session: ports.RemoteCatalogSession{Name: "dev", State: "broken", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: ports.SessionBroken, wantTabs: 2},
+		{name: "broken", session: ports.RemoteCatalogSession{Name: "dev", State: "broken", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: protocol.SessionBroken, wantTabs: 2},
-		{name: "unknown fails closed", session: ports.RemoteCatalogSession{Name: "dev", State: "unknown", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: ports.SessionBroken, wantTabs: 2},
+		{name: "unknown fails closed", session: ports.RemoteCatalogSession{Name: "dev", State: "unknown", Tabs: []ports.RemoteCatalogTab{{}, {}}}, wantState: protocol.SessionBroken, wantTabs: 2},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 	factory.EXPECT().DialerForRemote("build@mule", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()
 	var learner ports.RemoteHostLearner
-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "build@mule", "", nil, runAttachDeps{
+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "build@mule", "", nil, runAttachDeps{
 		remoteDialerFactory: factory,
 		hostStore:           store,
 		runClient: func(_ context.Context, deps client.Dependencies, _ client.AttachRequest) error {
 	factory := portsmocks.NewMockRemoteDialerFactory(t)
 	factory.EXPECT().DialerForRemote("arch", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()
 	var learner ports.RemoteHostLearner
-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "arch", "", nil, runAttachDeps{
+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "arch", "", nil, runAttachDeps{
 		remoteDialerFactory: factory,
 		hostStore:           store,
 		runClient: func(_ context.Context, deps client.Dependencies, _ client.AttachRequest) error {

M internal/app/run.go +28 -28


@@ -155,7 +155,7 @@ func Run(args []string) error {
155		// I/O.	155		// I/O.
156		func parseArgs(args []string) (command, error) {	156		func parseArgs(args []string) (command, error) {
157		if len(args) == 0 {	157		if len(args) == 0 {
158	-	return command{kind: kindAttach, intent: ports.IntentEphemeral}, nil	158	+	return command{kind: kindAttach, intent: protocol.IntentEphemeral}, nil
159		}	159		}
160			160
161		switch args[0] {	161		switch args[0] {

@@ -193,7 +193,7 @@ func parseArgs(args []string) (command, error) {
193		if err := domain.ValidateSessionName(args[1]); err != nil {	193		if err := domain.ValidateSessionName(args[1]); err != nil {
194		return command{}, err	194		return command{}, err
195		}	195		}
196	-	return command{kind: kindAttach, intent: ports.IntentNew, name: args[1]}, nil	196	+	return command{kind: kindAttach, intent: protocol.IntentNew, name: args[1]}, nil
197		case "attach", "a":	197		case "attach", "a":
198		if len(args) < 2 \|\| args[1] == "" {	198		if len(args) < 2 \|\| args[1] == "" {
199		return command{}, usagef("`attach` requires a session name")	199		return command{}, usagef("`attach` requires a session name")

@@ -201,7 +201,7 @@ func parseArgs(args []string) (command, error) {
201		if len(args) > 2 {	201		if len(args) > 2 {
202		return command{}, usagef("`attach` accepts exactly one session name or remote target")	202		return command{}, usagef("`attach` accepts exactly one session name or remote target")
203		}	203		}
204	-	cmd := command{kind: kindAttach, intent: ports.IntentAttach, name: args[1]}	204	+	cmd := command{kind: kindAttach, intent: protocol.IntentAttach, name: args[1]}
205		if target, session, ok := parseRemoteAttachTarget(args[1]); ok {	205		if target, session, ok := parseRemoteAttachTarget(args[1]); ok {
206		if err := domain.ValidateRemoteHostTarget(target); err != nil {	206		if err := domain.ValidateRemoteHostTarget(target); err != nil {
207		return command{}, err	207		return command{}, err

@@ -214,7 +214,7 @@ func parseArgs(args []string) (command, error) {
214		cmd.remoteTarget = target	214		cmd.remoteTarget = target
215		cmd.name = session	215		cmd.name = session
216		if session == "" {	216		if session == "" {
217	-	cmd.intent = ports.IntentEphemeral	217	+	cmd.intent = protocol.IntentEphemeral
218		}	218		}
219		}	219		}
220		return cmd, nil	220		return cmd, nil

@@ -828,8 +828,8 @@ func remoteTransportModeFromEnv(value string) (ports.RemoteTransportMode, error)
828		}	828		}
829		}	829		}
830			830
831	-	func validateRemoteAttachHandoff(target ports.AttachTarget) error {	831	+	func validateRemoteAttachHandoff(target protocol.AttachTarget) error {
832	-	if err := ports.ValidateAttachTarget(target); err != nil {	832	+	if err := protocol.ValidateAttachTarget(target); err != nil {
833		return err	833		return err
834		}	834		}
835		if err := domain.ValidateRemoteHostTarget(target.Endpoint); err != nil {	835		if err := domain.ValidateRemoteHostTarget(target.Endpoint); err != nil {

@@ -839,7 +839,7 @@ func validateRemoteAttachHandoff(target ports.AttachTarget) error {
839		return err	839		return err
840		}	840		}
841		if target.RemoteTarget != nil {	841		if target.RemoteTarget != nil {
842	-	if target.EnvironmentPolicy != ports.EnvironmentPolicyDaemonOwned {	842	+	if target.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
843		return errors.New("remote picker handoff must use daemon-owned environment")	843		return errors.New("remote picker handoff must use daemon-owned environment")
844		}	844		}
845		if target.RemoteTarget.Endpoint != target.Endpoint \|\| target.RemoteTarget.SessionName != target.Session {	845		if target.RemoteTarget.Endpoint != target.Endpoint \|\| target.RemoteTarget.SessionName != target.Session {

@@ -874,7 +874,7 @@ const maxAttachTargetHandoffs = 32
874			874
875		func runAttachWithDeps(ctx context.Context, intent uint8, name, remoteTarget, activeSession string, log *slog.Logger, deps runAttachDeps) error {	875		func runAttachWithDeps(ctx context.Context, intent uint8, name, remoteTarget, activeSession string, log *slog.Logger, deps runAttachDeps) error {
876		if activeSession != "" {	876		if activeSession != "" {
877	-	if remoteTarget == "" && intent == ports.IntentNew {	877	+	if remoteTarget == "" && intent == protocol.IntentNew {
878		return deps.createDetached(ctx, name)	878		return deps.createDetached(ctx, name)
879		}	879		}
880		return errors.New("vev: sessions should be nested with care; unset VEV to force")	880		return errors.New("vev: sessions should be nested with care; unset VEV to force")

@@ -891,7 +891,7 @@ func runAttachWithDeps(ctx context.Context, intent uint8, name, remoteTarget, ac
891		mode, modeErr := remoteTransportModeFromEnv(deps.selectedRemoteTransport)	891		mode, modeErr := remoteTransportModeFromEnv(deps.selectedRemoteTransport)
892		factory := deps.remoteDialerFactory	892		factory := deps.remoteDialerFactory
893		var remoteSelection *domain.RemoteSessionTarget	893		var remoteSelection *domain.RemoteSessionTarget
894	-	var remoteEnvironmentPolicy ports.EnvironmentPolicy	894	+	var remoteEnvironmentPolicy protocol.EnvironmentPolicy
895		remoteDisplayOrigin := domain.RemoteDisplayOrigin(remoteTarget)	895		remoteDisplayOrigin := domain.RemoteDisplayOrigin(remoteTarget)
896		routeOrigin := protocol.RouteOriginLocal	896		routeOrigin := protocol.RouteOriginLocal
897		routeOriginKey := "local"	897		routeOriginKey := "local"

@@ -906,13 +906,13 @@ func runAttachWithDeps(ctx context.Context, intent uint8, name, remoteTarget, ac
906		}	906		}
907		}	907		}
908		pickerHandoff := remoteTarget == ""	908		pickerHandoff := remoteTarget == ""
909	-	pickerEnvironmentPolicy := func(target *domain.RemoteSessionTarget, policy ports.EnvironmentPolicy) ports.EnvironmentPolicy {	909	+	pickerEnvironmentPolicy := func(target *domain.RemoteSessionTarget, policy protocol.EnvironmentPolicy) protocol.EnvironmentPolicy {
910		if pickerHandoff && target == nil {	910		if pickerHandoff && target == nil {
911	-	return ports.EnvironmentPolicyDaemonOwned	911	+	return protocol.EnvironmentPolicyDaemonOwned
912		}	912		}
913		return policy	913		return policy
914		}	914		}
915	-	handoff := func(target ports.AttachTarget) (ports.Dialer, client.AttachRequest, error) {	915	+	handoff := func(target protocol.AttachTarget) (ports.Dialer, client.AttachRequest, error) {
916		if err := validateRemoteAttachHandoff(target); err != nil {	916		if err := validateRemoteAttachHandoff(target); err != nil {
917		return nil, client.AttachRequest{}, fmt.Errorf("vev: invalid remote attach handoff: %w", err)	917		return nil, client.AttachRequest{}, fmt.Errorf("vev: invalid remote attach handoff: %w", err)
918		}	918		}

@@ -1051,11 +1051,11 @@ func (d localDaemonDialer) Dial(ctx context.Context) (ports.Transport, error) {
1051		return ensureDaemonWithLifecycle(ctx, d.dir, dial, realSpawn, defaultBackoff)	1051		return ensureDaemonWithLifecycle(ctx, d.dir, dial, realSpawn, defaultBackoff)
1052		}	1052		}
1053			1053
1054	-	func detachedLocalHello(name, cwd string) ports.Hello {	1054	+	func detachedLocalHello(name, cwd string) protocol.Hello {
1055		termEnv := os.Getenv("TERM")	1055		termEnv := os.Getenv("TERM")
1056	-	return ports.Hello{	1056	+	return protocol.Hello{
1057	-	Version: ports.ProtocolVersion,	1057	+	Version: protocol.Version,
1058	-	Intent: ports.IntentNew,	1058	+	Intent: protocol.IntentNew,
1059		Name: name,	1059		Name: name,
1060		Size: domain.Size{Cols: 80, Rows: 24},	1060		Size: domain.Size{Cols: 80, Rows: 24},
1061		TermEnv: termEnv,	1061		TermEnv: termEnv,

@@ -1126,7 +1126,7 @@ func requestDaemonStop(ctx context.Context) error {
1126		return errors.Join(errors.New("vev: no daemon running"), owner.Release())	1126		return errors.Join(errors.New("vev: no daemon running"), owner.Release())
1127		}	1127		}
1128		defer func() { _ = transport.Close() }()	1128		defer func() { _ = transport.Close() }()
1129	-	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(ports.Kill{All: true})}); err != nil {	1129	+	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})}); err != nil {
1130		return fmt.Errorf("vev: requesting daemon stop: %w", err)	1130		return fmt.Errorf("vev: requesting daemon stop: %w", err)
1131		}	1131		}
1132		if _, err := transport.Recv(); err != nil && !errors.Is(err, io.EOF) {	1132		if _, err := transport.Recv(); err != nil && !errors.Is(err, io.EOF) {

@@ -1456,7 +1456,7 @@ func runList(ctx context.Context, cmd command) (retErr error) {
1456		return nil	1456		return nil
1457		}	1457		}
1458			1458
1459	-	func listLocalSessions(ctx context.Context) (_ []ports.SessionInfo, retErr error) {	1459	+	func listLocalSessions(ctx context.Context) (_ []protocol.SessionInfo, retErr error) {
1460		transport, owner, err := waitForDaemonOrLifecycle(ctx, ipc.SocketDir(), realDial, defaultBackoff)	1460		transport, owner, err := waitForDaemonOrLifecycle(ctx, ipc.SocketDir(), realDial, defaultBackoff)
1461		if err != nil {	1461		if err != nil {
1462		return nil, fmt.Errorf("vev: waiting for durable session state: %w", err)	1462		return nil, fmt.Errorf("vev: waiting for durable session state: %w", err)

@@ -1470,19 +1470,19 @@ func listLocalSessions(ctx context.Context) (_ []ports.SessionInfo, retErr error
1470		}	1470		}
1471		return nil, fmt.Errorf("vev: reading stored sessions: %w", loadErr)	1471		return nil, fmt.Errorf("vev: reading stored sessions: %w", loadErr)
1472		}	1472		}
1473	-	infos := make([]ports.SessionInfo, 0, len(records))	1473	+	infos := make([]protocol.SessionInfo, 0, len(records))
1474		for _, r := range records {	1474		for _, r := range records {
1475	-	state := ports.SessionDown	1475	+	state := protocol.SessionDown
1476		if r.DegradedReason != "" {	1476		if r.DegradedReason != "" {
1477	-	state = ports.SessionBroken	1477	+	state = protocol.SessionBroken
1478		}	1478		}
1479	-	infos = append(infos, ports.SessionInfo{Name: r.Name, State: state})	1479	+	infos = append(infos, protocol.SessionInfo{Name: r.Name, State: state})
1480		}	1480		}
1481		return infos, nil	1481		return infos, nil
1482		}	1482		}
1483		defer func() { _ = transport.Close() }()	1483		defer func() { _ = transport.Close() }()
1484			1484
1485	-	if err := transport.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(ports.List{})}); err != nil {	1485	+	if err := transport.Send(ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})}); err != nil {
1486		return nil, fmt.Errorf("vev: requesting session list: %w", err)	1486		return nil, fmt.Errorf("vev: requesting session list: %w", err)
1487		}	1487		}
1488		reply, err := transport.Recv()	1488		reply, err := transport.Recv()

@@ -1492,7 +1492,7 @@ func listLocalSessions(ctx context.Context) (_ []ports.SessionInfo, retErr error
1492		return decodeSessionListReply(reply)	1492		return decodeSessionListReply(reply)
1493		}	1493		}
1494			1494
1495	-	func decodeSessionListReply(reply ports.Frame) ([]ports.SessionInfo, error) {	1495	+	func decodeSessionListReply(reply ports.Frame) ([]protocol.SessionInfo, error) {
1496		if reply.Type == ports.MsgError {	1496		if reply.Type == ports.MsgError {
1497		em, err := ports.UnmarshalErrorMsg(reply.Payload)	1497		em, err := ports.UnmarshalErrorMsg(reply.Payload)
1498		if err != nil {	1498		if err != nil {

@@ -1511,7 +1511,7 @@ func decodeSessionListReply(reply ports.Frame) ([]ports.SessionInfo, error) {
1511		}	1511		}
1512			1512
1513		// printSessions renders a session table (or a friendly note when empty).	1513		// printSessions renders a session table (or a friendly note when empty).
1514	-	func printSessions(w io.Writer, sessions []ports.SessionInfo) {	1514	+	func printSessions(w io.Writer, sessions []protocol.SessionInfo) {
1515		if len(sessions) == 0 {	1515		if len(sessions) == 0 {
1516		_, _ = fmt.Fprintln(w, "no sessions")	1516		_, _ = fmt.Fprintln(w, "no sessions")
1517		return	1517		return

@@ -1523,10 +1523,10 @@ func printSessions(w io.Writer, sessions []ports.SessionInfo) {
1523		tabs := fmt.Sprintf("%d", s.Tabs)	1523		tabs := fmt.Sprintf("%d", s.Tabs)
1524		attached := "no"	1524		attached := "no"
1525		switch s.State {	1525		switch s.State {
1526	-	case ports.SessionDown:	1526	+	case protocol.SessionDown:
1527		state = "down"	1527		state = "down"
1528		tabs = "-"	1528		tabs = "-"
1529	-	case ports.SessionBroken:	1529	+	case protocol.SessionBroken:
1530		state = "broken"	1530		state = "broken"
1531		tabs = "-"	1531		tabs = "-"
1532		default:	1532		default:

@@ -1596,7 +1596,7 @@ func runKill(ctx context.Context, name string, all, daemon bool) (retErr error)
1596		}	1596		}
1597		defer func() { _ = transport.Close() }()	1597		defer func() { _ = transport.Close() }()
1598			1598
1599	-	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(ports.Kill{Name: name, All: all \|\| daemon})}); err != nil {	1599	+	if err := transport.Send(ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{Name: name, All: all \|\| daemon})}); err != nil {
1600		return fmt.Errorf("vev: requesting kill: %w", err)	1600		return fmt.Errorf("vev: requesting kill: %w", err)
1601		}	1601		}
1602		reply, err := transport.Recv()	1602		reply, err := transport.Recv()

M internal/app/run_test.go +62 -62


@@ -437,20 +437,20 @@ func TestParseArgs(t *testing.T) {
437		wantErr bool	437		wantErr bool
438		nonUsageErr bool	438		nonUsageErr bool
439		}{	439		}{
440	-	{name: "no args -> ephemeral attach", args: nil, wantKind: kindAttach, wantIntent: ports.IntentEphemeral},	440	+	{name: "no args -> ephemeral attach", args: nil, wantKind: kindAttach, wantIntent: protocol.IntentEphemeral},
441	-	{name: "empty slice -> ephemeral attach", args: []string{}, wantKind: kindAttach, wantIntent: ports.IntentEphemeral},	441	+	{name: "empty slice -> ephemeral attach", args: []string{}, wantKind: kindAttach, wantIntent: protocol.IntentEphemeral},
442	-	{name: "new named", args: []string{"new", "work"}, wantKind: kindAttach, wantIntent: ports.IntentNew, wantName: "work"},	442	+	{name: "new named", args: []string{"new", "work"}, wantKind: kindAttach, wantIntent: protocol.IntentNew, wantName: "work"},
443		{name: "new without name", args: []string{"new"}, wantErr: true},	443		{name: "new without name", args: []string{"new"}, wantErr: true},
444		{name: "new empty name", args: []string{"new", ""}, wantErr: true},	444		{name: "new empty name", args: []string{"new", ""}, wantErr: true},
445		{name: "new command override unsupported", args: []string{"new", "work", "--", "sh"}, wantErr: true},	445		{name: "new command override unsupported", args: []string{"new", "work", "--", "sh"}, wantErr: true},
446	-	{name: "attach named", args: []string{"attach", "work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "work"},	446	+	{name: "attach named", args: []string{"attach", "work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "work"},
447	-	{name: "attach preserves legacy unsafe name", args: []string{"attach", "my work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "my work"},	447	+	{name: "attach preserves legacy unsafe name", args: []string{"attach", "my work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "my work"},
448	-	{name: "attach alias a", args: []string{"a", "work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "work"},	448	+	{name: "attach alias a", args: []string{"a", "work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "work"},
449	-	{name: "attach remote host uses ephemeral", args: []string{"attach", "user@example.com"}, wantKind: kindAttach, wantIntent: ports.IntentEphemeral, wantRemote: "user@example.com"},	449	+	{name: "attach remote host uses ephemeral", args: []string{"attach", "user@example.com"}, wantKind: kindAttach, wantIntent: protocol.IntentEphemeral, wantRemote: "user@example.com"},
450	-	{name: "attach remote host with empty session uses ephemeral", args: []string{"attach", "user@example.com:"}, wantKind: kindAttach, wantIntent: ports.IntentEphemeral, wantRemote: "user@example.com"},	450	+	{name: "attach remote host with empty session uses ephemeral", args: []string{"attach", "user@example.com:"}, wantKind: kindAttach, wantIntent: protocol.IntentEphemeral, wantRemote: "user@example.com"},
451	-	{name: "attach remote host with session", args: []string{"attach", "user@example.com:work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "work", wantRemote: "user@example.com"},	451	+	{name: "attach remote host with session", args: []string{"attach", "user@example.com:work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "work", wantRemote: "user@example.com"},
452	-	{name: "attach remote ipv4 with session", args: []string{"attach", "user@192.0.2.10:work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "work", wantRemote: "user@192.0.2.10"},	452	+	{name: "attach remote ipv4 with session", args: []string{"attach", "user@192.0.2.10:work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "work", wantRemote: "user@192.0.2.10"},
453	-	{name: "attach remote ipv6 with session", args: []string{"attach", "user@[2001:db8::1]:work"}, wantKind: kindAttach, wantIntent: ports.IntentAttach, wantName: "work", wantRemote: "user@[2001:db8::1]"},	453	+	{name: "attach remote ipv6 with session", args: []string{"attach", "user@[2001:db8::1]:work"}, wantKind: kindAttach, wantIntent: protocol.IntentAttach, wantName: "work", wantRemote: "user@[2001:db8::1]"},
454		{name: "attach remote invalid session", args: []string{"attach", "user@example.com:my work"}, wantErr: true, nonUsageErr: true},	454		{name: "attach remote invalid session", args: []string{"attach", "user@example.com:my work"}, wantErr: true, nonUsageErr: true},
455		{name: "attach extra arg", args: []string{"attach", "work", "extra"}, wantErr: true},	455		{name: "attach extra arg", args: []string{"attach", "work", "extra"}, wantErr: true},
456		{name: "attach without name", args: []string{"attach"}, wantErr: true},	456		{name: "attach without name", args: []string{"attach"}, wantErr: true},

@@ -566,10 +566,10 @@ func TestAttachTargetsCreateCommonSessionRequest(t *testing.T) {
566		arg string	566		arg string
567		want client.AttachRequest	567		want client.AttachRequest
568		}{	568		}{
569	-	{name: "local host", arg: "work", want: client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"}},	569	+	{name: "local host", arg: "work", want: client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"}},
570	-	{name: "remote host", arg: "user@example.com:work", want: client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"}},	570	+	{name: "remote host", arg: "user@example.com:work", want: client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"}},
571	-	{name: "remote ipv4", arg: "user@192.0.2.10:work", want: client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"}},	571	+	{name: "remote ipv4", arg: "user@192.0.2.10:work", want: client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"}},
572	-	{name: "remote ipv6", arg: "user@[2001:db8::1]:work", want: client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"}},	572	+	{name: "remote ipv6", arg: "user@[2001:db8::1]:work", want: client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"}},
573		}	573		}
574		for _, tt := range tests {	574		for _, tt := range tests {
575		t.Run(tt.name, func(t *testing.T) {	575		t.Run(tt.name, func(t *testing.T) {

@@ -587,10 +587,10 @@ func TestAttachTargetsCreateCommonSessionRequest(t *testing.T) {
587			587
588		func TestListShowsBroken(t *testing.T) {	588		func TestListShowsBroken(t *testing.T) {
589		var out bytes.Buffer	589		var out bytes.Buffer
590	-	printSessions(&out, []ports.SessionInfo{	590	+	printSessions(&out, []protocol.SessionInfo{
591	-	{Name: "fresh", State: ports.SessionDown},	591	+	{Name: "fresh", State: protocol.SessionDown},
592	-	{Name: "loading", State: ports.SessionDown},	592	+	{Name: "loading", State: protocol.SessionDown},
593	-	{Name: "broken", State: ports.SessionBroken},	593	+	{Name: "broken", State: protocol.SessionBroken},
594		})	594		})
595		require.Contains(t, out.String(), "fresh")	595		require.Contains(t, out.String(), "fresh")
596		require.Contains(t, out.String(), "down")	596		require.Contains(t, out.String(), "down")

@@ -602,9 +602,9 @@ func TestListShowsBroken(t *testing.T) {
602			602
603		func TestPrintSessionsShowsDownState(t *testing.T) {	603		func TestPrintSessionsShowsDownState(t *testing.T) {
604		var out bytes.Buffer	604		var out bytes.Buffer
605	-	printSessions(&out, []ports.SessionInfo{	605	+	printSessions(&out, []protocol.SessionInfo{
606	-	{Name: "main", State: ports.SessionUp, Tabs: 2, Attached: true},	606	+	{Name: "main", State: protocol.SessionUp, Tabs: 2, Attached: true},
607	-	{Name: "old", State: ports.SessionDown},	607	+	{Name: "old", State: protocol.SessionDown},
608		})	608		})
609		got := out.String()	609		got := out.String()
610		for _, want := range []string{"NAME", "STATE", "main", "up", "2", "yes", "old", "down", "-"} {	610		for _, want := range []string{"NAME", "STATE", "main", "up", "2", "yes", "old", "down", "-"} {

@@ -616,10 +616,10 @@ func TestPrintSessionsShowsDownState(t *testing.T) {
616			616
617		func TestPrintSessionsMarksEphemeral(t *testing.T) {	617		func TestPrintSessionsMarksEphemeral(t *testing.T) {
618		var buf bytes.Buffer	618		var buf bytes.Buffer
619	-	printSessions(&buf, []ports.SessionInfo{	619	+	printSessions(&buf, []protocol.SessionInfo{
620	-	{Name: "0", State: ports.SessionUp, Ephemeral: true, Tabs: 1, Attached: false},	620	+	{Name: "0", State: protocol.SessionUp, Ephemeral: true, Tabs: 1, Attached: false},
621	-	{Name: "work", State: ports.SessionUp, Tabs: 2, Attached: true},	621	+	{Name: "work", State: protocol.SessionUp, Tabs: 2, Attached: true},
622	-	{Name: "old", State: ports.SessionDown},	622	+	{Name: "old", State: protocol.SessionDown},
623		})	623		})
624		out := buf.String()	624		out := buf.String()
625		for _, want := range []string{"0", "temporary", "work", "up", "old", "down"} {	625		for _, want := range []string{"0", "temporary", "work", "up", "old", "down"} {

@@ -757,7 +757,7 @@ func captureStdout(t *testing.T, fn func()) string {
757			757
758		func TestRunAttachRejectsNestedVEVBeforeDial(t *testing.T) {	758		func TestRunAttachRejectsNestedVEVBeforeDial(t *testing.T) {
759		called := false	759		called := false
760	-	err := runAttachWithDeps(context.Background(), ports.IntentEphemeral, "", "", "outer", nil, runAttachDeps{	760	+	err := runAttachWithDeps(context.Background(), protocol.IntentEphemeral, "", "", "outer", nil, runAttachDeps{
761		createDetached: func(context.Context, string) error {	761		createDetached: func(context.Context, string) error {
762		called = true	762		called = true
763		return nil	763		return nil

@@ -776,7 +776,7 @@ func TestRunAttachRejectsNestedVEVBeforeDial(t *testing.T) {
776			776
777		func TestRunAttachNestedNewCreatesDetachedSession(t *testing.T) {	777		func TestRunAttachNestedNewCreatesDetachedSession(t *testing.T) {
778		var gotName string	778		var gotName string
779	-	err := runAttachWithDeps(context.Background(), ports.IntentNew, "scratch", "", "outer", nil, runAttachDeps{	779	+	err := runAttachWithDeps(context.Background(), protocol.IntentNew, "scratch", "", "outer", nil, runAttachDeps{
780		createDetached: func(_ context.Context, name string) error {	780		createDetached: func(_ context.Context, name string) error {
781		gotName = name	781		gotName = name
782		return nil	782		return nil

@@ -796,7 +796,7 @@ func TestDetachedLocalHelloIncludesTrueColor(t *testing.T) {
796			796
797		hello := detachedLocalHello("scratch", "/tmp/work")	797		hello := detachedLocalHello("scratch", "/tmp/work")
798			798
799	-	require.Equal(t, ports.IntentNew, hello.Intent)	799	+	require.Equal(t, protocol.IntentNew, hello.Intent)
800		require.Equal(t, "scratch", hello.Name)	800		require.Equal(t, "scratch", hello.Name)
801		require.Equal(t, "xterm-direct", hello.TermEnv)	801		require.Equal(t, "xterm-direct", hello.TermEnv)
802		require.Equal(t, "/tmp/work", hello.Cwd)	802		require.Equal(t, "/tmp/work", hello.Cwd)

@@ -834,7 +834,7 @@ func TestRunAttachWithDepsSelectsRemoteTransport(t *testing.T) {
834		factory := portsmocks.NewMockRemoteDialerFactory(t)	834		factory := portsmocks.NewMockRemoteDialerFactory(t)
835		factory.EXPECT().DialerForRemote("remote.example", "work", tt.wantMode, mock.Anything).Return(namedDialer{name: "remote"}, nil)	835		factory.EXPECT().DialerForRemote("remote.example", "work", tt.wantMode, mock.Anything).Return(namedDialer{name: "remote"}, nil)
836			836
837	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	837	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
838		remoteDialerFactory: factory,	838		remoteDialerFactory: factory,
839		selectedRemoteTransport: tt.selectedTransport,	839		selectedRemoteTransport: tt.selectedTransport,
840		clipboard: clip,	840		clipboard: clip,

@@ -845,11 +845,11 @@ func TestRunAttachWithDepsSelectsRemoteTransport(t *testing.T) {
845		}	845		}
846		gotDialer = nd.name	846		gotDialer = nd.name
847		gotRemote = deps.Remote	847		gotRemote = deps.Remote
848	-	if !request.Remote \|\| request.EnvironmentPolicy != ports.EnvironmentPolicyClientOwned {	848	+	if !request.Remote \|\| request.EnvironmentPolicy != protocol.EnvironmentPolicyClientOwned {
849		t.Fatal("direct CLI remote attach must preserve client-owned environment policy")	849		t.Fatal("direct CLI remote attach must preserve client-owned environment policy")
850		}	850		}
851		gotClipboard = deps.Clipboard	851		gotClipboard = deps.Clipboard
852	-	if request.Intent != ports.IntentAttach \|\| request.SessionName != "work" {	852	+	if request.Intent != protocol.IntentAttach \|\| request.SessionName != "work" {
853		t.Fatalf("intent/name = %d/%q, want attach/work", request.Intent, request.SessionName)	853		t.Fatalf("intent/name = %d/%q, want attach/work", request.Intent, request.SessionName)
854		}	854		}
855		return nil	855		return nil

@@ -876,18 +876,18 @@ func TestRunAttachWithDepsDirectLegacyCallbackPreservesClientOwnership(t *testin
876		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-1"}, nil).Once()	876		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-1"}, nil).Once()
877		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-2"}, nil).Once()	877		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-2"}, nil).Once()
878			878
879	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	879	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
880		remoteDialerFactory: factory,	880		remoteDialerFactory: factory,
881		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {	881		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {
882		require.True(t, request.Remote)	882		require.True(t, request.Remote)
883	-	require.Equal(t, ports.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)	883	+	require.Equal(t, protocol.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
884	-	nextDialer, nextRequest, err := deps.AttachHandoff(ports.AttachTarget{	884	+	nextDialer, nextRequest, err := deps.AttachHandoff(protocol.AttachTarget{
885	-	Endpoint: "selected.example", Session: "picked", Intent: ports.IntentAttach,	885	+	Endpoint: "selected.example", Session: "picked", Intent: protocol.IntentAttach,
886	-	EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	886	+	EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
887		})	887		})
888		require.NoError(t, err)	888		require.NoError(t, err)
889		require.NotNil(t, nextDialer)	889		require.NotNil(t, nextDialer)
890	-	require.Equal(t, ports.EnvironmentPolicyClientOwned, nextRequest.EnvironmentPolicy)	890	+	require.Equal(t, protocol.EnvironmentPolicyClientOwned, nextRequest.EnvironmentPolicy)
891		return nil	891		return nil
892		},	892		},
893		})	893		})

@@ -899,15 +899,15 @@ func TestRunAttachWithDepsRemotePickerHandoffReopensDirectConnection(t *testing.
899		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-1"}, nil).Once()	899		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-1"}, nil).Once()
900		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-2"}, nil).Once()	900		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-2"}, nil).Once()
901		var calls int	901		var calls int
902	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	902	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
903		remoteDialerFactory: factory,	903		remoteDialerFactory: factory,
904		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {	904		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {
905		calls++	905		calls++
906		require.NotNil(t, deps.Dialer)	906		require.NotNil(t, deps.Dialer)
907		require.True(t, request.Remote)	907		require.True(t, request.Remote)
908	-	require.Equal(t, ports.EnvironmentPolicyClientOwned, request.EnvironmentPolicy, "direct CLI remote ownership must survive a handoff")	908	+	require.Equal(t, protocol.EnvironmentPolicyClientOwned, request.EnvironmentPolicy, "direct CLI remote ownership must survive a handoff")
909		if calls == 1 {	909		if calls == 1 {
910	-	return &client.AttachTargetError{Target: ports.AttachTarget{Endpoint: "selected.example", Session: "picked", Intent: ports.IntentAttach}}	910	+	return &client.AttachTargetError{Target: protocol.AttachTarget{Endpoint: "selected.example", Session: "picked", Intent: protocol.IntentAttach}}
911		}	911		}
912		return nil	912		return nil
913		},	913		},

@@ -921,11 +921,11 @@ func TestRunAttachWithDepsAllowsRevisitingRemoteHandoff(t *testing.T) {
921		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()	921		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()
922		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-revisit"}, nil).Once()	922		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote-revisit"}, nil).Once()
923			923
924	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	924	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
925		remoteDialerFactory: factory,	925		remoteDialerFactory: factory,
926		runClient: func(_ context.Context, deps client.Dependencies, _ client.AttachRequest) error {	926		runClient: func(_ context.Context, deps client.Dependencies, _ client.AttachRequest) error {
927	-	dialer, request, err := deps.AttachHandoff(ports.AttachTarget{	927	+	dialer, request, err := deps.AttachHandoff(protocol.AttachTarget{
928	-	Endpoint: "remote.example", Session: "work", Intent: ports.IntentAttach,	928	+	Endpoint: "remote.example", Session: "work", Intent: protocol.IntentAttach,
929		})	929		})
930		require.NoError(t, err)	930		require.NoError(t, err)
931		require.NotNil(t, dialer)	931		require.NotNil(t, dialer)

@@ -941,11 +941,11 @@ func TestRunAttachWithDepsBoundsRepeatedAttachTargetHandoffs(t *testing.T) {
941		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Times(maxAttachTargetHandoffs + 1)	941		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Times(maxAttachTargetHandoffs + 1)
942			942
943		calls := 0	943		calls := 0
944	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	944	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
945		remoteDialerFactory: factory,	945		remoteDialerFactory: factory,
946		runClient: func(_ context.Context, _ client.Dependencies, _ client.AttachRequest) error {	946		runClient: func(_ context.Context, _ client.Dependencies, _ client.AttachRequest) error {
947		calls++	947		calls++
948	-	return &client.AttachTargetError{Target: ports.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: ports.IntentAttach}}	948	+	return &client.AttachTargetError{Target: protocol.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: protocol.IntentAttach}}
949		},	949		},
950		})	950		})
951		require.ErrorContains(t, err, "attach handoff exceeded maximum")	951		require.ErrorContains(t, err, "attach handoff exceeded maximum")

@@ -957,18 +957,18 @@ func TestRunAttachWithDepsLocalPickerHandoffAttachesSelectedRemote(t *testing.T)
957		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()	957		factory.EXPECT().DialerForRemote("selected.example", "picked", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()
958			958
959		localCalls, remoteCalls := 0, 0	959		localCalls, remoteCalls := 0, 0
960	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "", "", nil, runAttachDeps{	960	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "", "", nil, runAttachDeps{
961		localDialer: func() ports.Dialer { return namedDialer{name: "local"} },	961		localDialer: func() ports.Dialer { return namedDialer{name: "local"} },
962		remoteDialerFactory: factory,	962		remoteDialerFactory: factory,
963		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {	963		runClient: func(_ context.Context, deps client.Dependencies, request client.AttachRequest) error {
964		if deps.Remote {	964		if deps.Remote {
965		remoteCalls++	965		remoteCalls++
966	-	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)	966	+	require.Equal(t, client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "picked", Remote: true, Origin: protocol.RouteOriginDiscovery, OriginKey: "selected.example", HostLabel: "selected.example", EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, request)
967		return nil	967		return nil
968		}	968		}
969		localCalls++	969		localCalls++
970	-	require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local"}, request)	970	+	require.Equal(t, client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local"}, request)
971	-	return &client.AttachTargetError{Target: ports.AttachTarget{Endpoint: "selected.example", Session: "picked", Intent: ports.IntentAttach}}	971	+	return &client.AttachTargetError{Target: protocol.AttachTarget{Endpoint: "selected.example", Session: "picked", Intent: protocol.IntentAttach}}
972		},	972		},
973		})	973		})
974		require.NoError(t, err)	974		require.NoError(t, err)

@@ -979,20 +979,20 @@ func TestRunAttachWithDepsLocalPickerHandoffAttachesSelectedRemote(t *testing.T)
979		func TestRunAttachWithDepsRejectsInvalidHandoffBeforeDialing(t *testing.T) {	979		func TestRunAttachWithDepsRejectsInvalidHandoffBeforeDialing(t *testing.T) {
980		tests := []struct {	980		tests := []struct {
981		name string	981		name string
982	-	target ports.AttachTarget	982	+	target protocol.AttachTarget
983		}{	983		}{
984	-	{name: "invalid host", target: ports.AttachTarget{Endpoint: "remote host", Session: "work", Intent: ports.IntentAttach}},	984	+	{name: "invalid host", target: protocol.AttachTarget{Endpoint: "remote host", Session: "work", Intent: protocol.IntentAttach}},
985	-	{name: "invalid session", target: ports.AttachTarget{Endpoint: "remote.example", Session: "bad name", Intent: ports.IntentAttach}},	985	+	{name: "invalid session", target: protocol.AttachTarget{Endpoint: "remote.example", Session: "bad name", Intent: protocol.IntentAttach}},
986	-	{name: "tokenless resume", target: ports.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: ports.IntentResume}},	986	+	{name: "tokenless resume", target: protocol.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: protocol.IntentResume}},
987		{	987		{
988		name: "tokenless resume with remote target",	988		name: "tokenless resume with remote target",
989	-	target: ports.AttachTarget{	989	+	target: protocol.AttachTarget{
990	-	Endpoint: "remote.example", Session: "work", Intent: ports.IntentResume,	990	+	Endpoint: "remote.example", Session: "work", Intent: protocol.IntentResume,
991		RemoteTarget: &domain.RemoteSessionTarget{	991		RemoteTarget: &domain.RemoteSessionTarget{
992		Endpoint: "remote.example", DisplayOrigin: "remote.example",	992		Endpoint: "remote.example", DisplayOrigin: "remote.example",
993		LifecycleID: domain.SessionLifecycleID{1}, SessionName: "work", LiveTabID: "tab-1",	993		LifecycleID: domain.SessionLifecycleID{1}, SessionName: "work", LiveTabID: "tab-1",
994		},	994		},
995	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	995	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
996		},	996		},
997		},	997		},
998		}	998		}

@@ -1001,7 +1001,7 @@ func TestRunAttachWithDepsRejectsInvalidHandoffBeforeDialing(t *testing.T) {
1001		factory := portsmocks.NewMockRemoteDialerFactory(t)	1001		factory := portsmocks.NewMockRemoteDialerFactory(t)
1002		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()	1002		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(namedDialer{name: "remote"}, nil).Once()
1003		calls := 0	1003		calls := 0
1004	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	1004	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
1005		remoteDialerFactory: factory,	1005		remoteDialerFactory: factory,
1006		runClient: func(_ context.Context, _ client.Dependencies, _ client.AttachRequest) error {	1006		runClient: func(_ context.Context, _ client.Dependencies, _ client.AttachRequest) error {
1007		calls++	1007		calls++

@@ -1018,7 +1018,7 @@ func TestRunAttachWithDepsRejectsInvalidRemoteTransportBeforeDialing(t *testing.
1018		factory := portsmocks.NewMockRemoteDialerFactory(t)	1018		factory := portsmocks.NewMockRemoteDialerFactory(t)
1019		runClientCalled := false	1019		runClientCalled := false
1020			1020
1021	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	1021	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
1022		remoteDialerFactory: factory,	1022		remoteDialerFactory: factory,
1023		selectedRemoteTransport: "serial",	1023		selectedRemoteTransport: "serial",
1024		runClient: func(context.Context, client.Dependencies, client.AttachRequest) error {	1024		runClient: func(context.Context, client.Dependencies, client.AttachRequest) error {

@@ -1040,7 +1040,7 @@ func TestRunAttachWithDepsReturnsFactoryErrorBeforeRunClient(t *testing.T) {
1040		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(nil, factoryErr)	1040		factory.EXPECT().DialerForRemote("remote.example", "work", ports.RemoteTransportUDP, mock.Anything).Return(nil, factoryErr)
1041		runClientCalled := false	1041		runClientCalled := false
1042			1042
1043	-	err := runAttachWithDeps(context.Background(), ports.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{	1043	+	err := runAttachWithDeps(context.Background(), protocol.IntentAttach, "work", "remote.example", "", nil, runAttachDeps{
1044		remoteDialerFactory: factory,	1044		remoteDialerFactory: factory,
1045		runClient: func(context.Context, client.Dependencies, client.AttachRequest) error {	1045		runClient: func(context.Context, client.Dependencies, client.AttachRequest) error {
1046		runClientCalled = true	1046		runClientCalled = true

@@ -1060,7 +1060,7 @@ func TestRunAttachWithDepsBuildsLocalDialer(t *testing.T) {
1060		gotRemote := true	1060		gotRemote := true
1061		gotClipboard := ports.ClipboardReader(&fakeClipboardReader{})	1061		gotClipboard := ports.ClipboardReader(&fakeClipboardReader{})
1062		factory := portsmocks.NewMockRemoteDialerFactory(t)	1062		factory := portsmocks.NewMockRemoteDialerFactory(t)
1063	-	err := runAttachWithDeps(context.Background(), ports.IntentEphemeral, "", "", "", nil, runAttachDeps{	1063	+	err := runAttachWithDeps(context.Background(), protocol.IntentEphemeral, "", "", "", nil, runAttachDeps{
1064		localDialer: func() ports.Dialer { return namedDialer{name: "local"} },	1064		localDialer: func() ports.Dialer { return namedDialer{name: "local"} },
1065		remoteDialerFactory: factory,	1065		remoteDialerFactory: factory,
1066		clipboard: &fakeClipboardReader{}, // must NOT reach runClient for a local attach	1066		clipboard: &fakeClipboardReader{}, // must NOT reach runClient for a local attach

@@ -1075,7 +1075,7 @@ func TestRunAttachWithDepsBuildsLocalDialer(t *testing.T) {
1075		t.Fatal("local carriage metadata must not be in the attach request")	1075		t.Fatal("local carriage metadata must not be in the attach request")
1076		}	1076		}
1077		gotClipboard = deps.Clipboard	1077		gotClipboard = deps.Clipboard
1078	-	if request.Intent != ports.IntentEphemeral \|\| request.SessionName != "" {	1078	+	if request.Intent != protocol.IntentEphemeral \|\| request.SessionName != "" {
1079		t.Fatalf("intent/name = %d/%q, want ephemeral/empty", request.Intent, request.SessionName)	1079		t.Fatalf("intent/name = %d/%q, want ephemeral/empty", request.Intent, request.SessionName)
1080		}	1080		}
1081		return nil	1081		return nil

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

 	"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/mock"
 )
 	t.Setenv("XDG_RUNTIME_DIR", t.TempDir())
 	t.Setenv(envRemoteTransport, "invalid")
-	err := runAttach(context.Background(), ports.IntentEphemeral, "", "host")
+	err := runAttach(context.Background(), protocol.IntentEphemeral, "", "host")
 	if !strings.Contains(err.Error(), "invalid remote transport") {
 		t.Fatalf("runAttach() error = %v, want remote transport validation error", err)
 	}
 	}
 	t.Cleanup(func() { runClientWithDeps = originalRunClient })
-	if err := runAttach(context.Background(), ports.IntentAttach, "work", "remote.example"); err != nil {
+	if err := runAttach(context.Background(), protocol.IntentAttach, "work", "remote.example"); err != nil {
 		t.Fatal(err)
 	}
 	if traceCalls != 1 || factoryCalls != 1 {

M internal/persist/catalogue_test.go +2 -2


@@ -9,7 +9,7 @@ import (
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10			10
11		"github.com/bnema/vev/internal/domain"	11		"github.com/bnema/vev/internal/domain"
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol"
13		"github.com/bnema/vev/pkg/kv"	13		"github.com/bnema/vev/pkg/kv"
14		"github.com/bnema/vev/pkg/safedir"	14		"github.com/bnema/vev/pkg/safedir"
15		)	15		)

@@ -57,7 +57,7 @@ func TestOpenOrCreateReportsRecordsFromOlderProtocol(t *testing.T) {
57		TabNames: []string{"shell", "logs"},	57		TabNames: []string{"shell", "logs"},
58		Committed: &domain.CheckpointRef{Generation: 3, ManifestDigest: [32]byte{3}},	58		Committed: &domain.CheckpointRef{Generation: 3, ManifestDigest: [32]byte{3}},
59		}	59		}
60	-	olderProtocol, err := encodeRecordValueForProtocol(record, ports.ProtocolVersion-1)	60	+	olderProtocol, err := encodeRecordValueForProtocol(record, protocol.Version-1)
61		require.NoError(t, err)	61		require.NoError(t, err)
62		protocolLess, err := encodeRecordValue(record)	62		protocolLess, err := encodeRecordValue(record)
63		require.NoError(t, err)	63		require.NoError(t, err)

M internal/persist/persist.go +2 -1

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/pkg/kv"
 )
 			decodeErr = err
 			return false
 		}
-		if stored.protocolVersion != ports.ProtocolVersion {
+		if stored.protocolVersion != protocol.Version {
 			records = append(records, stored.record)
 		}
 		return true

M internal/persist/record.go +2 -2


@@ -7,7 +7,7 @@ import (
7		"math"	7		"math"
8			8
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		)	11		)
12			12
13		const (	13		const (

@@ -24,7 +24,7 @@ var catalogueMagic = [4]byte{'V', 'E', 'V', 'C'}
24		type Record = domain.CatalogueRecord	24		type Record = domain.CatalogueRecord
25			25
26		func encodeRecordValue(record domain.CatalogueRecord) ([]byte, error) {	26		func encodeRecordValue(record domain.CatalogueRecord) ([]byte, error) {
27	-	return encodeRecordValueForProtocol(record, ports.ProtocolVersion)	27	+	return encodeRecordValueForProtocol(record, protocol.Version)
28		}	28		}
29			29
30		func encodeRecordValueForProtocol(record domain.CatalogueRecord, protocolVersion uint16) ([]byte, error) {	30		func encodeRecordValueForProtocol(record domain.CatalogueRecord, protocolVersion uint16) ([]byte, error) {

M internal/ports/frame_test.go +4 -2

 import (
 	"testing"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestProtocolVersion(t *testing.T) {
-	if ProtocolVersion != 37 {
+	if protocol.Version != 37 {
-		t.Fatalf("ProtocolVersion = %d, want 37", ProtocolVersion)
+		t.Fatalf("ProtocolVersion = %d, want 37", protocol.Version)
 	}
 }

M internal/ports/navigation_test.go +14 -14


@@ -133,36 +133,36 @@ func TestParkedRouteWireRoundTripsStrictly(t *testing.T) {
133		}	133		}
134			134
135		func TestHelloNavigationValidationTable(t *testing.T) {	135		func TestHelloNavigationValidationTable(t *testing.T) {
136	-	base := Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}	136	+	base := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}
137		remoteTarget := &domain.RemoteSessionTarget{	137		remoteTarget := &domain.RemoteSessionTarget{
138		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: domain.SessionLifecycleID{1},	138		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: domain.SessionLifecycleID{1},
139		SessionName: "work", LiveTabID: "tab-1",	139		SessionName: "work", LiveTabID: "tab-1",
140		}	140		}
141		tests := []struct {	141		tests := []struct {
142		name string	142		name string
143	-	hello Hello	143	+	hello protocol.Hello
144		valid bool	144		valid bool
145		capability protocol.NavigationCapabilities	145		capability protocol.NavigationCapabilities
146		overlay protocol.StartupOverlay	146		overlay protocol.StartupOverlay
147		wantPayload string	147		wantPayload string
148		}{	148		}{
149		{name: "ordinary", hello: base, valid: true},	149		{name: "ordinary", hello: base, valid: true},
150	-	{name: "resume route", hello: Hello{Version: ProtocolVersion, Intent: IntentResume, Size: domain.Size{Cols: 80, Rows: 24}}, valid: true},	150	+	{name: "resume route", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentResume, Size: domain.Size{Cols: 80, Rows: 24}}, valid: true},
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: "daemon-owned home picker", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityHomePicker, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, valid: true, capability: protocol.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: "remote-target home picker", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: protocol.NavigationCapabilityHomePicker, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, valid: true, capability: protocol.NavigationCapabilityHomePicker},
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: "client-owned home picker rejected", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}, 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: "daemon-owned back picker rejected", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker, EnvironmentPolicy: protocol.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: "remote-target back picker rejected", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: remoteTarget, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, valid: false},
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: "back with startup picker", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.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"},
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: "new rejects navigation", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack, StartupOverlay: protocol.StartupOverlaySessionPicker}, 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: "unknown capability", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: 4}, 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: "back without picker", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, NavigationCapabilities: protocol.NavigationCapabilityBack}, 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	+	{name: "picker without back", hello: protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: false},
161		}	161		}
162			162
163		for _, tt := range tests {	163		for _, tt := range tests {
164		t.Run(tt.name, func(t *testing.T) {	164		t.Run(tt.name, func(t *testing.T) {
165	-	err := ValidateHello(tt.hello)	165	+	err := protocol.ValidateHello(tt.hello)
166		if tt.valid {	166		if tt.valid {
167		require.NoError(t, err)	167		require.NoError(t, err)
168		payload := MarshalHello(tt.hello)	168		payload := MarshalHello(tt.hello)

M internal/ports/remote.go +3 -3


@@ -193,8 +193,8 @@ var (
193		// ValidateRemoteCatalog applies the exact current schema and all bounds before	193		// ValidateRemoteCatalog applies the exact current schema and all bounds before
194		// a catalogue is cached or rendered.	194		// a catalogue is cached or rendered.
195		func ValidateRemoteCatalog(c RemoteCatalog) error {	195		func ValidateRemoteCatalog(c RemoteCatalog) error {
196	-	if c.ProtocolVersion != ProtocolVersion {	196	+	if c.ProtocolVersion != protocol.Version {
197	-	return &RemoteCatalogVersionMismatchError{Got: c.ProtocolVersion, Want: ProtocolVersion, Kind: "protocol"}	197	+	return &RemoteCatalogVersionMismatchError{Got: c.ProtocolVersion, Want: protocol.Version, Kind: "protocol"}
198		}	198		}
199		if c.SchemaVersion != RemoteCatalogSchemaVersion {	199		if c.SchemaVersion != RemoteCatalogSchemaVersion {
200		return &RemoteCatalogVersionMismatchError{Got: c.SchemaVersion, Want: RemoteCatalogSchemaVersion, Kind: "catalog"}	200		return &RemoteCatalogVersionMismatchError{Got: c.SchemaVersion, Want: RemoteCatalogSchemaVersion, Kind: "catalog"}

@@ -309,7 +309,7 @@ func ValidateRemoteCatalogCacheEntries(entries []RemoteCatalogCacheEntry) error
309		return fmt.Errorf("%w: duplicate host", ErrInvalidRemoteCatalog)	309		return fmt.Errorf("%w: duplicate host", ErrInvalidRemoteCatalog)
310		}	310		}
311		seenHosts[entry.Host] = struct{}{}	311		seenHosts[entry.Host] = struct{}{}
312	-	catalog := RemoteCatalog{ProtocolVersion: ProtocolVersion, SchemaVersion: RemoteCatalogSchemaVersion, Sessions: entry.Sessions}	312	+	catalog := RemoteCatalog{ProtocolVersion: protocol.Version, SchemaVersion: RemoteCatalogSchemaVersion, Sessions: entry.Sessions}
313		if err := ValidateRemoteCatalog(catalog); err != nil {	313		if err := ValidateRemoteCatalog(catalog); err != nil {
314		return fmt.Errorf("%w: host %q: %v", ErrInvalidRemoteCatalog, entry.Host, err)	314		return fmt.Errorf("%w: host %q: %v", ErrInvalidRemoteCatalog, entry.Host, err)
315		}	315		}

M internal/ports/remote_preview_hardening_test.go +6 -6


@@ -178,7 +178,7 @@ func TestRemoteTargetWireRejectsInvalidSelectorCombinations(t *testing.T) {
178		t.Run(test.name, func(t *testing.T) {	178		t.Run(test.name, func(t *testing.T) {
179		target := *testRemoteTarget(false)	179		target := *testRemoteTarget(false)
180		test.mutate(&target)	180		test.mutate(&target)
181	-	message := AttachTarget{Endpoint: target.Endpoint, Session: target.SessionName, Intent: IntentAttach, RemoteTarget: &target, EnvironmentPolicy: EnvironmentPolicyDaemonOwned}	181	+	message := protocol.AttachTarget{Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach, RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}
182		if MarshalAttachTarget(message) != nil {	182		if MarshalAttachTarget(message) != nil {
183		t.Fatal("invalid target was marshaled")	183		t.Fatal("invalid target was marshaled")
184		}	184		}

@@ -188,13 +188,13 @@ func TestRemoteTargetWireRejectsInvalidSelectorCombinations(t *testing.T) {
188			188
189		func TestRemoteTargetWireRichGoldenRoundTrip(t *testing.T) {	189		func TestRemoteTargetWireRichGoldenRoundTrip(t *testing.T) {
190		target := testRemoteTarget(false)	190		target := testRemoteTarget(false)
191	-	got := MarshalAttachTarget(AttachTarget{	191	+	got := MarshalAttachTarget(protocol.AttachTarget{
192	-	Endpoint: target.Endpoint, Session: target.SessionName, Intent: IntentAttach,	192	+	Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
193	-	RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyDaemonOwned,	193	+	RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
194		})	194		})
195		want := []byte{	195		want := []byte{
196		0x00, 0x0f, 'b', 'u', 'i', 'l', 'd', '@', 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',	196		0x00, 0x0f, 'b', 'u', 'i', 'l', 'd', '@', 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',
197	-	0x00, 0x04, 'w', 'o', 'r', 'k', IntentAttach,	197	+	0x00, 0x04, 'w', 'o', 'r', 'k', protocol.IntentAttach,
198		0x01,	198		0x01,
199		0x00, 0x0f, 'b', 'u', 'i', 'l', 'd', '@', 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',	199		0x00, 0x0f, 'b', 'u', 'i', 'l', 'd', '@', 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',
200		0x00, 0x09, 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',	200		0x00, 0x09, 'm', 'u', 'l', 'e', ':', '2', '2', '2', '2',

@@ -210,7 +210,7 @@ func TestRemoteTargetWireRichGoldenRoundTrip(t *testing.T) {
210		if err != nil {	210		if err != nil {
211		t.Fatalf("UnmarshalAttachTarget() error = %v", err)	211		t.Fatalf("UnmarshalAttachTarget() error = %v", err)
212		}	212		}
213	-	if decoded.RemoteTarget == nil \|\| decoded.RemoteTarget != target \|\| decoded.EnvironmentPolicy != EnvironmentPolicyDaemonOwned {	213	+	if decoded.RemoteTarget == nil \|\| decoded.RemoteTarget != target \|\| decoded.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
214		t.Fatalf("decoded target = %#v, policy = %d", decoded.RemoteTarget, decoded.EnvironmentPolicy)	214		t.Fatalf("decoded target = %#v, policy = %d", decoded.RemoteTarget, decoded.EnvironmentPolicy)
215		}	215		}
216		}	216		}

M internal/ports/remote_state_test.go +5 -4

 import (
 	"testing"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 	for _, state := range []RemoteCatalogSessionState{RemoteCatalogSessionUp, RemoteCatalogSessionDown, RemoteCatalogSessionBroken} {
 		t.Run(string(state), func(t *testing.T) {
 			err := ValidateRemoteCatalog(RemoteCatalog{
-				ProtocolVersion: ProtocolVersion,
+				ProtocolVersion: protocol.Version,
 				SchemaVersion:   RemoteCatalogSchemaVersion,
 				Sessions: []RemoteCatalogSession{{
 					LifecycleID: [16]byte{1}, Name: "work", State: state,
 	}
 	err := ValidateRemoteCatalog(RemoteCatalog{
-		ProtocolVersion: ProtocolVersion,
+		ProtocolVersion: protocol.Version,
 		SchemaVersion:   RemoteCatalogSchemaVersion,
 		Sessions: []RemoteCatalogSession{{
 			LifecycleID: [16]byte{1}, Name: "work", State: RemoteCatalogSessionState("running"),
 	})
 	require.ErrorIs(t, err, ErrRemoteCatalogUnknownState)
-	err = ValidateRemoteCatalog(RemoteCatalog{ProtocolVersion: ProtocolVersion, Sessions: []RemoteCatalogSession{}})
+	err = ValidateRemoteCatalog(RemoteCatalog{ProtocolVersion: protocol.Version, Sessions: []RemoteCatalogSession{}})
 	var mismatch *RemoteCatalogVersionMismatchError
 	require.ErrorAs(t, err, &mismatch)
 	require.Equal(t, "catalog", mismatch.Kind)
 func TestValidateRemoteCatalogRejectsDuplicateSessionNames(t *testing.T) {
 	err := ValidateRemoteCatalog(RemoteCatalog{
-		ProtocolVersion: ProtocolVersion,
+		ProtocolVersion: protocol.Version,
 		SchemaVersion:   RemoteCatalogSchemaVersion,
 		Sessions: []RemoteCatalogSession{
 			{LifecycleID: [16]byte{1}, Name: "work", State: RemoteCatalogSessionUp, Tabs: []RemoteCatalogTab{}},

M internal/ports/remote_target_wire_test.go +38 -37

 	"testing"
 	"github.com/bnema/vev/internal/domain"
+	"github.com/bnema/vev/internal/protocol"
 )
 func testRemoteTarget(stopped bool) *domain.RemoteSessionTarget {
 		}
 		t.Run(name, func(t *testing.T) {
 			target := testRemoteTarget(stopped)
-			msg := Hello{
+			msg := protocol.Hello{
-				Version:           ProtocolVersion,
+				Version:           protocol.Version,
-				Intent:            IntentAttach,
+				Intent:            protocol.IntentAttach,
 				Name:              target.SessionName,
 				Size:              domain.Size{Cols: 80, Rows: 24},
 				RemoteTarget:      target,
-				EnvironmentPolicy: EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			}
 			payload := MarshalHello(msg)
 			if payload == nil {
 			if got.RemoteTarget == nil || *got.RemoteTarget != *target {
 				t.Fatalf("remote target = %#v, want %#v", got.RemoteTarget, target)
 			}
-			if got.EnvironmentPolicy != EnvironmentPolicyDaemonOwned {
+			if got.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
 				t.Fatalf("environment policy = %d, want daemon-owned", got.EnvironmentPolicy)
 			}
-			attachPayload := MarshalAttachTarget(AttachTarget{
+			attachPayload := MarshalAttachTarget(protocol.AttachTarget{
 				Endpoint:          target.Endpoint,
 				Session:           target.SessionName,
-				Intent:            IntentAttach,
+				Intent:            protocol.IntentAttach,
 				RemoteTarget:      target,
-				EnvironmentPolicy: EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			})
 			if attachPayload == nil {
 				t.Fatal("MarshalAttachTarget returned nil")
 		{
 			name: "hello",
 			validate: func() error {
-				return ValidateHello(Hello{
+				return protocol.ValidateHello(protocol.Hello{
-					Version: ProtocolVersion, Intent: IntentAttach,
+					Version: protocol.Version, Intent: protocol.IntentAttach,
 					Name: target.SessionName, Size: domain.Size{Cols: 80, Rows: 24},
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyClientOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
 				})
 			},
 			marshalBad: func() []byte {
-				return MarshalHello(Hello{
+				return MarshalHello(protocol.Hello{
-					Version: ProtocolVersion, Intent: IntentAttach,
+					Version: protocol.Version, Intent: protocol.IntentAttach,
 					Name: target.SessionName, Size: domain.Size{Cols: 80, Rows: 24},
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyClientOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
 				})
 			},
 			marshalGood: func() []byte {
-				return MarshalHello(Hello{
+				return MarshalHello(protocol.Hello{
-					Version: ProtocolVersion, Intent: IntentAttach,
+					Version: protocol.Version, Intent: protocol.IntentAttach,
 					Name: target.SessionName, Size: domain.Size{Cols: 80, Rows: 24},
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyDaemonOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 				})
 			},
 			unmarshal:    func(payload []byte) error { _, err := UnmarshalHello(payload); return err },
 			policyOffset: 10,
-			wantErr:      ErrInvalidHello,
+			wantErr:      protocol.ErrInvalidHello,
 		},
 		{
 			name: "attach target",
 			validate: func() error {
-				return ValidateAttachTarget(AttachTarget{
+				return protocol.ValidateAttachTarget(protocol.AttachTarget{
-					Endpoint: target.Endpoint, Session: target.SessionName, Intent: IntentAttach,
+					Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyClientOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
 				})
 			},
 			marshalBad: func() []byte {
-				return MarshalAttachTarget(AttachTarget{
+				return MarshalAttachTarget(protocol.AttachTarget{
-					Endpoint: target.Endpoint, Session: target.SessionName, Intent: IntentAttach,
+					Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyClientOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
 				})
 			},
 			marshalGood: func() []byte {
-				return MarshalAttachTarget(AttachTarget{
+				return MarshalAttachTarget(protocol.AttachTarget{
-					Endpoint: target.Endpoint, Session: target.SessionName, Intent: IntentAttach,
+					Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
-					RemoteTarget: target, EnvironmentPolicy: EnvironmentPolicyDaemonOwned,
+					RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 				})
 			},
 			unmarshal:    func(payload []byte) error { _, err := UnmarshalAttachTarget(payload); return err },
 			policyOffset: 3,
-			wantErr:      ErrInvalidAttachTarget,
+			wantErr:      protocol.ErrInvalidAttachTarget,
 		},
 	}
 			if err := tt.unmarshal(trailing); err == nil {
 				t.Fatal("trailing garbage unexpectedly decoded")
 			}
-			payload[len(payload)-tt.policyOffset] = byte(EnvironmentPolicyClientOwned)
+			payload[len(payload)-tt.policyOffset] = byte(protocol.EnvironmentPolicyClientOwned)
 			if err := tt.unmarshal(payload); !errors.Is(err, tt.wantErr) {
 				t.Fatalf("mutated policy error = %v, want %v", err, tt.wantErr)
 			}
 }
 func TestAttachTargetRejectsResumeIntent(t *testing.T) {
-	tests := []AttachTarget{
+	tests := []protocol.AttachTarget{
-		{Endpoint: "host", Session: "work", Intent: IntentResume},
+		{Endpoint: "host", Session: "work", Intent: protocol.IntentResume},
 		{
 			Endpoint:          "build@mule:2222",
 			Session:           "work",
-			Intent:            IntentResume,
+			Intent:            protocol.IntentResume,
 			RemoteTarget:      testRemoteTarget(false),
-			EnvironmentPolicy: EnvironmentPolicyDaemonOwned,
+			EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		},
 	}
 	for _, target := range tests {
-		if err := ValidateAttachTarget(target); !errors.Is(err, ErrInvalidAttachTarget) {
+		if err := protocol.ValidateAttachTarget(target); !errors.Is(err, protocol.ErrInvalidAttachTarget) {
-			t.Fatalf("ValidateAttachTarget(%#v) error = %v, want %v", target, err, ErrInvalidAttachTarget)
+			t.Fatalf("ValidateAttachTarget(%#v) error = %v, want %v", target, err, protocol.ErrInvalidAttachTarget)
 		}
 		if got := MarshalAttachTarget(target); got != nil {
 			t.Fatalf("MarshalAttachTarget(%#v) = %x, want nil", target, got)
 }
 func TestTargetWireIncludesRequiredV27Section(t *testing.T) {
-	want := []byte{0, 4, 'h', 'o', 's', 't', 0, 4, 'w', 'o', 'r', 'k', IntentAttach, 0, 0, 0, 0}
+	want := []byte{0, 4, 'h', 'o', 's', 't', 0, 4, 'w', 'o', 'r', 'k', protocol.IntentAttach, 0, 0, 0, 0}
-	got := MarshalAttachTarget(AttachTarget{Endpoint: "host", Session: "work", Intent: IntentAttach})
+	got := MarshalAttachTarget(protocol.AttachTarget{Endpoint: "host", Session: "work", Intent: protocol.IntentAttach})
 	if !bytes.Equal(got, want) {
 		t.Fatalf("target bytes = %x, want %x", got, want)
 	}

M internal/ports/routes_test.go +8 -8


@@ -33,9 +33,9 @@ func TestExactSessionTargetCodecIsStrict(t *testing.T) {
33			33
34		func TestHelloExactTargetRoundTrip(t *testing.T) {	34		func TestHelloExactTargetRoundTrip(t *testing.T) {
35		target := testExactTarget()	35		target := testExactTarget()
36	-	msg := Hello{	36	+	msg := protocol.Hello{
37	-	Version: ProtocolVersion,	37	+	Version: protocol.Version,
38	-	Intent: IntentAttach,	38	+	Intent: protocol.IntentAttach,
39		Name: target.SessionName,	39		Name: target.SessionName,
40		Size: domain.Size{Cols: 80, Rows: 24},	40		Size: domain.Size{Cols: 80, Rows: 24},
41		ExactTarget: &target,	41		ExactTarget: &target,

@@ -49,12 +49,12 @@ func TestHelloExactTargetRoundTrip(t *testing.T) {
49		require.Equal(t, msg, got)	49		require.Equal(t, msg, got)
50			50
51		invalid := msg	51		invalid := msg
52	-	invalid.Intent = IntentNew	52	+	invalid.Intent = protocol.IntentNew
53	-	require.Error(t, ValidateHello(invalid))	53	+	require.Error(t, protocol.ValidateHello(invalid))
54			54
55		invalid = msg	55		invalid = msg
56		invalid.PreferredTabID = "bad tab"	56		invalid.PreferredTabID = "bad tab"
57	-	require.Error(t, ValidateHello(invalid))	57	+	require.Error(t, protocol.ValidateHello(invalid))
58		}	58		}
59			59
60		func TestRoutePositionCodecIsStrict(t *testing.T) {	60		func TestRoutePositionCodecIsStrict(t *testing.T) {

@@ -78,7 +78,7 @@ func TestRoutePositionCodecIsStrict(t *testing.T) {
78			78
79		func TestWelcomeCarriesCommittedRouteIdentity(t *testing.T) {	79		func TestWelcomeCarriesCommittedRouteIdentity(t *testing.T) {
80		identity := &protocol.CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}	80		identity := &protocol.CommittedRouteIdentity{Target: testExactTarget(), Ephemeral: true}
81	-	want := Welcome{SessionID: "daemon-session", SessionName: "work", Ephemeral: true, CommittedIdentity: identity}	81	+	want := protocol.Welcome{SessionID: "daemon-session", SessionName: "work", Ephemeral: true, CommittedIdentity: identity}
82			82
83		got, err := UnmarshalWelcome(MarshalWelcome(want))	83		got, err := UnmarshalWelcome(MarshalWelcome(want))
84		require.NoError(t, err)	84		require.NoError(t, err)

@@ -87,7 +87,7 @@ func TestWelcomeCarriesCommittedRouteIdentity(t *testing.T) {
87			87
88		func TestWelcomeRejectsMismatchedCommittedIdentity(t *testing.T) {	88		func TestWelcomeRejectsMismatchedCommittedIdentity(t *testing.T) {
89		identity := &protocol.CommittedRouteIdentity{Target: testExactTarget()}	89		identity := &protocol.CommittedRouteIdentity{Target: testExactTarget()}
90	-	payload := MarshalWelcome(Welcome{SessionID: "daemon-session", SessionName: "other", CommittedIdentity: identity})	90	+	payload := MarshalWelcome(protocol.Welcome{SessionID: "daemon-session", SessionName: "other", CommittedIdentity: identity})
91			91
92		require.Nil(t, payload)	92		require.Nil(t, payload)
93		}	93		}

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

@@ -1,323 +0,0 @@
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 +138 -138


@@ -114,7 +114,7 @@ func (w *payloadWriter) putLongBytes(b []byte) {
114		// A target may be absent for direct local attaches, but its presence marker and	114		// A target may be absent for direct local attaches, but its presence marker and
115		// environment policy are never optional: v27 has no extension or legacy tail	115		// environment policy are never optional: v27 has no extension or legacy tail
116		// inside this section; the exact-target section follows it.	116		// inside this section; the exact-target section follows it.
117	-	func marshalRemoteTargetSection(w payloadWriter, target domain.RemoteSessionTarget, policy EnvironmentPolicy) {	117	+	func marshalRemoteTargetSection(w payloadWriter, target domain.RemoteSessionTarget, policy protocol.EnvironmentPolicy) {
118		if target == nil {	118		if target == nil {
119		w.putBool(false)	119		w.putBool(false)
120		} else {	120		} else {

@@ -190,7 +190,7 @@ func skipRemoteTargetSection(r *payloadReader) error {
190		if err != nil {	190		if err != nil {
191		return err	191		return err
192		}	192		}
193	-	if ValidateEnvironmentPolicy(EnvironmentPolicy(policy)) != nil {	193	+	if protocol.ValidateEnvironmentPolicy(protocol.EnvironmentPolicy(policy)) != nil {
194		return errInvalidEnum	194		return errInvalidEnum
195		}	195		}
196		return nil	196		return nil

@@ -256,7 +256,7 @@ func unmarshalRemoteTarget(r payloadReader) (domain.RemoteSessionTarget, error
256		return target, nil	256		return target, nil
257		}	257		}
258			258
259	-	func unmarshalRemoteTargetSection(r payloadReader) (domain.RemoteSessionTarget, EnvironmentPolicy, error) {	259	+	func unmarshalRemoteTargetSection(r payloadReader) (domain.RemoteSessionTarget, protocol.EnvironmentPolicy, error) {
260		target, err := unmarshalRemoteTarget(r)	260		target, err := unmarshalRemoteTarget(r)
261		if err != nil {	261		if err != nil {
262		return nil, 0, err	262		return nil, 0, err

@@ -265,10 +265,10 @@ func unmarshalRemoteTargetSection(r payloadReader) (domain.RemoteSessionTarget
265		if err != nil {	265		if err != nil {
266		return nil, 0, err	266		return nil, 0, err
267		}	267		}
268	-	if ValidateEnvironmentPolicy(EnvironmentPolicy(policy)) != nil {	268	+	if protocol.ValidateEnvironmentPolicy(protocol.EnvironmentPolicy(policy)) != nil {
269		return nil, 0, errInvalidEnum	269		return nil, 0, errInvalidEnum
270		}	270		}
271	-	return target, EnvironmentPolicy(policy), nil	271	+	return target, protocol.EnvironmentPolicy(policy), nil
272		}	272		}
273			273
274		// payloadReader consumes a message payload field by field in wire order,	274		// payloadReader consumes a message payload field by field in wire order,

@@ -439,8 +439,8 @@ func validateWireRemoteTarget(target domain.RemoteSessionTarget) error {
439		}	439		}
440			440
441		// MarshalHello encodes h into a Hello message payload.	441		// MarshalHello encodes h into a Hello message payload.
442	-	func MarshalHello(h Hello) []byte {	442	+	func MarshalHello(h protocol.Hello) []byte {
443	-	if err := ValidateHello(h); err != nil {	443	+	if err := protocol.ValidateHello(h); err != nil {
444		return nil	444		return nil
445		}	445		}
446		w := payloadWriter{}	446		w := payloadWriter{}

@@ -478,7 +478,7 @@ func preflightHello(b []byte) error {
478		return err	478		return err
479		}	479		}
480		if version == 21 {	480		if version == 21 {
481	-	return ErrInvalidHello	481	+	return protocol.ErrInvalidHello
482		}	482		}
483		if _, err := r.getUint8(); err != nil {	483		if _, err := r.getUint8(); err != nil {
484		return err	484		return err

@@ -554,122 +554,122 @@ func preflightHello(b []byte) error {
554		}	554		}
555			555
556		// UnmarshalHello decodes a Hello message payload.	556		// UnmarshalHello decodes a Hello message payload.
557	-	func UnmarshalHello(b []byte) (Hello, error) {	557	+	func UnmarshalHello(b []byte) (protocol.Hello, error) {
558		if len(b) > MaxFrameLen-1 {	558		if len(b) > MaxFrameLen-1 {
559	-	return Hello{}, ErrInvalidHello	559	+	return protocol.Hello{}, protocol.ErrInvalidHello
560		}	560		}
561		if err := preflightHello(b); err != nil {	561		if err := preflightHello(b); err != nil {
562	-	return Hello{}, err	562	+	return protocol.Hello{}, err
563		}	563		}
564		r := payloadReader{b: b}	564		r := payloadReader{b: b}
565	-	var h Hello	565	+	var h protocol.Hello
566		var err error	566		var err error
567			567
568		if h.Version, err = r.getUint16(); err != nil {	568		if h.Version, err = r.getUint16(); err != nil {
569	-	return Hello{}, err	569	+	return protocol.Hello{}, err
570		}	570		}
571		if h.Intent, err = r.getUint8(); err != nil {	571		if h.Intent, err = r.getUint8(); err != nil {
572	-	return Hello{}, err	572	+	return protocol.Hello{}, err
573		}	573		}
574		clientID, err := r.getBytes(len(h.ClientID))	574		clientID, err := r.getBytes(len(h.ClientID))
575		if err != nil {	575		if err != nil {
576	-	return Hello{}, err	576	+	return protocol.Hello{}, err
577		}	577		}
578		copy(h.ClientID[:], clientID)	578		copy(h.ClientID[:], clientID)
579		if h.ResumeToken, err = r.getUint64(); err != nil {	579		if h.ResumeToken, err = r.getUint64(); err != nil {
580	-	return Hello{}, err	580	+	return protocol.Hello{}, err
581		}	581		}
582		if h.Name, err = r.getString(); err != nil {	582		if h.Name, err = r.getString(); err != nil {
583	-	return Hello{}, err	583	+	return protocol.Hello{}, err
584		}	584		}
585		cols, err := r.getUint16()	585		cols, err := r.getUint16()
586		if err != nil {	586		if err != nil {
587	-	return Hello{}, err	587	+	return protocol.Hello{}, err
588		}	588		}
589		rows, err := r.getUint16()	589		rows, err := r.getUint16()
590		if err != nil {	590		if err != nil {
591	-	return Hello{}, err	591	+	return protocol.Hello{}, err
592		}	592		}
593		pixelWidth, err := r.getUint16()	593		pixelWidth, err := r.getUint16()
594		if err != nil {	594		if err != nil {
595	-	return Hello{}, err	595	+	return protocol.Hello{}, err
596		}	596		}
597		pixelHeight, err := r.getUint16()	597		pixelHeight, err := r.getUint16()
598		if err != nil {	598		if err != nil {
599	-	return Hello{}, err	599	+	return protocol.Hello{}, err
600		}	600		}
601		h.Size = domain.Size{Cols: int(cols), Rows: int(rows)}	601		h.Size = domain.Size{Cols: int(cols), Rows: int(rows)}
602		h.PixelWidth = int(pixelWidth)	602		h.PixelWidth = int(pixelWidth)
603		h.PixelHeight = int(pixelHeight)	603		h.PixelHeight = int(pixelHeight)
604		if h.TermEnv, err = r.getString(); err != nil {	604		if h.TermEnv, err = r.getString(); err != nil {
605	-	return Hello{}, err	605	+	return protocol.Hello{}, err
606		}	606		}
607		if h.Cwd, err = r.getString(); err != nil {	607		if h.Cwd, err = r.getString(); err != nil {
608	-	return Hello{}, err	608	+	return protocol.Hello{}, err
609		}	609		}
610		if h.TrueColor, err = r.getBool(); err != nil {	610		if h.TrueColor, err = r.getBool(); err != nil {
611	-	return Hello{}, err	611	+	return protocol.Hello{}, err
612		}	612		}
613		if h.MaxOutputInFlight, err = r.getUint8(); err != nil {	613		if h.MaxOutputInFlight, err = r.getUint8(); err != nil {
614	-	return Hello{}, err	614	+	return protocol.Hello{}, err
615		}	615		}
616		envCount, err := r.getUint32()	616		envCount, err := r.getUint32()
617		if err != nil {	617		if err != nil {
618	-	return Hello{}, err	618	+	return protocol.Hello{}, err
619		}	619		}
620		// Each entry has at least its uint32 byte length. Check that before	620		// Each entry has at least its uint32 byte length. Check that before
621		// allocating so a malformed count cannot force an excessive allocation.	621		// allocating so a malformed count cannot force an excessive allocation.
622		if uint64(envCount) > uint64(len(r.b)/4) {	622		if uint64(envCount) > uint64(len(r.b)/4) {
623	-	return Hello{}, errShortPayload	623	+	return protocol.Hello{}, errShortPayload
624		}	624		}
625		if envCount != 0 {	625		if envCount != 0 {
626		h.Env = make([]string, 0, int(envCount))	626		h.Env = make([]string, 0, int(envCount))
627		for range int(envCount) {	627		for range int(envCount) {
628		entry, err := r.getLongString()	628		entry, err := r.getLongString()
629		if err != nil {	629		if err != nil {
630	-	return Hello{}, err	630	+	return protocol.Hello{}, err
631		}	631		}
632		h.Env = append(h.Env, entry)	632		h.Env = append(h.Env, entry)
633		}	633		}
634		}	634		}
635		if h.RemoteTarget, h.EnvironmentPolicy, err = unmarshalRemoteTargetSection(&r); err != nil {	635		if h.RemoteTarget, h.EnvironmentPolicy, err = unmarshalRemoteTargetSection(&r); err != nil {
636	-	return Hello{}, err	636	+	return protocol.Hello{}, err
637		}	637		}
638		if h.ExactTarget, err = unmarshalExactTargetSection(&r); err != nil {	638		if h.ExactTarget, err = unmarshalExactTargetSection(&r); err != nil {
639	-	return Hello{}, err	639	+	return protocol.Hello{}, err
640		}	640		}
641		preferredTabID, err := r.getString()	641		preferredTabID, err := r.getString()
642		if err != nil {	642		if err != nil {
643	-	return Hello{}, err	643	+	return protocol.Hello{}, err
644		}	644		}
645		h.PreferredTabID = domain.TabStableID(preferredTabID)	645		h.PreferredTabID = domain.TabStableID(preferredTabID)
646		capabilities, err := r.getUint8()	646		capabilities, err := r.getUint8()
647		if err != nil {	647		if err != nil {
648	-	return Hello{}, err	648	+	return protocol.Hello{}, err
649		}	649		}
650		h.NavigationCapabilities = protocol.NavigationCapabilities(capabilities)	650		h.NavigationCapabilities = protocol.NavigationCapabilities(capabilities)
651		overlay, err := r.getUint8()	651		overlay, err := r.getUint8()
652		if err != nil {	652		if err != nil {
653	-	return Hello{}, err	653	+	return protocol.Hello{}, err
654		}	654		}
655		h.StartupOverlay = protocol.StartupOverlay(overlay)	655		h.StartupOverlay = protocol.StartupOverlay(overlay)
656		if h.Remote, err = r.getBool(); err != nil {	656		if h.Remote, err = r.getBool(); err != nil {
657	-	return Hello{}, err	657	+	return protocol.Hello{}, err
658		}	658		}
659		if h.KittyDirectGraphics, err = r.getBool(); err != nil {	659		if h.KittyDirectGraphics, err = r.getBool(); err != nil {
660	-	return Hello{}, err	660	+	return protocol.Hello{}, err
661		}	661		}
662		if err := r.done(); err != nil {	662		if err := r.done(); err != nil {
663	-	return Hello{}, err	663	+	return protocol.Hello{}, err
664		}	664		}
665	-	if err := ValidateHello(h); err != nil {	665	+	if err := protocol.ValidateHello(h); err != nil {
666	-	return Hello{}, err	666	+	return protocol.Hello{}, err
667		}	667		}
668		return h, nil	668		return h, nil
669		}	669		}
670			670
671		// MarshalInput encodes m into an Input message payload.	671		// MarshalInput encodes m into an Input message payload.
672	-	func MarshalInput(m Input) []byte {	672	+	func MarshalInput(m protocol.Input) []byte {
673		w := payloadWriter{}	673		w := payloadWriter{}
674		w.putUint64(m.InputSeq)	674		w.putUint64(m.InputSeq)
675		w.putBytes(m.Data)	675		w.putBytes(m.Data)

@@ -678,13 +678,13 @@ func MarshalInput(m Input) []byte {
678			678
679		// UnmarshalInput decodes an Input message payload. After the fixed input	679		// UnmarshalInput decodes an Input message payload. After the fixed input
680		// sequence, the rest of the payload is data; there is no length prefix.	680		// sequence, the rest of the payload is data; there is no length prefix.
681	-	func UnmarshalInput(b []byte) (Input, error) {	681	+	func UnmarshalInput(b []byte) (protocol.Input, error) {
682		r := payloadReader{b: b}	682		r := payloadReader{b: b}
683		seq, err := r.getUint64()	683		seq, err := r.getUint64()
684		if err != nil {	684		if err != nil {
685	-	return Input{}, err	685	+	return protocol.Input{}, err
686		}	686		}
687	-	return Input{InputSeq: seq, Data: r.rest()}, nil	687	+	return protocol.Input{InputSeq: seq, Data: r.rest()}, nil
688		}	688		}
689			689
690		// MarshalImagePush encodes m into an ImagePush message payload.	690		// MarshalImagePush encodes m into an ImagePush message payload.

@@ -713,25 +713,25 @@ func UnmarshalImagePush(b []byte) (protocol.ImagePush, error) {
713		}	713		}
714			714
715		// MarshalClientNotice encodes a fixed one-byte client notice action.	715		// MarshalClientNotice encodes a fixed one-byte client notice action.
716	-	func MarshalClientNotice(m ClientNotice) []byte {	716	+	func MarshalClientNotice(m protocol.ClientNotice) []byte {
717		return []byte{m.Action}	717		return []byte{m.Action}
718		}	718		}
719			719
720		// UnmarshalClientNotice decodes a fixed client notice action and rejects both	720		// UnmarshalClientNotice decodes a fixed client notice action and rejects both
721		// unknown values and any trailing bytes.	721		// unknown values and any trailing bytes.
722	-	func UnmarshalClientNotice(b []byte) (ClientNotice, error) {	722	+	func UnmarshalClientNotice(b []byte) (protocol.ClientNotice, error) {
723		r := payloadReader{b: b}	723		r := payloadReader{b: b}
724		action, err := r.getUint8()	724		action, err := r.getUint8()
725		if err != nil {	725		if err != nil {
726	-	return ClientNotice{}, err	726	+	return protocol.ClientNotice{}, err
727		}	727		}
728	-	if ValidateClientNotice(ClientNotice{Action: action}) != nil {	728	+	if protocol.ValidateClientNotice(protocol.ClientNotice{Action: action}) != nil {
729	-	return ClientNotice{}, errors.New("ports: unknown client notice action")	729	+	return protocol.ClientNotice{}, errors.New("ports: unknown client notice action")
730		}	730		}
731		if err := r.done(); err != nil {	731		if err := r.done(); err != nil {
732	-	return ClientNotice{}, err	732	+	return protocol.ClientNotice{}, err
733		}	733		}
734	-	return ClientNotice{Action: action}, nil	734	+	return protocol.ClientNotice{Action: action}, nil
735		}	735		}
736			736
737		// MarshalResize encodes m into a Resize message payload.	737		// MarshalResize encodes m into a Resize message payload.

@@ -883,45 +883,45 @@ func UnmarshalResize(b []byte) (protocol.Resize, error) {
883		}	883		}
884			884
885		// MarshalDetach encodes a Detach message payload (always empty).	885		// MarshalDetach encodes a Detach message payload (always empty).
886	-	func MarshalDetach(Detach) []byte {	886	+	func MarshalDetach(protocol.Detach) []byte {
887		return nil	887		return nil
888		}	888		}
889			889
890		// UnmarshalDetach decodes a Detach message payload.	890		// UnmarshalDetach decodes a Detach message payload.
891	-	func UnmarshalDetach(b []byte) (Detach, error) {	891	+	func UnmarshalDetach(b []byte) (protocol.Detach, error) {
892		r := payloadReader{b: b}	892		r := payloadReader{b: b}
893		if err := r.done(); err != nil {	893		if err := r.done(); err != nil {
894	-	return Detach{}, err	894	+	return protocol.Detach{}, err
895		}	895		}
896	-	return Detach{}, nil	896	+	return protocol.Detach{}, nil
897		}	897		}
898			898
899		// MarshalPing encodes a Ping message payload (always empty).	899		// MarshalPing encodes a Ping message payload (always empty).
900	-	func MarshalPing(Ping) []byte {	900	+	func MarshalPing(protocol.Ping) []byte {
901		return nil	901		return nil
902		}	902		}
903			903
904		// UnmarshalPing decodes a Ping message payload.	904		// UnmarshalPing decodes a Ping message payload.
905	-	func UnmarshalPing(b []byte) (Ping, error) {	905	+	func UnmarshalPing(b []byte) (protocol.Ping, error) {
906		r := payloadReader{b: b}	906		r := payloadReader{b: b}
907		if err := r.done(); err != nil {	907		if err := r.done(); err != nil {
908	-	return Ping{}, err	908	+	return protocol.Ping{}, err
909		}	909		}
910	-	return Ping{}, nil	910	+	return protocol.Ping{}, nil
911		}	911		}
912			912
913		// MarshalPong encodes a Pong message payload (always empty).	913		// MarshalPong encodes a Pong message payload (always empty).
914	-	func MarshalPong(Pong) []byte {	914	+	func MarshalPong(protocol.Pong) []byte {
915		return nil	915		return nil
916		}	916		}
917			917
918		// UnmarshalPong decodes a Pong message payload.	918		// UnmarshalPong decodes a Pong message payload.
919	-	func UnmarshalPong(b []byte) (Pong, error) {	919	+	func UnmarshalPong(b []byte) (protocol.Pong, error) {
920		r := payloadReader{b: b}	920		r := payloadReader{b: b}
921		if err := r.done(); err != nil {	921		if err := r.done(); err != nil {
922	-	return Pong{}, err	922	+	return protocol.Pong{}, err
923		}	923		}
924	-	return Pong{}, nil	924	+	return protocol.Pong{}, nil
925		}	925		}
926			926
927		// MarshalAck encodes m into an epoch/state Ack payload.	927		// MarshalAck encodes m into an epoch/state Ack payload.

@@ -956,7 +956,7 @@ func UnmarshalAck(b []byte) (protocol.Ack, error) {
956		}	956		}
957			957
958		// MarshalWelcome encodes m into a Welcome message payload.	958		// MarshalWelcome encodes m into a Welcome message payload.
959	-	func MarshalWelcome(m Welcome) []byte {	959	+	func MarshalWelcome(m protocol.Welcome) []byte {
960		if m.CommittedIdentity != nil && (m.SessionName != m.CommittedIdentity.Target.SessionName \|\| m.Ephemeral != m.CommittedIdentity.Ephemeral) {	960		if m.CommittedIdentity != nil && (m.SessionName != m.CommittedIdentity.Target.SessionName \|\| m.Ephemeral != m.CommittedIdentity.Ephemeral) {
961		return nil	961		return nil
962		}	962		}

@@ -977,42 +977,42 @@ func MarshalWelcome(m Welcome) []byte {
977		}	977		}
978			978
979		// UnmarshalWelcome decodes a Welcome message payload.	979		// UnmarshalWelcome decodes a Welcome message payload.
980	-	func UnmarshalWelcome(b []byte) (Welcome, error) {	980	+	func UnmarshalWelcome(b []byte) (protocol.Welcome, error) {
981		r := payloadReader{b: b}	981		r := payloadReader{b: b}
982	-	var m Welcome	982	+	var m protocol.Welcome
983		var err error	983		var err error
984			984
985		if m.SessionID, err = r.getString(); err != nil {	985		if m.SessionID, err = r.getString(); err != nil {
986	-	return Welcome{}, err	986	+	return protocol.Welcome{}, err
987		}	987		}
988		if m.SessionName, err = r.getString(); err != nil {	988		if m.SessionName, err = r.getString(); err != nil {
989	-	return Welcome{}, err	989	+	return protocol.Welcome{}, err
990		}	990		}
991		var ephemeral bool	991		var ephemeral bool
992		if ephemeral, err = r.getBool(); err != nil {	992		if ephemeral, err = r.getBool(); err != nil {
993	-	return Welcome{}, err	993	+	return protocol.Welcome{}, err
994		}	994		}
995		m.Ephemeral = ephemeral	995		m.Ephemeral = ephemeral
996		if m.ResumeToken, err = r.getUint64(); err != nil {	996		if m.ResumeToken, err = r.getUint64(); err != nil {
997	-	return Welcome{}, err	997	+	return protocol.Welcome{}, err
998		}	998		}
999		if m.Capabilities, err = r.getUint32(); err != nil {	999		if m.Capabilities, err = r.getUint32(); err != nil {
1000	-	return Welcome{}, err	1000	+	return protocol.Welcome{}, err
1001		}	1001		}
1002		if m.CommittedIdentity, err = unmarshalCommittedIdentitySection(&r); err != nil {	1002		if m.CommittedIdentity, err = unmarshalCommittedIdentitySection(&r); err != nil {
1003	-	return Welcome{}, err	1003	+	return protocol.Welcome{}, err
1004		}	1004		}
1005		if m.CommittedIdentity != nil && (m.CommittedIdentity.Target.SessionName != m.SessionName \|\| m.CommittedIdentity.Ephemeral != m.Ephemeral) {	1005		if m.CommittedIdentity != nil && (m.CommittedIdentity.Target.SessionName != m.SessionName \|\| m.CommittedIdentity.Ephemeral != m.Ephemeral) {
1006	-	return Welcome{}, fmt.Errorf("%w: committed identity does not match welcome", protocol.ErrInvalidRouteWire)	1006	+	return protocol.Welcome{}, fmt.Errorf("%w: committed identity does not match welcome", protocol.ErrInvalidRouteWire)
1007		}	1007		}
1008		if err := r.done(); err != nil {	1008		if err := r.done(); err != nil {
1009	-	return Welcome{}, err	1009	+	return protocol.Welcome{}, err
1010		}	1010		}
1011		return m, nil	1011		return m, nil
1012		}	1012		}
1013			1013
1014		// MarshalErrorMsg encodes m into an ErrorMsg message payload.	1014		// MarshalErrorMsg encodes m into an ErrorMsg message payload.
1015	-	func MarshalErrorMsg(m ErrorMsg) []byte {	1015	+	func MarshalErrorMsg(m protocol.ErrorMsg) []byte {
1016		w := payloadWriter{}	1016		w := payloadWriter{}
1017		w.putUint16(m.Code)	1017		w.putUint16(m.Code)
1018		w.putString(m.Text)	1018		w.putString(m.Text)

@@ -1020,19 +1020,19 @@ func MarshalErrorMsg(m ErrorMsg) []byte {
1020		}	1020		}
1021			1021
1022		// UnmarshalErrorMsg decodes an ErrorMsg message payload.	1022		// UnmarshalErrorMsg decodes an ErrorMsg message payload.
1023	-	func UnmarshalErrorMsg(b []byte) (ErrorMsg, error) {	1023	+	func UnmarshalErrorMsg(b []byte) (protocol.ErrorMsg, error) {
1024		r := payloadReader{b: b}	1024		r := payloadReader{b: b}
1025	-	var m ErrorMsg	1025	+	var m protocol.ErrorMsg
1026		var err error	1026		var err error
1027			1027
1028		if m.Code, err = r.getUint16(); err != nil {	1028		if m.Code, err = r.getUint16(); err != nil {
1029	-	return ErrorMsg{}, err	1029	+	return protocol.ErrorMsg{}, err
1030		}	1030		}
1031		if m.Text, err = r.getString(); err != nil {	1031		if m.Text, err = r.getString(); err != nil {
1032	-	return ErrorMsg{}, err	1032	+	return protocol.ErrorMsg{}, err
1033		}	1033		}
1034		if err := r.done(); err != nil {	1034		if err := r.done(); err != nil {
1035	-	return ErrorMsg{}, err	1035	+	return protocol.ErrorMsg{}, err
1036		}	1036		}
1037		return m, nil	1037		return m, nil
1038		}	1038		}

@@ -1198,8 +1198,8 @@ func decompressOutputData(data []byte, decodedLen int) ([]byte, error) {
1198		}	1198		}
1199			1199
1200		// MarshalAttachTarget encodes a strict server attach-target payload.	1200		// MarshalAttachTarget encodes a strict server attach-target payload.
1201	-	func MarshalAttachTarget(m AttachTarget) []byte {	1201	+	func MarshalAttachTarget(m protocol.AttachTarget) []byte {
1202	-	if err := ValidateAttachTarget(m); err != nil {	1202	+	if err := protocol.ValidateAttachTarget(m); err != nil {
1203		return nil	1203		return nil
1204		}	1204		}
1205		w := payloadWriter{}	1205		w := payloadWriter{}

@@ -1213,118 +1213,118 @@ func MarshalAttachTarget(m AttachTarget) []byte {
1213		}	1213		}
1214			1214
1215		// UnmarshalAttachTarget decodes a strict server attach-target payload.	1215		// UnmarshalAttachTarget decodes a strict server attach-target payload.
1216	-	func UnmarshalAttachTarget(b []byte) (AttachTarget, error) {	1216	+	func UnmarshalAttachTarget(b []byte) (protocol.AttachTarget, error) {
1217		// Preflight lengths and intent before getString can allocate either value.	1217		// Preflight lengths and intent before getString can allocate either value.
1218		probe := payloadReader{b: b}	1218		probe := payloadReader{b: b}
1219		endpointLen, err := probe.getUint16()	1219		endpointLen, err := probe.getUint16()
1220		if err != nil \|\| int(endpointLen) > len(probe.b) {	1220		if err != nil \|\| int(endpointLen) > len(probe.b) {
1221	-	return AttachTarget{}, ErrInvalidAttachTarget	1221	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1222		}	1222		}
1223		probe.b = probe.b[endpointLen:]	1223		probe.b = probe.b[endpointLen:]
1224		sessionLen, err := probe.getUint16()	1224		sessionLen, err := probe.getUint16()
1225		if err != nil \|\| sessionLen == 0 \|\| int(sessionLen) > len(probe.b) {	1225		if err != nil \|\| sessionLen == 0 \|\| int(sessionLen) > len(probe.b) {
1226	-	return AttachTarget{}, ErrInvalidAttachTarget	1226	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1227		}	1227		}
1228		probe.b = probe.b[sessionLen:]	1228		probe.b = probe.b[sessionLen:]
1229		intent, err := probe.getUint8()	1229		intent, err := probe.getUint8()
1230	-	if err != nil \|\| (intent != IntentEphemeral && intent != IntentNew && intent != IntentAttach && intent != IntentResume) {	1230	+	if err != nil \|\| (intent != protocol.IntentEphemeral && intent != protocol.IntentNew && intent != protocol.IntentAttach && intent != protocol.IntentResume) {
1231	-	return AttachTarget{}, ErrInvalidAttachTarget	1231	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1232		}	1232		}
1233		if err := skipRemoteTargetSection(&probe); err != nil {	1233		if err := skipRemoteTargetSection(&probe); err != nil {
1234	-	return AttachTarget{}, ErrInvalidAttachTarget	1234	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1235		}	1235		}
1236		if err := skipExactTargetSection(&probe); err != nil {	1236		if err := skipExactTargetSection(&probe); err != nil {
1237	-	return AttachTarget{}, ErrInvalidAttachTarget	1237	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1238		}	1238		}
1239		if _, err := probe.getBool(); err != nil {	1239		if _, err := probe.getBool(); err != nil {
1240	-	return AttachTarget{}, ErrInvalidAttachTarget	1240	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1241		}	1241		}
1242		if err := probe.done(); err != nil {	1242		if err := probe.done(); err != nil {
1243	-	return AttachTarget{}, ErrInvalidAttachTarget	1243	+	return protocol.AttachTarget{}, protocol.ErrInvalidAttachTarget
1244		}	1244		}
1245			1245
1246		r := payloadReader{b: b}	1246		r := payloadReader{b: b}
1247	-	var m AttachTarget	1247	+	var m protocol.AttachTarget
1248		if m.Endpoint, err = r.getString(); err != nil {	1248		if m.Endpoint, err = r.getString(); err != nil {
1249	-	return AttachTarget{}, err	1249	+	return protocol.AttachTarget{}, err
1250		}	1250		}
1251		if m.Session, err = r.getString(); err != nil {	1251		if m.Session, err = r.getString(); err != nil {
1252	-	return AttachTarget{}, err	1252	+	return protocol.AttachTarget{}, err
1253		}	1253		}
1254		if m.Intent, err = r.getUint8(); err != nil {	1254		if m.Intent, err = r.getUint8(); err != nil {
1255	-	return AttachTarget{}, err	1255	+	return protocol.AttachTarget{}, err
1256		}	1256		}
1257		if m.RemoteTarget, m.EnvironmentPolicy, err = unmarshalRemoteTargetSection(&r); err != nil {	1257		if m.RemoteTarget, m.EnvironmentPolicy, err = unmarshalRemoteTargetSection(&r); err != nil {
1258	-	return AttachTarget{}, err	1258	+	return protocol.AttachTarget{}, err
1259		}	1259		}
1260		if m.ExactTarget, err = unmarshalExactTargetSection(&r); err != nil {	1260		if m.ExactTarget, err = unmarshalExactTargetSection(&r); err != nil {
1261	-	return AttachTarget{}, err	1261	+	return protocol.AttachTarget{}, err
1262		}	1262		}
1263		if m.SamePeer, err = r.getBool(); err != nil {	1263		if m.SamePeer, err = r.getBool(); err != nil {
1264	-	return AttachTarget{}, err	1264	+	return protocol.AttachTarget{}, err
1265		}	1265		}
1266		if err := r.done(); err != nil {	1266		if err := r.done(); err != nil {
1267	-	return AttachTarget{}, err	1267	+	return protocol.AttachTarget{}, err
1268		}	1268		}
1269	-	if err := ValidateAttachTarget(m); err != nil {	1269	+	if err := protocol.ValidateAttachTarget(m); err != nil {
1270	-	return AttachTarget{}, err	1270	+	return protocol.AttachTarget{}, err
1271		}	1271		}
1272		return m, nil	1272		return m, nil
1273		}	1273		}
1274			1274
1275		// MarshalDetached encodes m into a Detached message payload.	1275		// MarshalDetached encodes m into a Detached message payload.
1276	-	func MarshalDetached(m Detached) []byte {	1276	+	func MarshalDetached(m protocol.Detached) []byte {
1277		return []byte{m.Reason}	1277		return []byte{m.Reason}
1278		}	1278		}
1279			1279
1280		// UnmarshalDetached decodes a Detached message payload.	1280		// UnmarshalDetached decodes a Detached message payload.
1281	-	func UnmarshalDetached(b []byte) (Detached, error) {	1281	+	func UnmarshalDetached(b []byte) (protocol.Detached, error) {
1282		r := payloadReader{b: b}	1282		r := payloadReader{b: b}
1283		reason, err := r.getUint8()	1283		reason, err := r.getUint8()
1284		if err != nil {	1284		if err != nil {
1285	-	return Detached{}, err	1285	+	return protocol.Detached{}, err
1286		}	1286		}
1287	-	if ValidateDetached(Detached{Reason: reason}) != nil {	1287	+	if protocol.ValidateDetached(protocol.Detached{Reason: reason}) != nil {
1288	-	return Detached{}, errInvalidEnum	1288	+	return protocol.Detached{}, errInvalidEnum
1289		}	1289		}
1290		if err := r.done(); err != nil {	1290		if err := r.done(); err != nil {
1291	-	return Detached{}, err	1291	+	return protocol.Detached{}, err
1292		}	1292		}
1293	-	return Detached{Reason: reason}, nil	1293	+	return protocol.Detached{Reason: reason}, nil
1294		}	1294		}
1295			1295
1296		// MarshalList encodes a List message payload (always empty).	1296		// MarshalList encodes a List message payload (always empty).
1297	-	func MarshalList(List) []byte {	1297	+	func MarshalList(protocol.List) []byte {
1298		return nil	1298		return nil
1299		}	1299		}
1300			1300
1301		// UnmarshalList decodes a List message payload.	1301		// UnmarshalList decodes a List message payload.
1302	-	func UnmarshalList(b []byte) (List, error) {	1302	+	func UnmarshalList(b []byte) (protocol.List, error) {
1303		r := payloadReader{b: b}	1303		r := payloadReader{b: b}
1304		if err := r.done(); err != nil {	1304		if err := r.done(); err != nil {
1305	-	return List{}, err	1305	+	return protocol.List{}, err
1306		}	1306		}
1307	-	return List{}, nil	1307	+	return protocol.List{}, nil
1308		}	1308		}
1309			1309
1310		// MarshalOutputResetRequest encodes an OutputResetRequest payload (always	1310		// MarshalOutputResetRequest encodes an OutputResetRequest payload (always
1311		// empty).	1311		// empty).
1312	-	func MarshalOutputResetRequest(OutputResetRequest) []byte {	1312	+	func MarshalOutputResetRequest(protocol.OutputResetRequest) []byte {
1313		return nil	1313		return nil
1314		}	1314		}
1315			1315
1316		// UnmarshalOutputResetRequest decodes a strict empty OutputResetRequest	1316		// UnmarshalOutputResetRequest decodes a strict empty OutputResetRequest
1317		// payload.	1317		// payload.
1318	-	func UnmarshalOutputResetRequest(b []byte) (OutputResetRequest, error) {	1318	+	func UnmarshalOutputResetRequest(b []byte) (protocol.OutputResetRequest, error) {
1319		r := payloadReader{b: b}	1319		r := payloadReader{b: b}
1320		if err := r.done(); err != nil {	1320		if err := r.done(); err != nil {
1321	-	return OutputResetRequest{}, err	1321	+	return protocol.OutputResetRequest{}, err
1322		}	1322		}
1323	-	return OutputResetRequest{}, nil	1323	+	return protocol.OutputResetRequest{}, nil
1324		}	1324		}
1325			1325
1326		// MarshalKill encodes m into a Kill message payload.	1326		// MarshalKill encodes m into a Kill message payload.
1327	-	func MarshalKill(m Kill) []byte {	1327	+	func MarshalKill(m protocol.Kill) []byte {
1328		w := payloadWriter{}	1328		w := payloadWriter{}
1329		w.putString(m.Name)	1329		w.putString(m.Name)
1330		if m.All {	1330		if m.All {

@@ -1334,28 +1334,28 @@ func MarshalKill(m Kill) []byte {
1334		}	1334		}
1335			1335
1336		// UnmarshalKill decodes a Kill message payload.	1336		// UnmarshalKill decodes a Kill message payload.
1337	-	func UnmarshalKill(b []byte) (Kill, error) {	1337	+	func UnmarshalKill(b []byte) (protocol.Kill, error) {
1338		r := payloadReader{b: b}	1338		r := payloadReader{b: b}
1339		name, err := r.getString()	1339		name, err := r.getString()
1340		if err != nil {	1340		if err != nil {
1341	-	return Kill{}, err	1341	+	return protocol.Kill{}, err
1342		}	1342		}
1343		var all bool	1343		var all bool
1344		if len(r.b) > 0 {	1344		if len(r.b) > 0 {
1345		all, err = r.getBool()	1345		all, err = r.getBool()
1346		if err != nil {	1346		if err != nil {
1347	-	return Kill{}, err	1347	+	return protocol.Kill{}, err
1348		}	1348		}
1349		}	1349		}
1350		if err := r.done(); err != nil {	1350		if err := r.done(); err != nil {
1351	-	return Kill{}, err	1351	+	return protocol.Kill{}, err
1352		}	1352		}
1353	-	return Kill{Name: name, All: all}, nil	1353	+	return protocol.Kill{Name: name, All: all}, nil
1354		}	1354		}
1355			1355
1356		// MarshalSessions encodes m into a Sessions message payload: a uint16 count	1356		// MarshalSessions encodes m into a Sessions message payload: a uint16 count
1357		// followed by that many session records.	1357		// followed by that many session records.
1358	-	func MarshalSessions(m Sessions) []byte {	1358	+	func MarshalSessions(m protocol.Sessions) []byte {
1359		w := payloadWriter{}	1359		w := payloadWriter{}
1360		w.putUint16(uint16(len(m.Sessions)))	1360		w.putUint16(uint16(len(m.Sessions)))
1361		for _, s := range m.Sessions {	1361		for _, s := range m.Sessions {

@@ -1378,48 +1378,48 @@ func MarshalSessions(m Sessions) []byte {
1378		}	1378		}
1379			1379
1380		// UnmarshalSessions decodes a Sessions message payload.	1380		// UnmarshalSessions decodes a Sessions message payload.
1381	-	func UnmarshalSessions(b []byte) (Sessions, error) {	1381	+	func UnmarshalSessions(b []byte) (protocol.Sessions, error) {
1382		r := payloadReader{b: b}	1382		r := payloadReader{b: b}
1383		count, err := r.getUint16()	1383		count, err := r.getUint16()
1384		if err != nil {	1384		if err != nil {
1385	-	return Sessions{}, err	1385	+	return protocol.Sessions{}, err
1386		}	1386		}
1387	-	sessions := make([]SessionInfo, 0, count)	1387	+	sessions := make([]protocol.SessionInfo, 0, count)
1388		for range int(count) {	1388		for range int(count) {
1389	-	var s SessionInfo	1389	+	var s protocol.SessionInfo
1390		if s.SessionID, err = r.getString(); err != nil {	1390		if s.SessionID, err = r.getString(); err != nil {
1391	-	return Sessions{}, err	1391	+	return protocol.Sessions{}, err
1392		}	1392		}
1393		if s.Name, err = r.getString(); err != nil {	1393		if s.Name, err = r.getString(); err != nil {
1394	-	return Sessions{}, err	1394	+	return protocol.Sessions{}, err
1395		}	1395		}
1396		eph, err := r.getBool()	1396		eph, err := r.getBool()
1397		if err != nil {	1397		if err != nil {
1398	-	return Sessions{}, err	1398	+	return protocol.Sessions{}, err
1399		}	1399		}
1400		s.Ephemeral = eph	1400		s.Ephemeral = eph
1401		if s.Tabs, err = r.getUint16(); err != nil {	1401		if s.Tabs, err = r.getUint16(); err != nil {
1402	-	return Sessions{}, err	1402	+	return protocol.Sessions{}, err
1403		}	1403		}
1404		att, err := r.getBool()	1404		att, err := r.getBool()
1405		if err != nil {	1405		if err != nil {
1406	-	return Sessions{}, err	1406	+	return protocol.Sessions{}, err
1407		}	1407		}
1408		s.Attached = att	1408		s.Attached = att
1409		state, err := r.getUint8()	1409		state, err := r.getUint8()
1410		if err != nil {	1410		if err != nil {
1411	-	return Sessions{}, err	1411	+	return protocol.Sessions{}, err
1412		}	1412		}
1413	-	s.State = SessionState(state)	1413	+	s.State = protocol.SessionState(state)
1414	-	if s.State > SessionBroken {	1414	+	if s.State > protocol.SessionBroken {
1415	-	return Sessions{}, errors.New("ports: invalid session state")	1415	+	return protocol.Sessions{}, errors.New("ports: invalid session state")
1416		}	1416		}
1417		sessions = append(sessions, s)	1417		sessions = append(sessions, s)
1418		}	1418		}
1419		if err := r.done(); err != nil {	1419		if err := r.done(); err != nil {
1420	-	return Sessions{}, err	1420	+	return protocol.Sessions{}, err
1421		}	1421		}
1422	-	return Sessions{Sessions: sessions}, nil	1422	+	return protocol.Sessions{Sessions: sessions}, nil
1423		}	1423		}
1424		func putInt16(w *payloadWriter, n int) { w.putUint16(uint16(int16(n))) }	1424		func putInt16(w *payloadWriter, n int) { w.putUint16(uint16(int16(n))) }
1425			1425

@@ -1737,7 +1737,7 @@ func MarshalParkedRouteRequest(request protocol.ParkedRouteRequest) []byte {
1737		w.putUint64(request.RequestID)	1737		w.putUint64(request.RequestID)
1738		w.putBytes(request.LeaseID[:])	1738		w.putBytes(request.LeaseID[:])
1739		w.putUint8(uint8(request.Action))	1739		w.putUint8(uint8(request.Action))
1740	-	marshalRemoteTargetSection(&w, request.Target, EnvironmentPolicyDaemonOwned)	1740	+	marshalRemoteTargetSection(&w, request.Target, protocol.EnvironmentPolicyDaemonOwned)
1741		return w.b	1741		return w.b
1742		}	1742		}
1743			1743

@@ -1757,7 +1757,7 @@ func UnmarshalParkedRouteRequest(b []byte) (protocol.ParkedRouteRequest, error)
1757		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation	1757		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
1758		}	1758		}
1759		target, policy, err := unmarshalRemoteTargetSection(&r)	1759		target, policy, err := unmarshalRemoteTargetSection(&r)
1760	-	if err != nil \|\| policy != EnvironmentPolicyDaemonOwned \|\| r.done() != nil {	1760	+	if err != nil \|\| policy != protocol.EnvironmentPolicyDaemonOwned \|\| r.done() != nil {
1761		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation	1761		return protocol.ParkedRouteRequest{}, protocol.ErrInvalidNavigation
1762		}	1762		}
1763		request := protocol.ParkedRouteRequest{RequestID: requestID, Action: protocol.ParkedRouteAction(action), Target: target}	1763		request := protocol.ParkedRouteRequest{RequestID: requestID, Action: protocol.ParkedRouteAction(action), Target: target}

M internal/ports/wire_command.go +27 -49

 	"encoding/binary"
 	"errors"
 	"math"
+	"github.com/bnema/vev/internal/protocol"
 )
 // ErrTooManyCommandArgs reports that a request exceeds the wire count limit.
 var ErrTooManyCommandArgs = errors.New("ports: too many command arguments")
-// CommandRequest asks the daemon to run one control command. Version must
-// stay first so a future payload layout can still be rejected cleanly.
-type CommandRequest struct {
-	Version       uint16
-	RequestID     uint64
-	Attached      bool
-	Self          bool
-	Slug          string
-	Args          []string
-	TargetSession string
-	TargetTab     string
-	TargetPane    string
-	JSON          bool
-}
-// CommandResult reports a control command's outcome.
-type CommandResult struct {
-	RequestID uint64
-	OK        bool
-	Code      uint16
-	Text      string
-	Output    string
-}
 // PeekCommandVersion returns the leading protocol version from a
 // CommandRequest payload.
 func PeekCommandVersion(b []byte) (uint16, bool) {
 }
 // MarshalCommandRequest encodes m into a CommandRequest payload.
-func MarshalCommandRequest(m CommandRequest) ([]byte, error) {
+func MarshalCommandRequest(m protocol.CommandRequest) ([]byte, error) {
 	if len(m.Args) > math.MaxUint16 {
 		return nil, ErrTooManyCommandArgs
 	}
 }
 // UnmarshalCommandRequest decodes a strict CommandRequest payload.
-func UnmarshalCommandRequest(b []byte) (CommandRequest, error) {
+func UnmarshalCommandRequest(b []byte) (protocol.CommandRequest, error) {
 	r := payloadReader{b: b}
-	var m CommandRequest
+	var m protocol.CommandRequest
 	var err error
 	if m.Version, err = r.getUint16(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.RequestID, err = r.getUint64(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.Attached, err = r.getBool(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.Self, err = r.getBool(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.Slug, err = r.getString(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	argCount, err := r.getUint16()
 	if err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	// Every argument requires at least a uint32 length prefix. Reject an
 	// impossible count before allocating from untrusted input.
 	if uint64(argCount) > uint64(len(r.b)/4) {
-		return CommandRequest{}, errShortPayload
+		return protocol.CommandRequest{}, errShortPayload
 	}
 	if argCount != 0 {
 		m.Args = make([]string, 0, int(argCount))
 		for range int(argCount) {
 			arg, err := r.getLongString()
 			if err != nil {
-				return CommandRequest{}, err
+				return protocol.CommandRequest{}, err
 			}
 			m.Args = append(m.Args, arg)
 		}
 	}
 	if m.TargetSession, err = r.getString(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.TargetTab, err = r.getString(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.TargetPane, err = r.getString(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if m.JSON, err = r.getBool(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	if err := r.done(); err != nil {
-		return CommandRequest{}, err
+		return protocol.CommandRequest{}, err
 	}
 	return m, nil
 }
 // MarshalCommandResult encodes m into a CommandResult payload.
-func MarshalCommandResult(m CommandResult) []byte {
+func MarshalCommandResult(m protocol.CommandResult) []byte {
 	w := payloadWriter{}
 	w.putUint64(m.RequestID)
 	w.putBool(m.OK)
 }
 // UnmarshalCommandResult decodes a strict CommandResult payload.
-func UnmarshalCommandResult(b []byte) (CommandResult, error) {
+func UnmarshalCommandResult(b []byte) (protocol.CommandResult, error) {
 	r := payloadReader{b: b}
-	var m CommandResult
+	var m protocol.CommandResult
 	var err error
 	if m.RequestID, err = r.getUint64(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	if m.OK, err = r.getBool(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	if m.Code, err = r.getUint16(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	if m.Text, err = r.getString(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	if m.Output, err = r.getLongString(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	if err := r.done(); err != nil {
-		return CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	return m, nil
 }

M internal/ports/wire_final_test.go +27 -27


@@ -12,21 +12,21 @@ import (
12		)	12		)
13			13
14		func TestFinalProtocolVersionAndNoV21Hello(t *testing.T) {	14		func TestFinalProtocolVersionAndNoV21Hello(t *testing.T) {
15	-	if ProtocolVersion != 37 {	15	+	if protocol.Version != 37 {
16	-	t.Fatalf("ProtocolVersion = %d, want 37", ProtocolVersion)	16	+	t.Fatalf("ProtocolVersion = %d, want 37", protocol.Version)
17		}	17		}
18	-	payload := MarshalHello(Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}})	18	+	payload := MarshalHello(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}})
19		if len(payload) < 2 {	19		if len(payload) < 2 {
20		t.Fatal("MarshalHello produced a truncated valid payload")	20		t.Fatal("MarshalHello produced a truncated valid payload")
21		}	21		}
22		binary.BigEndian.PutUint16(payload, 21)	22		binary.BigEndian.PutUint16(payload, 21)
23	-	if _, err := UnmarshalHello(payload); !errors.Is(err, ErrInvalidHello) {	23	+	if _, err := UnmarshalHello(payload); !errors.Is(err, protocol.ErrInvalidHello) {
24		t.Fatalf("UnmarshalHello(v21) error = %v, want ErrInvalidHello", err)	24		t.Fatalf("UnmarshalHello(v21) error = %v, want ErrInvalidHello", err)
25		}	25		}
26		}	26		}
27			27
28		func TestFinalHelloGoldenStrict(t *testing.T) {	28		func TestFinalHelloGoldenStrict(t *testing.T) {
29	-	msg := Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}	29	+	msg := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}
30		want := append([]byte{0, 37, 2}, make([]byte, 16+8)...)	30		want := append([]byte{0, 37, 2}, make([]byte, 16+8)...)
31		want = append(want, 0, 0, 0, 80, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)	31		want = append(want, 0, 0, 0, 80, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
32		want = append(want, 0, 0)	32		want = append(want, 0, 0)

@@ -46,7 +46,7 @@ func TestFinalHelloGoldenStrict(t *testing.T) {
46		}	46		}
47			47
48		func TestHelloDeclaresKittyDirectGraphicsAtWireTail(t *testing.T) {	48		func TestHelloDeclaresKittyDirectGraphicsAtWireTail(t *testing.T) {
49	-	msg := Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, KittyDirectGraphics: true}	49	+	msg := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}, KittyDirectGraphics: true}
50		payload := MarshalHello(msg)	50		payload := MarshalHello(msg)
51		if len(payload) == 0 \|\| payload[len(payload)-1] != 1 {	51		if len(payload) == 0 \|\| payload[len(payload)-1] != 1 {
52		t.Fatalf("Hello capability tail = %x, want trailing true declaration", payload)	52		t.Fatalf("Hello capability tail = %x, want trailing true declaration", payload)

@@ -61,20 +61,20 @@ func TestHelloDeclaresKittyDirectGraphicsAtWireTail(t *testing.T) {
61		}	61		}
62			62
63		func TestFinalHelloSemanticValidation(t *testing.T) {	63		func TestFinalHelloSemanticValidation(t *testing.T) {
64	-	valid := Hello{Version: ProtocolVersion, Intent: IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}	64	+	valid := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Size: domain.Size{Cols: 80, Rows: 24}}
65		for _, tt := range []struct {	65		for _, tt := range []struct {
66		name string	66		name string
67	-	mutate func(*Hello)	67	+	mutate func(*protocol.Hello)
68		}{	68		}{
69	-	{name: "intent", mutate: func(h *Hello) { h.Intent = 99 }},	69	+	{name: "intent", mutate: func(h *protocol.Hello) { h.Intent = 99 }},
70	-	{name: "zero columns", mutate: func(h *Hello) { h.Size.Cols = 0 }},	70	+	{name: "zero columns", mutate: func(h *protocol.Hello) { h.Size.Cols = 0 }},
71	-	{name: "zero rows", mutate: func(h *Hello) { h.Size.Rows = 0 }},	71	+	{name: "zero rows", mutate: func(h *protocol.Hello) { h.Size.Rows = 0 }},
72	-	{name: "area", mutate: func(h *Hello) { h.Size = domain.Size{Cols: 513, Rows: 512} }},	72	+	{name: "area", mutate: func(h *protocol.Hello) { h.Size = domain.Size{Cols: 513, Rows: 512} }},
73		} {	73		} {
74		t.Run(tt.name, func(t *testing.T) {	74		t.Run(tt.name, func(t *testing.T) {
75		msg := valid	75		msg := valid
76		tt.mutate(&msg)	76		tt.mutate(&msg)
77	-	if err := ValidateHello(msg); err == nil {	77	+	if err := protocol.ValidateHello(msg); err == nil {
78		t.Fatal("ValidateHello accepted malformed semantics")	78		t.Fatal("ValidateHello accepted malformed semantics")
79		}	79		}
80		})	80		})

@@ -195,7 +195,7 @@ func TestFinalAckGoldenStrict(t *testing.T) {
195		}	195		}
196			196
197		func TestFinalAttachTargetGoldenStrict(t *testing.T) {	197		func TestFinalAttachTargetGoldenStrict(t *testing.T) {
198	-	msg := AttachTarget{Endpoint: "host", Session: "work", Intent: IntentAttach}	198	+	msg := protocol.AttachTarget{Endpoint: "host", Session: "work", Intent: protocol.IntentAttach}
199		want := []byte{0, 4, 'h', 'o', 's', 't', 0, 4, 'w', 'o', 'r', 'k', 2, 0, 0, 0, 0}	199		want := []byte{0, 4, 'h', 'o', 's', 't', 0, 4, 'w', 'o', 'r', 'k', 2, 0, 0, 0, 0}
200		got := MarshalAttachTarget(msg)	200		got := MarshalAttachTarget(msg)
201		if !bytes.Equal(got, want) {	201		if !bytes.Equal(got, want) {

@@ -207,12 +207,12 @@ func TestFinalAttachTargetGoldenStrict(t *testing.T) {
207		}	207		}
208		assertAllPrefixesFail(t, got, UnmarshalAttachTarget)	208		assertAllPrefixesFail(t, got, UnmarshalAttachTarget)
209		assertTrailingGarbageFails(t, got, UnmarshalAttachTarget)	209		assertTrailingGarbageFails(t, got, UnmarshalAttachTarget)
210	-	local := AttachTarget{Session: "work", Intent: IntentAttach}	210	+	local := protocol.AttachTarget{Session: "work", Intent: protocol.IntentAttach}
211		localPayload := MarshalAttachTarget(local)	211		localPayload := MarshalAttachTarget(local)
212		if localPayload == nil {	212		if localPayload == nil {
213		t.Fatal("MarshalAttachTarget rejected same-peer route handoff")	213		t.Fatal("MarshalAttachTarget rejected same-peer route handoff")
214		}	214		}
215	-	wantLocal := []byte{0, 0, 0, 4, 'w', 'o', 'r', 'k', IntentAttach, 0, 0, 0, 0}	215	+	wantLocal := []byte{0, 0, 0, 4, 'w', 'o', 'r', 'k', protocol.IntentAttach, 0, 0, 0, 0}
216		if !bytes.Equal(localPayload, wantLocal) {	216		if !bytes.Equal(localPayload, wantLocal) {
217		t.Fatalf("same-peer bytes = %x, want %x", localPayload, wantLocal)	217		t.Fatalf("same-peer bytes = %x, want %x", localPayload, wantLocal)
218		}	218		}

@@ -222,7 +222,7 @@ func TestFinalAttachTargetGoldenStrict(t *testing.T) {
222		}	222		}
223		assertAllPrefixesFail(t, localPayload, UnmarshalAttachTarget)	223		assertAllPrefixesFail(t, localPayload, UnmarshalAttachTarget)
224		assertTrailingGarbageFails(t, localPayload, UnmarshalAttachTarget)	224		assertTrailingGarbageFails(t, localPayload, UnmarshalAttachTarget)
225	-	for _, bad := range []AttachTarget{{Endpoint: "host", Intent: IntentAttach}, {Endpoint: "host", Session: "work", Intent: 99}} {	225	+	for _, bad := range []protocol.AttachTarget{{Endpoint: "host", Intent: protocol.IntentAttach}, {Endpoint: "host", Session: "work", Intent: 99}} {
226		if got := MarshalAttachTarget(bad); got != nil {	226		if got := MarshalAttachTarget(bad); got != nil {
227		t.Fatalf("MarshalAttachTarget(%+v) = %x, want nil", bad, got)	227		t.Fatalf("MarshalAttachTarget(%+v) = %x, want nil", bad, got)
228		}	228		}

@@ -232,9 +232,9 @@ func TestFinalAttachTargetGoldenStrict(t *testing.T) {
232		func TestAttachTargetExactTargetWireStrict(t *testing.T) {	232		func TestAttachTargetExactTargetWireStrict(t *testing.T) {
233		var lifecycle domain.SessionLifecycleID	233		var lifecycle domain.SessionLifecycleID
234		lifecycle[0] = 1	234		lifecycle[0] = 1
235	-	target := AttachTarget{Session: "work", Intent: IntentAttach, ExactTarget: &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}, SamePeer: true}	235	+	target := protocol.AttachTarget{Session: "work", Intent: protocol.IntentAttach, ExactTarget: &protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}, SamePeer: true}
236		payload := MarshalAttachTarget(target)	236		payload := MarshalAttachTarget(target)
237	-	want := append([]byte{0, 0, 0, 4, 'w', 'o', 'r', 'k', IntentAttach, 0, 0, 1, 1}, make([]byte, 15)...)	237	+	want := append([]byte{0, 0, 0, 4, 'w', 'o', 'r', 'k', protocol.IntentAttach, 0, 0, 1, 1}, make([]byte, 15)...)
238		want = append(want, 0, 4, 'w', 'o', 'r', 'k', 1)	238		want = append(want, 0, 4, 'w', 'o', 'r', 'k', 1)
239		if !bytes.Equal(payload, want) {	239		if !bytes.Equal(payload, want) {
240		t.Fatalf("exact target bytes = %x, want %x", payload, want)	240		t.Fatalf("exact target bytes = %x, want %x", payload, want)

@@ -261,7 +261,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
261		{	261		{
262		name: "hello boolean",	262		name: "hello boolean",
263		payload: func() []byte {	263		payload: func() []byte {
264	-	b := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}})	264	+	b := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}})
265		b[len(b)-8] = 2	265		b[len(b)-8] = 2
266		return b	266		return b
267		}(),	267		}(),

@@ -270,7 +270,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
270		{	270		{
271		name: "hello remote boolean",	271		name: "hello remote boolean",
272		payload: func() []byte {	272		payload: func() []byte {
273	-	b := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}})	273	+	b := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}})
274		b[len(b)-2] = 2	274		b[len(b)-2] = 2
275		return b	275		return b
276		}(),	276		}(),

@@ -279,7 +279,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
279		{	279		{
280		name: "hello Kitty graphics boolean",	280		name: "hello Kitty graphics boolean",
281		payload: func() []byte {	281		payload: func() []byte {
282	-	b := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}})	282	+	b := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}})
283		b[len(b)-1] = 2	283		b[len(b)-1] = 2
284		return b	284		return b
285		}(),	285		}(),

@@ -288,7 +288,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
288		{	288		{
289		name: "attach target same-peer boolean",	289		name: "attach target same-peer boolean",
290		payload: func() []byte {	290		payload: func() []byte {
291	-	b := MarshalAttachTarget(AttachTarget{Endpoint: "host", Session: "work", Intent: IntentAttach})	291	+	b := MarshalAttachTarget(protocol.AttachTarget{Endpoint: "host", Session: "work", Intent: protocol.IntentAttach})
292		b[len(b)-1] = 2	292		b[len(b)-1] = 2
293		return b	293		return b
294		}(),	294		}(),

@@ -297,7 +297,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
297		{	297		{
298		name: "welcome boolean",	298		name: "welcome boolean",
299		payload: func() []byte {	299		payload: func() []byte {
300	-	b := MarshalWelcome(Welcome{SessionID: "id"})	300	+	b := MarshalWelcome(protocol.Welcome{SessionID: "id"})
301		b[6] = 2	301		b[6] = 2
302		return b	302		return b
303		}(),	303		}(),

@@ -307,7 +307,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
307		{	307		{
308		name: "kill boolean",	308		name: "kill boolean",
309		payload: func() []byte {	309		payload: func() []byte {
310	-	b := MarshalKill(Kill{All: true})	310	+	b := MarshalKill(protocol.Kill{All: true})
311		b[len(b)-1] = 2	311		b[len(b)-1] = 2
312		return b	312		return b
313		}(),	313		}(),

@@ -316,7 +316,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
316		{	316		{
317		name: "sessions ephemeral boolean",	317		name: "sessions ephemeral boolean",
318		payload: func() []byte {	318		payload: func() []byte {
319	-	b := MarshalSessions(Sessions{Sessions: []SessionInfo{{State: SessionUp}}})	319	+	b := MarshalSessions(protocol.Sessions{Sessions: []protocol.SessionInfo{{State: protocol.SessionUp}}})
320		b[6] = 2	320		b[6] = 2
321		return b	321		return b
322		}(),	322		}(),

@@ -325,7 +325,7 @@ func TestFinalClosedWireValuesRejectUnknownEnumsAndBooleans(t *testing.T) {
325		{	325		{
326		name: "sessions attached boolean",	326		name: "sessions attached boolean",
327		payload: func() []byte {	327		payload: func() []byte {
328	-	b := MarshalSessions(Sessions{Sessions: []SessionInfo{{State: SessionUp}}})	328	+	b := MarshalSessions(protocol.Sessions{Sessions: []protocol.SessionInfo{{State: protocol.SessionUp}}})
329		b[9] = 2	329		b[9] = 2
330		return b	330		return b
331		}(),	331		}(),

M internal/ports/wire_test.go +92 -92


@@ -63,14 +63,14 @@ func appendNoNavigationTail(payload []byte) []byte {
63		func TestHelloGoldenAndRoundTrip(t *testing.T) {	63		func TestHelloGoldenAndRoundTrip(t *testing.T) {
64		tests := []struct {	64		tests := []struct {
65		name string	65		name string
66	-	msg Hello	66	+	msg protocol.Hello
67		want []byte	67		want []byte
68		}{	68		}{
69		{	69		{
70		name: "typical",	70		name: "typical",
71	-	msg: Hello{	71	+	msg: protocol.Hello{
72		Version: 1,	72		Version: 1,
73	-	Intent: IntentNew,	73	+	Intent: protocol.IntentNew,
74		ClientID: [16]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10},	74		ClientID: [16]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10},
75		ResumeToken: 0x0102030405060708,	75		ResumeToken: 0x0102030405060708,
76		Name: "w0",	76		Name: "w0",

@@ -84,9 +84,9 @@ func TestHelloGoldenAndRoundTrip(t *testing.T) {
84		},	84		},
85		{	85		{
86		name: "empty strings",	86		name: "empty strings",
87	-	msg: Hello{	87	+	msg: protocol.Hello{
88		Version: 1,	88		Version: 1,
89	-	Intent: IntentEphemeral,	89	+	Intent: protocol.IntentEphemeral,
90		Name: "",	90		Name: "",
91		Size: domain.Size{Cols: 1, Rows: 1},	91		Size: domain.Size{Cols: 1, Rows: 1},
92		TermEnv: "",	92		TermEnv: "",

@@ -129,8 +129,8 @@ func TestHelloGoldenAndRoundTrip(t *testing.T) {
129			129
130		func TestHelloEnvironmentCodec(t *testing.T) {	130		func TestHelloEnvironmentCodec(t *testing.T) {
131		t.Run("literal wire layout", func(t *testing.T) {	131		t.Run("literal wire layout", func(t *testing.T) {
132	-	msg := Hello{	132	+	msg := protocol.Hello{
133	-	Version: ProtocolVersion,	133	+	Version: protocol.Version,
134		Size: domain.Size{Cols: 1, Rows: 1},	134		Size: domain.Size{Cols: 1, Rows: 1},
135		Env: []string{"A=B", "XY=123"},	135		Env: []string{"A=B", "XY=123"},
136		}	136		}

@@ -163,20 +163,20 @@ func TestHelloEnvironmentCodec(t *testing.T) {
163		t.Run("lossless order and values", func(t *testing.T) {	163		t.Run("lossless order and values", func(t *testing.T) {
164		entryOverUint16 := "LARGE=" + string(bytes.Repeat([]byte("x"), 65536))	164		entryOverUint16 := "LARGE=" + string(bytes.Repeat([]byte("x"), 65536))
165		want := []string{"A=first", "TOKEN=a=b=c", "EMPTY=", entryOverUint16, "A=second"}	165		want := []string{"A=first", "TOKEN=a=b=c", "EMPTY=", entryOverUint16, "A=second"}
166	-	payload := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}, Env: want})	166	+	payload := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}, Env: want})
167		got, err := UnmarshalHello(payload)	167		got, err := UnmarshalHello(payload)
168		require.NoError(t, err)	168		require.NoError(t, err)
169		require.Equal(t, want, got.Env)	169		require.Equal(t, want, got.Env)
170		})	170		})
171			171
172		t.Run("empty", func(t *testing.T) {	172		t.Run("empty", func(t *testing.T) {
173	-	payload := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}, Env: []string{}})	173	+	payload := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}, Env: []string{}})
174		got, err := UnmarshalHello(payload)	174		got, err := UnmarshalHello(payload)
175		require.NoError(t, err)	175		require.NoError(t, err)
176		require.Empty(t, got.Env)	176		require.Empty(t, got.Env)
177		})	177		})
178			178
179	-	base := MarshalHello(Hello{Version: ProtocolVersion, Size: domain.Size{Cols: 1, Rows: 1}})	179	+	base := MarshalHello(protocol.Hello{Version: protocol.Version, Size: domain.Size{Cols: 1, Rows: 1}})
180		withCount := func(count byte) []byte {	180		withCount := func(count byte) []byte {
181		payload := append([]byte(nil), base...)	181		payload := append([]byte(nil), base...)
182		// The uint32 environment count occupies bytes len-13 through len-10.	182		// The uint32 environment count occupies bytes len-13 through len-10.

@@ -214,11 +214,11 @@ func TestHelloEnvironmentCodec(t *testing.T) {
214		func TestInputGoldenAndRoundTrip(t *testing.T) {	214		func TestInputGoldenAndRoundTrip(t *testing.T) {
215		tests := []struct {	215		tests := []struct {
216		name string	216		name string
217	-	msg Input	217	+	msg protocol.Input
218		want []byte	218		want []byte
219		}{	219		}{
220	-	{name: "data", msg: Input{InputSeq: 0x0102030405060708, Data: []byte("hi")}, want: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x68, 0x69}},	220	+	{name: "data", msg: protocol.Input{InputSeq: 0x0102030405060708, Data: []byte("hi")}, want: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x68, 0x69}},
221	-	{name: "empty", msg: Input{InputSeq: 0, Data: nil}, want: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},	221	+	{name: "empty", msg: protocol.Input{InputSeq: 0, Data: nil}, want: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
222		}	222		}
223			223
224		for _, tt := range tests {	224		for _, tt := range tests {

@@ -367,7 +367,7 @@ func TestThemeGenerationClearedWireGoldenPreservesProtocolVersion(t *testing.T)
367		}	367		}
368		want := append([]byte{0x0f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00}, make([]byte, 48)...)	368		want := append([]byte{0x0f, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00}, make([]byte, 48)...)
369		require.Equal(t, want, MarshalTheme(cleared))	369		require.Equal(t, want, MarshalTheme(cleared))
370	-	require.Equal(t, uint16(37), ProtocolVersion)	370	+	require.Equal(t, uint16(37), protocol.Version)
371		}	371		}
372			372
373		func TestResizeGoldenAndRoundTrip(t *testing.T) {	373		func TestResizeGoldenAndRoundTrip(t *testing.T) {

@@ -394,7 +394,7 @@ func TestResizeGoldenAndRoundTrip(t *testing.T) {
394		}	394		}
395			395
396		func TestDetachGoldenAndRoundTrip(t *testing.T) {	396		func TestDetachGoldenAndRoundTrip(t *testing.T) {
397	-	got := MarshalDetach(Detach{})	397	+	got := MarshalDetach(protocol.Detach{})
398		if len(got) != 0 {	398		if len(got) != 0 {
399		t.Fatalf("MarshalDetach() = %#v, want empty", got)	399		t.Fatalf("MarshalDetach() = %#v, want empty", got)
400		}	400		}

@@ -402,14 +402,14 @@ func TestDetachGoldenAndRoundTrip(t *testing.T) {
402		if err != nil {	402		if err != nil {
403		t.Fatalf("UnmarshalDetach() error = %v", err)	403		t.Fatalf("UnmarshalDetach() error = %v", err)
404		}	404		}
405	-	if back != (Detach{}) {	405	+	if back != (protocol.Detach{}) {
406	-	t.Fatalf("round trip = %#v, want %#v", back, Detach{})	406	+	t.Fatalf("round trip = %#v, want %#v", back, protocol.Detach{})
407		}	407		}
408		assertTrailingGarbageFails(t, got, UnmarshalDetach)	408		assertTrailingGarbageFails(t, got, UnmarshalDetach)
409		}	409		}
410			410
411		func TestPingGoldenAndRoundTrip(t *testing.T) {	411		func TestPingGoldenAndRoundTrip(t *testing.T) {
412	-	got := MarshalPing(Ping{})	412	+	got := MarshalPing(protocol.Ping{})
413		if len(got) != 0 {	413		if len(got) != 0 {
414		t.Fatalf("MarshalPing() = %#v, want empty", got)	414		t.Fatalf("MarshalPing() = %#v, want empty", got)
415		}	415		}

@@ -417,14 +417,14 @@ func TestPingGoldenAndRoundTrip(t *testing.T) {
417		if err != nil {	417		if err != nil {
418		t.Fatalf("UnmarshalPing() error = %v", err)	418		t.Fatalf("UnmarshalPing() error = %v", err)
419		}	419		}
420	-	if back != (Ping{}) {	420	+	if back != (protocol.Ping{}) {
421	-	t.Fatalf("round trip = %#v, want %#v", back, Ping{})	421	+	t.Fatalf("round trip = %#v, want %#v", back, protocol.Ping{})
422		}	422		}
423		assertTrailingGarbageFails(t, got, UnmarshalPing)	423		assertTrailingGarbageFails(t, got, UnmarshalPing)
424		}	424		}
425			425
426		func TestPongGoldenAndRoundTrip(t *testing.T) {	426		func TestPongGoldenAndRoundTrip(t *testing.T) {
427	-	got := MarshalPong(Pong{})	427	+	got := MarshalPong(protocol.Pong{})
428		if len(got) != 0 {	428		if len(got) != 0 {
429		t.Fatalf("MarshalPong() = %#v, want empty", got)	429		t.Fatalf("MarshalPong() = %#v, want empty", got)
430		}	430		}

@@ -432,14 +432,14 @@ func TestPongGoldenAndRoundTrip(t *testing.T) {
432		if err != nil {	432		if err != nil {
433		t.Fatalf("UnmarshalPong() error = %v", err)	433		t.Fatalf("UnmarshalPong() error = %v", err)
434		}	434		}
435	-	if back != (Pong{}) {	435	+	if back != (protocol.Pong{}) {
436	-	t.Fatalf("round trip = %#v, want %#v", back, Pong{})	436	+	t.Fatalf("round trip = %#v, want %#v", back, protocol.Pong{})
437		}	437		}
438		assertTrailingGarbageFails(t, got, UnmarshalPong)	438		assertTrailingGarbageFails(t, got, UnmarshalPong)
439		}	439		}
440			440
441		func TestMarshalWelcomeRejectsInvalidCommittedIdentity(t *testing.T) {	441		func TestMarshalWelcomeRejectsInvalidCommittedIdentity(t *testing.T) {
442	-	got := MarshalWelcome(Welcome{	442	+	got := MarshalWelcome(protocol.Welcome{
443		SessionName: "work",	443		SessionName: "work",
444		CommittedIdentity: &protocol.CommittedRouteIdentity{	444		CommittedIdentity: &protocol.CommittedRouteIdentity{
445		Target: protocol.ExactSessionTarget{SessionName: "different"},	445		Target: protocol.ExactSessionTarget{SessionName: "different"},

@@ -449,7 +449,7 @@ func TestMarshalWelcomeRejectsInvalidCommittedIdentity(t *testing.T) {
449		}	449		}
450			450
451		func TestMarshalWelcomeRejectsCommittedIdentityMetadataMismatch(t *testing.T) {	451		func TestMarshalWelcomeRejectsCommittedIdentityMetadataMismatch(t *testing.T) {
452	-	base := Welcome{	452	+	base := protocol.Welcome{
453		SessionID: "session",	453		SessionID: "session",
454		SessionName: "work",	454		SessionName: "work",
455		Ephemeral: true,	455		Ephemeral: true,

@@ -458,9 +458,9 @@ func TestMarshalWelcomeRejectsCommittedIdentityMetadataMismatch(t *testing.T) {
458		Ephemeral: true,	458		Ephemeral: true,
459		},	459		},
460		}	460		}
461	-	for name, mutate := range map[string]func(*Welcome){	461	+	for name, mutate := range map[string]func(*protocol.Welcome){
462	-	"session name": func(w *Welcome) { w.SessionName = "other" },	462	+	"session name": func(w *protocol.Welcome) { w.SessionName = "other" },
463	-	"ephemeral": func(w *Welcome) { w.Ephemeral = false },	463	+	"ephemeral": func(w *protocol.Welcome) { w.Ephemeral = false },
464		} {	464		} {
465		t.Run(name, func(t *testing.T) {	465		t.Run(name, func(t *testing.T) {
466		got := base	466		got := base

@@ -474,17 +474,17 @@ func TestMarshalWelcomeRejectsCommittedIdentityMetadataMismatch(t *testing.T) {
474		func TestWelcomeGoldenAndRoundTrip(t *testing.T) {	474		func TestWelcomeGoldenAndRoundTrip(t *testing.T) {
475		tests := []struct {	475		tests := []struct {
476		name string	476		name string
477	-	msg Welcome	477	+	msg protocol.Welcome
478		want []byte	478		want []byte
479		}{	479		}{
480		{	480		{
481		name: "ephemeral",	481		name: "ephemeral",
482	-	msg: Welcome{SessionID: "sess-1", SessionName: "main", Ephemeral: true, ResumeToken: 0x0102030405060708, Capabilities: CapabilityResume \| CapabilityPredict},	482	+	msg: protocol.Welcome{SessionID: "sess-1", SessionName: "main", Ephemeral: true, ResumeToken: 0x0102030405060708, Capabilities: protocol.CapabilityResume \| protocol.CapabilityPredict},
483		want: []byte{0x00, 0x06, 0x73, 0x65, 0x73, 0x73, 0x2d, 0x31, 0x00, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x05, 0x00},	483		want: []byte{0x00, 0x06, 0x73, 0x65, 0x73, 0x73, 0x2d, 0x31, 0x00, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x01, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x00, 0x05, 0x00},
484		},	484		},
485		{	485		{
486		name: "non-ephemeral empty name",	486		name: "non-ephemeral empty name",
487	-	msg: Welcome{SessionID: "abc", SessionName: "", Ephemeral: false},	487	+	msg: protocol.Welcome{SessionID: "abc", SessionName: "", Ephemeral: false},
488		want: []byte{0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},	488		want: []byte{0x00, 0x03, 0x61, 0x62, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
489		},	489		},
490		}	490		}

@@ -511,22 +511,22 @@ func TestWelcomeGoldenAndRoundTrip(t *testing.T) {
511		}	511		}
512			512
513		func TestCommandErrorCodes(t *testing.T) {	513		func TestCommandErrorCodes(t *testing.T) {
514	-	require.Equal(t, uint16(6), ErrUnknownCommand)	514	+	require.Equal(t, uint16(6), protocol.ErrUnknownCommand)
515	-	require.Equal(t, uint16(7), ErrNotScriptable)	515	+	require.Equal(t, uint16(7), protocol.ErrNotScriptable)
516	-	require.Equal(t, uint16(8), ErrInvalidCommandArgs)	516	+	require.Equal(t, uint16(8), protocol.ErrInvalidCommandArgs)
517	-	require.Equal(t, uint16(9), ErrNoSuchTarget)	517	+	require.Equal(t, uint16(9), protocol.ErrNoSuchTarget)
518	-	require.Equal(t, uint16(10), ErrAmbiguousTarget)	518	+	require.Equal(t, uint16(10), protocol.ErrAmbiguousTarget)
519		}	519		}
520			520
521		func TestCommandRequestGoldenAndRoundTrip(t *testing.T) {	521		func TestCommandRequestGoldenAndRoundTrip(t *testing.T) {
522		tests := []struct {	522		tests := []struct {
523		name string	523		name string
524	-	msg CommandRequest	524	+	msg protocol.CommandRequest
525		want []byte	525		want []byte
526		}{	526		}{
527		{	527		{
528		name: "minimal",	528		name: "minimal",
529	-	msg: CommandRequest{Version: ProtocolVersion, Slug: "split-right"},	529	+	msg: protocol.CommandRequest{Version: protocol.Version, Slug: "split-right"},
530		want: []byte{	530		want: []byte{
531		0x00, 0x25,	531		0x00, 0x25,
532		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID	532		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID

@@ -540,8 +540,8 @@ func TestCommandRequestGoldenAndRoundTrip(t *testing.T) {
540		},	540		},
541		{	541		{
542		name: "full",	542		name: "full",
543	-	msg: CommandRequest{	543	+	msg: protocol.CommandRequest{
544	-	Version: ProtocolVersion,	544	+	Version: protocol.Version,
545		Self: true,	545		Self: true,
546		Slug: "toast",	546		Slug: "toast",
547		Args: []string{"-l", "warn", "tests KO"},	547		Args: []string{"-l", "warn", "tests KO"},

@@ -590,8 +590,8 @@ func TestCommandRequestGoldenAndRoundTrip(t *testing.T) {
590		}	590		}
591			591
592		func TestMarshalCommandRequestRejectsTooManyArguments(t *testing.T) {	592		func TestMarshalCommandRequestRejectsTooManyArguments(t *testing.T) {
593	-	payload, err := MarshalCommandRequest(CommandRequest{	593	+	payload, err := MarshalCommandRequest(protocol.CommandRequest{
594	-	Version: ProtocolVersion,	594	+	Version: protocol.Version,
595		Slug: "toast",	595		Slug: "toast",
596		Args: make([]string, math.MaxUint16+1),	596		Args: make([]string, math.MaxUint16+1),
597		})	597		})

@@ -601,7 +601,7 @@ func TestMarshalCommandRequestRejectsTooManyArguments(t *testing.T) {
601		}	601		}
602			602
603		func TestCommandRequestRejectsImpossibleArgumentCount(t *testing.T) {	603		func TestCommandRequestRejectsImpossibleArgumentCount(t *testing.T) {
604	-	payload, err := MarshalCommandRequest(CommandRequest{Version: ProtocolVersion, Slug: "toast"})	604	+	payload, err := MarshalCommandRequest(protocol.CommandRequest{Version: protocol.Version, Slug: "toast"})
605		require.NoError(t, err)	605		require.NoError(t, err)
606		argCountOffset := 2 + 8 + 1 + 1 + 2 + len("toast")	606		argCountOffset := 2 + 8 + 1 + 1 + 2 + len("toast")
607		payload[argCountOffset] = 0xff	607		payload[argCountOffset] = 0xff

@@ -615,12 +615,12 @@ func TestCommandRequestRejectsImpossibleArgumentCount(t *testing.T) {
615		func TestCommandResultGoldenAndRoundTrip(t *testing.T) {	615		func TestCommandResultGoldenAndRoundTrip(t *testing.T) {
616		tests := []struct {	616		tests := []struct {
617		name string	617		name string
618	-	msg CommandResult	618	+	msg protocol.CommandResult
619		want []byte	619		want []byte
620		}{	620		}{
621		{	621		{
622		name: "error",	622		name: "error",
623	-	msg: CommandResult{Code: ErrNoSuchTarget, Text: "no such session"},	623	+	msg: protocol.CommandResult{Code: protocol.ErrNoSuchTarget, Text: "no such session"},
624		want: []byte{	624		want: []byte{
625		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID	625		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID
626		0x00,	626		0x00,

@@ -631,7 +631,7 @@ func TestCommandResultGoldenAndRoundTrip(t *testing.T) {
631		},	631		},
632		{	632		{
633		name: "success with output",	633		name: "success with output",
634	-	msg: CommandResult{OK: true, Text: "listed", Output: "ID\tFOCUSED\n"},	634	+	msg: protocol.CommandResult{OK: true, Text: "listed", Output: "ID\tFOCUSED\n"},
635		want: []byte{	635		want: []byte{
636		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID	636		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // request ID
637		0x01,	637		0x01,

@@ -656,7 +656,7 @@ func TestCommandResultGoldenAndRoundTrip(t *testing.T) {
656		}	656		}
657			657
658		func TestErrorMsgGoldenAndRoundTrip(t *testing.T) {	658		func TestErrorMsgGoldenAndRoundTrip(t *testing.T) {
659	-	msg := ErrorMsg{Code: ErrNameTaken, Text: "name taken"}	659	+	msg := protocol.ErrorMsg{Code: protocol.ErrNameTaken, Text: "name taken"}
660		want := []byte{0x00, 0x03, 0x00, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e}	660		want := []byte{0x00, 0x03, 0x00, 0x0a, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x61, 0x6b, 0x65, 0x6e}
661			661
662		got := MarshalErrorMsg(msg)	662		got := MarshalErrorMsg(msg)

@@ -722,7 +722,7 @@ func TestAckGoldenAndRoundTrip(t *testing.T) {
722		}	722		}
723			723
724		func TestDetachedGoldenAndRoundTrip(t *testing.T) {	724		func TestDetachedGoldenAndRoundTrip(t *testing.T) {
725	-	msg := Detached{Reason: ReasonReplaced}	725	+	msg := protocol.Detached{Reason: protocol.ReasonReplaced}
726		want := []byte{0x03}	726		want := []byte{0x03}
727			727
728		got := MarshalDetached(msg)	728		got := MarshalDetached(msg)

@@ -744,13 +744,13 @@ func TestDetachedGoldenAndRoundTrip(t *testing.T) {
744		func TestClientNoticeGoldenAndStrict(t *testing.T) {	744		func TestClientNoticeGoldenAndStrict(t *testing.T) {
745		tests := []struct {	745		tests := []struct {
746		name string	746		name string
747	-	msg ClientNotice	747	+	msg protocol.ClientNotice
748		want []byte	748		want []byte
749		}{	749		}{
750	-	{name: "clipboard fallback", msg: ClientNotice{Action: ClientNoticeClipboardFallback}, want: []byte{0x01}},	750	+	{name: "clipboard fallback", msg: protocol.ClientNotice{Action: protocol.ClientNoticeClipboardFallback}, want: []byte{0x01}},
751	-	{name: "clipboard too large", msg: ClientNotice{Action: ClientNoticeClipboardTooLarge}, want: []byte{0x02}},	751	+	{name: "clipboard too large", msg: protocol.ClientNotice{Action: protocol.ClientNoticeClipboardTooLarge}, want: []byte{0x02}},
752	-	{name: "link degraded", msg: ClientNotice{Action: ClientNoticeLinkDegraded}, want: []byte{0x03}},	752	+	{name: "link degraded", msg: protocol.ClientNotice{Action: protocol.ClientNoticeLinkDegraded}, want: []byte{0x03}},
753	-	{name: "link connected", msg: ClientNotice{Action: ClientNoticeLinkConnected}, want: []byte{0x04}},	753	+	{name: "link connected", msg: protocol.ClientNotice{Action: protocol.ClientNoticeLinkConnected}, want: []byte{0x04}},
754		}	754		}
755		for _, tt := range tests {	755		for _, tt := range tests {
756		t.Run(tt.name, func(t *testing.T) {	756		t.Run(tt.name, func(t *testing.T) {

@@ -768,7 +768,7 @@ func TestClientNoticeGoldenAndStrict(t *testing.T) {
768		}	768		}
769			769
770		func TestListGoldenAndRoundTrip(t *testing.T) {	770		func TestListGoldenAndRoundTrip(t *testing.T) {
771	-	got := MarshalList(List{})	771	+	got := MarshalList(protocol.List{})
772		if len(got) != 0 {	772		if len(got) != 0 {
773		t.Fatalf("MarshalList() = %#v, want empty", got)	773		t.Fatalf("MarshalList() = %#v, want empty", got)
774		}	774		}

@@ -776,8 +776,8 @@ func TestListGoldenAndRoundTrip(t *testing.T) {
776		if err != nil {	776		if err != nil {
777		t.Fatalf("UnmarshalList() error = %v", err)	777		t.Fatalf("UnmarshalList() error = %v", err)
778		}	778		}
779	-	if back != (List{}) {	779	+	if back != (protocol.List{}) {
780	-	t.Fatalf("round trip = %#v, want %#v", back, List{})	780	+	t.Fatalf("round trip = %#v, want %#v", back, protocol.List{})
781		}	781		}
782		assertTrailingGarbageFails(t, got, UnmarshalList)	782		assertTrailingGarbageFails(t, got, UnmarshalList)
783		}	783		}

@@ -785,12 +785,12 @@ func TestListGoldenAndRoundTrip(t *testing.T) {
785		func TestKillGoldenAndRoundTrip(t *testing.T) {	785		func TestKillGoldenAndRoundTrip(t *testing.T) {
786		tests := []struct {	786		tests := []struct {
787		name string	787		name string
788	-	msg Kill	788	+	msg protocol.Kill
789		want []byte	789		want []byte
790		}{	790		}{
791	-	{name: "named", msg: Kill{Name: "main"}, want: []byte{0x00, 0x04, 0x6d, 0x61, 0x69, 0x6e}},	791	+	{name: "named", msg: protocol.Kill{Name: "main"}, want: []byte{0x00, 0x04, 0x6d, 0x61, 0x69, 0x6e}},
792	-	{name: "empty", msg: Kill{Name: ""}, want: []byte{0x00, 0x00}},	792	+	{name: "empty", msg: protocol.Kill{Name: ""}, want: []byte{0x00, 0x00}},
793	-	{name: "all", msg: Kill{All: true}, want: []byte{0x00, 0x00, 0x01}},	793	+	{name: "all", msg: protocol.Kill{All: true}, want: []byte{0x00, 0x00, 0x01}},
794		}	794		}
795			795
796		for _, tt := range tests {	796		for _, tt := range tests {

@@ -814,7 +814,7 @@ func TestKillGoldenAndRoundTrip(t *testing.T) {
814		if err != nil {	814		if err != nil {
815		t.Fatalf("UnmarshalKill(legacy) error = %v", err)	815		t.Fatalf("UnmarshalKill(legacy) error = %v", err)
816		}	816		}
817	-	if !reflect.DeepEqual(back, Kill{Name: "main"}) {	817	+	if !reflect.DeepEqual(back, protocol.Kill{Name: "main"}) {
818		t.Fatalf("legacy round trip = %#v, want named kill", back)	818		t.Fatalf("legacy round trip = %#v, want named kill", back)
819		}	819		}
820		assertAllPrefixesFail(t, legacy, UnmarshalKill)	820		assertAllPrefixesFail(t, legacy, UnmarshalKill)

@@ -824,16 +824,16 @@ func TestKillGoldenAndRoundTrip(t *testing.T) {
824		func TestSessionInfoRecoveryState(t *testing.T) {	824		func TestSessionInfoRecoveryState(t *testing.T) {
825		tests := []struct {	825		tests := []struct {
826		name string	826		name string
827	-	state SessionState	827	+	state protocol.SessionState
828		want []byte	828		want []byte
829		}{	829		}{
830	-	{name: "up", state: SessionUp, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}},	830	+	{name: "up", state: protocol.SessionUp, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
831	-	{name: "down", state: SessionDown, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1}},	831	+	{name: "down", state: protocol.SessionDown, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
832	-	{name: "broken", state: SessionBroken, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2}},	832	+	{name: "broken", state: protocol.SessionBroken, want: []byte{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2}},
833		}	833		}
834		for _, tt := range tests {	834		for _, tt := range tests {
835		t.Run(tt.name, func(t *testing.T) {	835		t.Run(tt.name, func(t *testing.T) {
836	-	payload := MarshalSessions(Sessions{Sessions: []SessionInfo{{State: tt.state}}})	836	+	payload := MarshalSessions(protocol.Sessions{Sessions: []protocol.SessionInfo{{State: tt.state}}})
837		require.Equal(t, tt.want, payload)	837		require.Equal(t, tt.want, payload)
838		got, err := UnmarshalSessions(payload)	838		got, err := UnmarshalSessions(payload)
839		require.NoError(t, err)	839		require.NoError(t, err)

@@ -853,19 +853,19 @@ func TestSessionInfoRecoveryState(t *testing.T) {
853		func TestSessionsGoldenAndRoundTrip(t *testing.T) {	853		func TestSessionsGoldenAndRoundTrip(t *testing.T) {
854		tests := []struct {	854		tests := []struct {
855		name string	855		name string
856	-	msg Sessions	856	+	msg protocol.Sessions
857		want []byte	857		want []byte
858		}{	858		}{
859		{	859		{
860		name: "empty",	860		name: "empty",
861	-	msg: Sessions{},	861	+	msg: protocol.Sessions{},
862		want: []byte{0x00, 0x00},	862		want: []byte{0x00, 0x00},
863		},	863		},
864		{	864		{
865		name: "two",	865		name: "two",
866	-	msg: Sessions{Sessions: []SessionInfo{	866	+	msg: protocol.Sessions{Sessions: []protocol.SessionInfo{
867	-	{SessionID: "0", Name: "0", State: SessionUp, Ephemeral: true, Tabs: 1, Attached: false},	867	+	{SessionID: "0", Name: "0", State: protocol.SessionUp, Ephemeral: true, Tabs: 1, Attached: false},
868	-	{SessionID: "work", Name: "proj", State: SessionDown, Ephemeral: false, Tabs: 5, Attached: true},	868	+	{SessionID: "work", Name: "proj", State: protocol.SessionDown, Ephemeral: false, Tabs: 5, Attached: true},
869		}},	869		}},
870		want: []byte{	870		want: []byte{
871		0x00, 0x02,	871		0x00, 0x02,

@@ -907,10 +907,10 @@ func TestSessionsGoldenAndRoundTrip(t *testing.T) {
907		func TestMsgTypeConstantsDistinct(t *testing.T) {	907		func TestMsgTypeConstantsDistinct(t *testing.T) {
908		t.Run("intents", func(t *testing.T) {	908		t.Run("intents", func(t *testing.T) {
909		vals := map[uint8]string{	909		vals := map[uint8]string{
910	-	IntentEphemeral: "IntentEphemeral",	910	+	protocol.IntentEphemeral: "IntentEphemeral",
911	-	IntentNew: "IntentNew",	911	+	protocol.IntentNew: "IntentNew",
912	-	IntentAttach: "IntentAttach",	912	+	protocol.IntentAttach: "IntentAttach",
913	-	IntentResume: "IntentResume",	913	+	protocol.IntentResume: "IntentResume",
914		}	914		}
915		if len(vals) != 4 {	915		if len(vals) != 4 {
916		t.Fatalf("expected 4 distinct intent values, got %d", len(vals))	916		t.Fatalf("expected 4 distinct intent values, got %d", len(vals))

@@ -919,12 +919,12 @@ func TestMsgTypeConstantsDistinct(t *testing.T) {
919			919
920		t.Run("error codes", func(t *testing.T) {	920		t.Run("error codes", func(t *testing.T) {
921		vals := map[uint16]string{	921		vals := map[uint16]string{
922	-	ErrVersionMismatch: "ErrVersionMismatch",	922	+	protocol.ErrVersionMismatch: "ErrVersionMismatch",
923	-	ErrNoSuchSession: "ErrNoSuchSession",	923	+	protocol.ErrNoSuchSession: "ErrNoSuchSession",
924	-	ErrNameTaken: "ErrNameTaken",	924	+	protocol.ErrNameTaken: "ErrNameTaken",
925	-	ErrServerShutdown: "ErrServerShutdown",	925	+	protocol.ErrServerShutdown: "ErrServerShutdown",
926	-	ErrInvalidSessionName: "ErrInvalidSessionName",	926	+	protocol.ErrInvalidSessionName: "ErrInvalidSessionName",
927	-	ErrInternal: "ErrInternal",	927	+	protocol.ErrInternal: "ErrInternal",
928		}	928		}
929		if len(vals) != 6 {	929		if len(vals) != 6 {
930		t.Fatalf("expected 6 distinct error codes, got %d", len(vals))	930		t.Fatalf("expected 6 distinct error codes, got %d", len(vals))

@@ -933,10 +933,10 @@ func TestMsgTypeConstantsDistinct(t *testing.T) {
933			933
934		t.Run("detached reasons", func(t *testing.T) {	934		t.Run("detached reasons", func(t *testing.T) {
935		vals := map[uint8]string{	935		vals := map[uint8]string{
936	-	ReasonDetach: "ReasonDetach",	936	+	protocol.ReasonDetach: "ReasonDetach",
937	-	ReasonSessionKilled: "ReasonSessionKilled",	937	+	protocol.ReasonSessionKilled: "ReasonSessionKilled",
938	-	ReasonServerShutdown: "ReasonServerShutdown",	938	+	protocol.ReasonServerShutdown: "ReasonServerShutdown",
939	-	ReasonReplaced: "ReasonReplaced",	939	+	protocol.ReasonReplaced: "ReasonReplaced",
940		}	940		}
941		if len(vals) != 4 {	941		if len(vals) != 4 {
942		t.Fatalf("expected 4 distinct detached reasons, got %d", len(vals))	942		t.Fatalf("expected 4 distinct detached reasons, got %d", len(vals))

@@ -947,7 +947,7 @@ func TestMsgTypeConstantsDistinct(t *testing.T) {
947		func TestHelloOutputWindowByteExactValues(t *testing.T) {	947		func TestHelloOutputWindowByteExactValues(t *testing.T) {
948		for _, window := range []uint8{0, 1, 8} {	948		for _, window := range []uint8{0, 1, 8} {
949		t.Run(fmt.Sprintf("window_%d", window), func(t *testing.T) {	949		t.Run(fmt.Sprintf("window_%d", window), func(t *testing.T) {
950	-	hello := Hello{Version: 14, Size: domain.Size{Cols: 1, Rows: 1}, MaxOutputInFlight: window}	950	+	hello := protocol.Hello{Version: 14, Size: domain.Size{Cols: 1, Rows: 1}, MaxOutputInFlight: window}
951		// The empty Hello has a fixed 1x1 size and zero pixel geometry before the negotiated output window.	951		// The empty Hello has a fixed 1x1 size and zero pixel geometry before the negotiated output window.
952		want := append(make([]byte, 42), window, 0, 0, 0, 0, 0, 0)	952		want := append(make([]byte, 42), window, 0, 0, 0, 0, 0, 0)
953		want = appendNoNavigationTail(want)	953		want = appendNoNavigationTail(want)

@@ -973,12 +973,12 @@ func requireBytesEqual(t *testing.T, want, got []byte) {
973		func TestCommandCorrelationGoldenAndStrict(t *testing.T) {	973		func TestCommandCorrelationGoldenAndStrict(t *testing.T) {
974		tests := []struct {	974		tests := []struct {
975		name string	975		name string
976	-	msg CommandRequest	976	+	msg protocol.CommandRequest
977		want []byte	977		want []byte
978		}{	978		}{
979		{	979		{
980		name: "attached",	980		name: "attached",
981	-	msg: CommandRequest{Version: ProtocolVersion, RequestID: 0x0102030405060708, Attached: true, Self: true, Slug: "split-right", Args: []string{"--vertical"}},	981	+	msg: protocol.CommandRequest{Version: protocol.Version, RequestID: 0x0102030405060708, Attached: true, Self: true, Slug: "split-right", Args: []string{"--vertical"}},
982		want: []byte{	982		want: []byte{
983		0x00, 0x25, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01, 0x01,	983		0x00, 0x25, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x01, 0x01,
984		0x00, 0x0b, 's', 'p', 'l', 'i', 't', '-', 'r', 'i', 'g', 'h', 't',	984		0x00, 0x0b, 's', 'p', 'l', 'i', 't', '-', 'r', 'i', 'g', 'h', 't',

@@ -988,7 +988,7 @@ func TestCommandCorrelationGoldenAndStrict(t *testing.T) {
988		},	988		},
989		{	989		{
990		name: "control",	990		name: "control",
991	-	msg: CommandRequest{Version: ProtocolVersion, Slug: "ls"},	991	+	msg: protocol.CommandRequest{Version: protocol.Version, Slug: "ls"},
992		want: []byte{	992		want: []byte{
993		0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	993		0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
994		0x00, 0x02, 'l', 's', 0x00, 0x00,	994		0x00, 0x02, 'l', 's', 0x00, 0x00,

@@ -1020,7 +1020,7 @@ func TestCommandCorrelationGoldenAndStrict(t *testing.T) {
1020		}	1020		}
1021			1021
1022		func TestCommandResultCorrelationGoldenAndStrict(t *testing.T) {	1022		func TestCommandResultCorrelationGoldenAndStrict(t *testing.T) {
1023	-	msg := CommandResult{RequestID: 0x0102030405060708, OK: true, Code: 7, Text: "ok", Output: "result"}	1023	+	msg := protocol.CommandResult{RequestID: 0x0102030405060708, OK: true, Code: 7, Text: "ok", Output: "result"}
1024		want := []byte{	1024		want := []byte{
1025		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,	1025		0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1026		0x01, 0x00, 0x07, 0x00, 0x02, 'o', 'k', 0x00, 0x00, 0x00, 0x06, 'r', 'e', 's', 'u', 'l', 't',	1026		0x01, 0x00, 0x07, 0x00, 0x02, 'o', 'k', 0x00, 0x00, 0x00, 0x06, 'r', 'e', 's', 'u', 'l', 't',

@@ -1040,10 +1040,10 @@ func TestCommandResultCorrelationGoldenAndStrict(t *testing.T) {
1040		}	1040		}
1041			1041
1042		func TestOutputResetRequestStrict(t *testing.T) {	1042		func TestOutputResetRequestStrict(t *testing.T) {
1043	-	got := MarshalOutputResetRequest(OutputResetRequest{})	1043	+	got := MarshalOutputResetRequest(protocol.OutputResetRequest{})
1044		require.Empty(t, got)	1044		require.Empty(t, got)
1045		back, err := UnmarshalOutputResetRequest(got)	1045		back, err := UnmarshalOutputResetRequest(got)
1046		require.NoError(t, err)	1046		require.NoError(t, err)
1047	-	require.Equal(t, OutputResetRequest{}, back)	1047	+	require.Equal(t, protocol.OutputResetRequest{}, back)
1048		assertTrailingGarbageFails(t, got, UnmarshalOutputResetRequest)	1048		assertTrailingGarbageFails(t, got, UnmarshalOutputResetRequest)
1049		}	1049		}

A internal/protocol/command.go +25 -0

@@ -0,0 +1,25 @@
	1	+	package protocol
	2	+
	3	+	// CommandRequest asks the daemon to run one control command. Version must stay
	4	+	// first so a future payload layout can still be rejected cleanly.
	5	+	type CommandRequest struct {
	6	+	Version uint16
	7	+	RequestID uint64
	8	+	Attached bool
	9	+	Self bool
	10	+	Slug string
	11	+	Args []string
	12	+	TargetSession string
	13	+	TargetTab string
	14	+	TargetPane string
	15	+	JSON bool
	16	+	}
	17	+
	18	+	// CommandResult reports a control command's outcome.
	19	+	type CommandResult struct {
	20	+	RequestID uint64
	21	+	OK bool
	22	+	Code uint16
	23	+	Text string
	24	+	Output string
	25	+	}

M internal/protocol/navigation.go +10 -0


@@ -86,6 +86,16 @@ func ValidateNavigation(capabilities NavigationCapabilities, overlay StartupOver
86	return nil	86		return nil
87	}	87		}
88		88
		89	+	func validateHelloNavigation(h Hello) error {
		90	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
		91	+	if h.NavigationCapabilities != 0 \|\| h.StartupOverlay != StartupOverlayNone {
		92	+	return ErrInvalidNavigation
		93	+	}
		94	+	return nil
		95	+	}
		96	+	return ValidateNavigation(h.NavigationCapabilities, h.StartupOverlay, h.RemoteTarget != nil \|\| h.EnvironmentPolicy == EnvironmentPolicyDaemonOwned)
		97	+	}
		98	+
89	func ValidateParkedRouteRequest(request ParkedRouteRequest) error {	99		func ValidateParkedRouteRequest(request ParkedRouteRequest) error {
90	if request.RequestID == 0 \|\| request.LeaseID.IsZero() {	100		if request.RequestID == 0 \|\| request.LeaseID.IsZero() {
91	return ErrInvalidNavigation	101		return ErrInvalidNavigation

M internal/protocol/session.go +304 -4


@@ -6,22 +6,122 @@ import (
6		"errors"	6		"errors"
7		"fmt"	7		"fmt"
8		"math"	8		"math"
			9	+	"time"
9			10
10		renderer "github.com/bnema/vev-vt"	11		renderer "github.com/bnema/vev-vt"
11		"github.com/bnema/vev/internal/domain"	12		"github.com/bnema/vev/internal/domain"
12		)	13		)
13			14
			15	+	// Version is the negotiated vev session protocol version.
			16	+	const Version uint16 = 37
			17	+
			18	+	// HandshakeTimeout bounds every transport handshake from connect through the
			19	+	// first committed publication.
			20	+	const HandshakeTimeout = 15 * time.Second
			21	+
14		// MaxOutputDataLen is the largest decoded terminal byte stream accepted by one	22		// MaxOutputDataLen is the largest decoded terminal byte stream accepted by one
15		// output publication in protocol version 37.	23		// output publication in protocol version 37.
16		const MaxOutputDataLen = (16 << 20) - 55	24		const MaxOutputDataLen = (16 << 20) - 55
17			25
			26	+	// ConnectionCapabilities describes transport behavior relevant to session
			27	+	// flow without naming a concrete carriage.
			28	+	type ConnectionCapabilities struct {
			29	+	OutputDataLimit int
			30	+	PreferredOutputWindow uint8
			31	+	AsyncSend bool
			32	+	OwnedSynchronousSend bool
			33	+	LinkState bool
			34	+	}
			35	+
18		var (	36		var (
19	-	ErrInvalidSize = errors.New("ports: invalid terminal size")	37	+	ErrInvalidSize = errors.New("ports: invalid terminal size")
20	-	ErrInvalidOutput = errors.New("ports: invalid output")	38	+	ErrInvalidHello = errors.New("ports: invalid hello")
21	-	ErrInvalidAck = errors.New("ports: invalid ack")	39	+	ErrInvalidOutput = errors.New("ports: invalid output")
22	-	ErrInvalidNavigation = errors.New("ports: invalid navigation")	40	+	ErrInvalidAck = errors.New("ports: invalid ack")
			41	+	ErrInvalidAttachTarget = errors.New("ports: invalid attach target")
			42	+	ErrInvalidNavigation = errors.New("ports: invalid navigation")
			43	+	ErrInvalidEnvironmentPolicy = errors.New("ports: invalid environment policy")
			44	+	ErrInvalidClientNotice = errors.New("ports: invalid client notice")
			45	+	ErrInvalidDetached = errors.New("ports: invalid detached reason")
			46	+	)
			47	+
			48	+	const (
			49	+	IntentEphemeral uint8 = 0
			50	+	IntentNew uint8 = 1
			51	+	IntentAttach uint8 = 2
			52	+	IntentResume uint8 = 3
			53	+	)
			54	+
			55	+	type EnvironmentPolicy uint8
			56	+
			57	+	const (
			58	+	EnvironmentPolicyClientOwned EnvironmentPolicy = iota
			59	+	EnvironmentPolicyDaemonOwned
			60	+	)
			61	+
			62	+	const (
			63	+	CapabilityResume uint32 = 1 << 0
			64	+	CapabilityUDP uint32 = 1 << 1
			65	+	CapabilityPredict uint32 = 1 << 2
			66	+	)
			67	+
			68	+	const (
			69	+	ErrVersionMismatch uint16 = 1
			70	+	ErrNoSuchSession uint16 = 2
			71	+	ErrNameTaken uint16 = 3
			72	+	ErrServerShutdown uint16 = 4
			73	+	ErrInvalidSessionName uint16 = 5
			74	+	ErrUnknownCommand uint16 = 6
			75	+	ErrNotScriptable uint16 = 7
			76	+	ErrInvalidCommandArgs uint16 = 8
			77	+	ErrNoSuchTarget uint16 = 9
			78	+	ErrAmbiguousTarget uint16 = 10
			79	+	ErrInternal uint16 = 255
23		)	80		)
24			81
			82	+	const (
			83	+	ReasonDetach uint8 = 0
			84	+	ReasonSessionKilled uint8 = 1
			85	+	ReasonServerShutdown uint8 = 2
			86	+	ReasonReplaced uint8 = 3
			87	+	)
			88	+
			89	+	// Hello is sent by the client immediately after connecting.
			90	+	type Hello struct {
			91	+	Version uint16
			92	+	Intent uint8
			93	+	ClientID [16]byte
			94	+	ResumeToken uint64
			95	+	Name string
			96	+	Size domain.Size
			97	+	PixelWidth int
			98	+	PixelHeight int
			99	+	TermEnv string
			100	+	Cwd string
			101	+	TrueColor bool
			102	+	// KittyDirectGraphics is an explicit declaration that the client has
			103	+	// probed its direct outer terminal and it accepts Kitty graphics output.
			104	+	KittyDirectGraphics bool
			105	+	MaxOutputInFlight uint8
			106	+	Env []string
			107	+	RemoteTarget *domain.RemoteSessionTarget
			108	+	ExactTarget *ExactSessionTarget
			109	+	PreferredTabID domain.TabStableID
			110	+	EnvironmentPolicy EnvironmentPolicy
			111	+	NavigationCapabilities NavigationCapabilities
			112	+	StartupOverlay StartupOverlay
			113	+	Remote bool
			114	+	}
			115	+
			116	+	func (h Hello) Geometry() domain.Geometry {
			117	+	return domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}.NormalizePixels()
			118	+	}
			119	+
			120	+	type Input struct {
			121	+	InputSeq uint64
			122	+	Data []byte
			123	+	}
			124	+
25		type Resize struct {	125		type Resize struct {
26		Size domain.Size	126		Size domain.Size
27		PixelWidth int	127		PixelWidth int

@@ -50,11 +150,38 @@ type ImagePush struct {
50		Data []byte	150		Data []byte
51		}	151		}
52			152
			153	+	type ClientNotice struct{ Action uint8 }
			154	+
			155	+	const (
			156	+	ClientNoticeClipboardFallback uint8 = 1
			157	+	ClientNoticeClipboardTooLarge uint8 = 2
			158	+	ClientNoticeLinkDegraded uint8 = 3
			159	+	ClientNoticeLinkConnected uint8 = 4
			160	+	)
			161	+
			162	+	type Detach struct{}
			163	+	type Ping struct{}
			164	+	type Pong struct{}
			165	+
53		type Ack struct {	166		type Ack struct {
54		Epoch uint64	167		Epoch uint64
55		State uint64	168		State uint64
56		}	169		}
57			170
			171	+	type Welcome struct {
			172	+	SessionID string
			173	+	SessionName string
			174	+	Ephemeral bool
			175	+	ResumeToken uint64
			176	+	Capabilities uint32
			177	+	CommittedIdentity *CommittedRouteIdentity
			178	+	}
			179	+
			180	+	type ErrorMsg struct {
			181	+	Code uint16
			182	+	Text string
			183	+	}
			184	+
58		type Output struct {	185		type Output struct {
59		Epoch uint64	186		Epoch uint64
60		Base uint64	187		Base uint64

@@ -66,6 +193,145 @@ type Output struct {
66		Data []byte	193		Data []byte
67		}	194		}
68			195
			196	+	type AttachTarget struct {
			197	+	Endpoint string
			198	+	Session string
			199	+	Intent uint8
			200	+	RemoteTarget *domain.RemoteSessionTarget
			201	+	ExactTarget *ExactSessionTarget
			202	+	EnvironmentPolicy EnvironmentPolicy
			203	+	SamePeer bool
			204	+	}
			205	+
			206	+	type Detached struct{ Reason uint8 }
			207	+	type List struct{}
			208	+
			209	+	type Kill struct {
			210	+	Name string
			211	+	All bool
			212	+	}
			213	+
			214	+	type SessionState uint8
			215	+
			216	+	const (
			217	+	SessionUp SessionState = iota
			218	+	SessionDown
			219	+	SessionBroken
			220	+	)
			221	+
			222	+	type SessionInfo struct {
			223	+	SessionID string
			224	+	Name string
			225	+	State SessionState
			226	+	Ephemeral bool
			227	+	Tabs uint16
			228	+	Attached bool
			229	+	}
			230	+
			231	+	type Sessions struct{ Sessions []SessionInfo }
			232	+	type OutputResetRequest struct{}
			233	+
			234	+	func validEnvironmentPolicy(policy EnvironmentPolicy) bool {
			235	+	return policy == EnvironmentPolicyClientOwned \|\| policy == EnvironmentPolicyDaemonOwned
			236	+	}
			237	+
			238	+	func ValidateEnvironmentPolicy(policy EnvironmentPolicy) error {
			239	+	if !validEnvironmentPolicy(policy) {
			240	+	return ErrInvalidEnvironmentPolicy
			241	+	}
			242	+	return nil
			243	+	}
			244	+
			245	+	func validClientNoticeAction(action uint8) bool {
			246	+	switch action {
			247	+	case ClientNoticeClipboardFallback, ClientNoticeClipboardTooLarge, ClientNoticeLinkDegraded, ClientNoticeLinkConnected:
			248	+	return true
			249	+	default:
			250	+	return false
			251	+	}
			252	+	}
			253	+
			254	+	func validDetachedReason(reason uint8) bool {
			255	+	switch reason {
			256	+	case ReasonDetach, ReasonSessionKilled, ReasonServerShutdown, ReasonReplaced:
			257	+	return true
			258	+	default:
			259	+	return false
			260	+	}
			261	+	}
			262	+
			263	+	func ValidateClientNotice(m ClientNotice) error {
			264	+	if !validClientNoticeAction(m.Action) {
			265	+	return ErrInvalidClientNotice
			266	+	}
			267	+	return nil
			268	+	}
			269	+
			270	+	func ValidateDetached(m Detached) error {
			271	+	if !validDetachedReason(m.Reason) {
			272	+	return ErrInvalidDetached
			273	+	}
			274	+	return nil
			275	+	}
			276	+
			277	+	func ValidateHello(h Hello) error {
			278	+	if h.Intent != IntentEphemeral && h.Intent != IntentNew && h.Intent != IntentAttach && h.Intent != IntentResume {
			279	+	return ErrInvalidHello
			280	+	}
			281	+	if err := ValidateGeometry(domain.Geometry{Size: h.Size, PixelWidth: h.PixelWidth, PixelHeight: h.PixelHeight}); err != nil {
			282	+	return fmt.Errorf("%w: geometry", ErrInvalidHello)
			283	+	}
			284	+	if !validEnvironmentPolicy(h.EnvironmentPolicy) {
			285	+	return ErrInvalidHello
			286	+	}
			287	+	if err := validateHelloNavigation(h); err != nil {
			288	+	return fmt.Errorf("%w: navigation: %w", ErrInvalidHello, err)
			289	+	}
			290	+	if len(h.Name) > math.MaxUint16 \|\| len(h.TermEnv) > math.MaxUint16 \|\| len(h.Cwd) > math.MaxUint16 \|\| len(h.Env) > math.MaxUint32 {
			291	+	return ErrInvalidHello
			292	+	}
			293	+	for _, entry := range h.Env {
			294	+	if uint64(len(entry)) > math.MaxUint32 {
			295	+	return ErrInvalidHello
			296	+	}
			297	+	}
			298	+	if h.PreferredTabID != "" {
			299	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
			300	+	return ErrInvalidHello
			301	+	}
			302	+	if err := domain.ValidateTabStableID(h.PreferredTabID); err != nil {
			303	+	return fmt.Errorf("%w: preferred tab: %v", ErrInvalidHello, err)
			304	+	}
			305	+	}
			306	+	if h.ExactTarget != nil {
			307	+	if h.Intent != IntentAttach && h.Intent != IntentResume {
			308	+	return ErrInvalidHello
			309	+	}
			310	+	if err := h.ExactTarget.Validate(); err != nil {
			311	+	return fmt.Errorf("%w: exact target: %v", ErrInvalidHello, err)
			312	+	}
			313	+	if h.Name != h.ExactTarget.SessionName {
			314	+	return ErrInvalidHello
			315	+	}
			316	+	if h.RemoteTarget != nil && (h.RemoteTarget.LifecycleID != h.ExactTarget.LifecycleID \|\| h.RemoteTarget.SessionName != h.ExactTarget.SessionName) {
			317	+	return ErrInvalidHello
			318	+	}
			319	+	}
			320	+	if h.RemoteTarget == nil {
			321	+	return nil
			322	+	}
			323	+	if h.EnvironmentPolicy != EnvironmentPolicyDaemonOwned \|\| (h.Intent != IntentAttach && h.Intent != IntentResume) {
			324	+	return ErrInvalidHello
			325	+	}
			326	+	if err := validateRemoteTarget(*h.RemoteTarget); err != nil {
			327	+	return fmt.Errorf("%w: remote target: %v", ErrInvalidHello, err)
			328	+	}
			329	+	if h.Name != h.RemoteTarget.SessionName {
			330	+	return ErrInvalidHello
			331	+	}
			332	+	return nil
			333	+	}
			334	+
69		func ValidateOutput(m Output) error {	335		func ValidateOutput(m Output) error {
70		if m.Epoch == 0 {	336		if m.Epoch == 0 {
71		return ErrInvalidOutput	337		return ErrInvalidOutput

@@ -93,6 +359,40 @@ func ValidateAck(m Ack) error {
93		return nil	359		return nil
94		}	360		}
95			361
			362	+	func ValidateAttachTarget(m AttachTarget) error {
			363	+	if m.Session == "" \|\| len(m.Endpoint) > math.MaxUint16 \|\| len(m.Session) > math.MaxUint16 {
			364	+	return ErrInvalidAttachTarget
			365	+	}
			366	+	if err := domain.ValidateSessionName(m.Session); err != nil {
			367	+	return ErrInvalidAttachTarget
			368	+	}
			369	+	if m.Intent != IntentEphemeral && m.Intent != IntentNew && m.Intent != IntentAttach && m.Intent != IntentResume {
			370	+	return ErrInvalidAttachTarget
			371	+	}
			372	+	if m.Intent == IntentResume \|\| !validEnvironmentPolicy(m.EnvironmentPolicy) {
			373	+	return ErrInvalidAttachTarget
			374	+	}
			375	+	if m.ExactTarget != nil && (m.ExactTarget.SessionName != m.Session \|\| m.ExactTarget.Validate() != nil) {
			376	+	return ErrInvalidAttachTarget
			377	+	}
			378	+	if m.SamePeer && (m.Endpoint != "" \|\| m.RemoteTarget != nil \|\| m.ExactTarget == nil) {
			379	+	return ErrInvalidAttachTarget
			380	+	}
			381	+	if m.RemoteTarget == nil {
			382	+	return nil
			383	+	}
			384	+	if m.EnvironmentPolicy != EnvironmentPolicyDaemonOwned \|\| m.Intent != IntentAttach {
			385	+	return ErrInvalidAttachTarget
			386	+	}
			387	+	if err := validateRemoteTarget(*m.RemoteTarget); err != nil {
			388	+	return fmt.Errorf("%w: remote target: %v", ErrInvalidAttachTarget, err)
			389	+	}
			390	+	if m.Endpoint != m.RemoteTarget.Endpoint \|\| m.Session != m.RemoteTarget.SessionName {
			391	+	return ErrInvalidAttachTarget
			392	+	}
			393	+	return nil
			394	+	}
			395	+
96		func validateRemoteTarget(target domain.RemoteSessionTarget) error {	396		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 {	397		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")	398		return errors.New("remote target string too long")

M internal/protocol/session_test.go +36 -1


@@ -9,6 +9,40 @@ import (
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10		)	10		)
11			11
			12	+	func TestVersionRemainsWireCompatible(t *testing.T) {
			13	+	require.Equal(t, uint16(37), Version)
			14	+	require.Equal(t, (16<<20)-55, MaxOutputDataLen)
			15	+	}
			16	+
			17	+	func TestHelloSemanticValidation(t *testing.T) {
			18	+	base := Hello{Version: Version, Intent: IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}}
			19	+	tests := []struct {
			20	+	name string
			21	+	mutate func(*Hello)
			22	+	want error
			23	+	}{
			24	+	{name: "valid", mutate: func(*Hello) {}},
			25	+	{name: "unknown intent", mutate: func(h *Hello) { h.Intent = 99 }, want: ErrInvalidHello},
			26	+	{name: "invalid geometry", mutate: func(h *Hello) { h.Size.Rows = 0 }, want: ErrInvalidHello},
			27	+	{name: "unsafe navigation", mutate: func(h *Hello) { h.NavigationCapabilities = NavigationCapabilityBack }, want: ErrInvalidHello},
			28	+	{name: "exact target name mismatch", mutate: func(h *Hello) {
			29	+	h.ExactTarget = &ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{1}, SessionName: "other"}
			30	+	}, want: ErrInvalidHello},
			31	+	}
			32	+	for _, tt := range tests {
			33	+	t.Run(tt.name, func(t *testing.T) {
			34	+	hello := base
			35	+	tt.mutate(&hello)
			36	+	err := ValidateHello(hello)
			37	+	if tt.want == nil {
			38	+	require.NoError(t, err)
			39	+	return
			40	+	}
			41	+	require.ErrorIs(t, err, tt.want)
			42	+	})
			43	+	}
			44	+	}
			45	+
12		func TestOutputSemanticValidation(t *testing.T) {	46		func TestOutputSemanticValidation(t *testing.T) {
13		valid := Output{Epoch: 1, New: 1, Full: true, Size: domain.Size{Cols: 80, Rows: 24}}	47		valid := Output{Epoch: 1, New: 1, Full: true, Size: domain.Size{Cols: 80, Rows: 24}}
14		require.NoError(t, ValidateOutput(valid))	48		require.NoError(t, ValidateOutput(valid))

@@ -43,7 +77,8 @@ func TestRouteAndPreviewSemanticValidation(t *testing.T) {
43		require.ErrorIs(t, ValidateRemotePreview(preview), ErrInvalidRemotePreview)	77		require.ErrorIs(t, ValidateRemotePreview(preview), ErrInvalidRemotePreview)
44		}	78		}
45			79
46	-	func TestPresentationErrorsPreserveClassification(t *testing.T) {	80	+	func TestSemanticErrorsPreserveClassification(t *testing.T) {
47		require.True(t, errors.Is(ValidateAck(Ack{}), ErrInvalidAck))	81		require.True(t, errors.Is(ValidateAck(Ack{}), ErrInvalidAck))
			82	+	require.True(t, errors.Is(ValidateAttachTarget(AttachTarget{}), ErrInvalidAttachTarget))
48		require.True(t, errors.Is(ValidateParkedRouteRequest(ParkedRouteRequest{}), ErrInvalidNavigation))	83		require.True(t, errors.Is(ValidateParkedRouteRequest(ParkedRouteRequest{}), ErrInvalidNavigation))
49		}	84		}

M internal/usecase/client/client.go +41 -41


@@ -133,7 +133,7 @@ const sendQueueDepth = 64
133			133
134		// preWelcomeTimeout remains the focused-test name for the shared handshake	134		// preWelcomeTimeout remains the focused-test name for the shared handshake
135		// budget, which now also covers connect and initial publication.	135		// budget, which now also covers connect and initial publication.
136	-	const preWelcomeTimeout = ports.HandshakeTimeout	136	+	const preWelcomeTimeout = protocol.HandshakeTimeout
137			137
138		// remoteHostLearnerShutdownTimeout bounds how long Run waits for async remote	138		// remoteHostLearnerShutdownTimeout bounds how long Run waits for async remote
139		// host learning after terminal restoration. Learning is best-effort; a stalled	139		// host learning after terminal restoration. Learning is best-effort; a stalled

@@ -151,7 +151,7 @@ const (
151		)	151		)
152			152
153		// Dependencies supplies the collaborators required by a Runner.	153		// Dependencies supplies the collaborators required by a Runner.
154	-	type AttachHandoffFunc func(ports.AttachTarget) (ports.Dialer, AttachRequest, error)	154	+	type AttachHandoffFunc func(protocol.AttachTarget) (ports.Dialer, AttachRequest, error)
155			155
156		type Dependencies struct {	156		type Dependencies struct {
157		Dialer ports.Dialer	157		Dialer ports.Dialer

@@ -189,7 +189,7 @@ type AttachRequest struct {
189		ExactTarget *protocol.ExactSessionTarget	189		ExactTarget *protocol.ExactSessionTarget
190		PreferredTabID domain.TabStableID	190		PreferredTabID domain.TabStableID
191		HostLabel string	191		HostLabel string
192	-	EnvironmentPolicy ports.EnvironmentPolicy	192	+	EnvironmentPolicy protocol.EnvironmentPolicy
193		NavigationCapabilities protocol.NavigationCapabilities	193		NavigationCapabilities protocol.NavigationCapabilities
194		StartupOverlay protocol.StartupOverlay	194		StartupOverlay protocol.StartupOverlay
195		}	195		}

@@ -379,14 +379,14 @@ func validateAttachRequest(request AttachRequest) error {
379		if err := (SessionTarget{Intent: request.Intent, SessionName: request.SessionName}).validate(); err != nil {	379		if err := (SessionTarget{Intent: request.Intent, SessionName: request.SessionName}).validate(); err != nil {
380		return fmt.Errorf("vev: invalid session target: %w", err)	380		return fmt.Errorf("vev: invalid session target: %w", err)
381		}	381		}
382	-	if err := protocol.ValidateNavigation(request.NavigationCapabilities, request.StartupOverlay, request.RemoteTarget != nil \|\| request.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned); err != nil {	382	+	if err := protocol.ValidateNavigation(request.NavigationCapabilities, request.StartupOverlay, request.RemoteTarget != nil \|\| request.EnvironmentPolicy == protocol.EnvironmentPolicyDaemonOwned); err != nil {
383		return fmt.Errorf("vev: invalid navigation route: %w", err)	383		return fmt.Errorf("vev: invalid navigation route: %w", err)
384		}	384		}
385		if request.RemoteTarget == nil {	385		if request.RemoteTarget == nil {
386	-	if request.EnvironmentPolicy == ports.EnvironmentPolicyClientOwned {	386	+	if request.EnvironmentPolicy == protocol.EnvironmentPolicyClientOwned {
387		return nil	387		return nil
388		}	388		}
389	-	if request.Remote && request.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned {	389	+	if request.Remote && request.EnvironmentPolicy == protocol.EnvironmentPolicyDaemonOwned {
390		return nil	390		return nil
391		}	391		}
392		return errors.New("vev: attach without remote target requires a matching environment policy")	392		return errors.New("vev: attach without remote target requires a matching environment policy")

@@ -397,10 +397,10 @@ func validateAttachRequest(request AttachRequest) error {
397		if request.SessionName != request.RemoteTarget.SessionName {	397		if request.SessionName != request.RemoteTarget.SessionName {
398		return errors.New("vev: remote attach target session mismatch")	398		return errors.New("vev: remote attach target session mismatch")
399		}	399		}
400	-	if request.EnvironmentPolicy != ports.EnvironmentPolicyDaemonOwned {	400	+	if request.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
401		return errors.New("vev: remote attach target requires daemon-owned environment")	401		return errors.New("vev: remote attach target requires daemon-owned environment")
402		}	402		}
403	-	if request.Intent != ports.IntentAttach && request.Intent != ports.IntentResume {	403	+	if request.Intent != protocol.IntentAttach && request.Intent != protocol.IntentResume {
404		return errors.New("vev: remote attach target requires attach or resume")	404		return errors.New("vev: remote attach target requires attach or resume")
405		}	405		}
406		return nil	406		return nil

@@ -510,9 +510,9 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
510		dialer = route.dialer	510		dialer = route.dialer
511		attemptRequest = route.request	511		attemptRequest = route.request
512		if route.resumeToken != 0 {	512		if route.resumeToken != 0 {
513	-	attemptRequest.Intent = ports.IntentResume	513	+	attemptRequest.Intent = protocol.IntentResume
514		} else {	514		} else {
515	-	attemptRequest.Intent = ports.IntentAttach	515	+	attemptRequest.Intent = protocol.IntentAttach
516		}	516		}
517		attemptRequest.StartupOverlay = protocol.StartupOverlayNone	517		attemptRequest.StartupOverlay = protocol.StartupOverlayNone
518		attemptRequest.NavigationCapabilities &^= protocol.NavigationCapabilityBack \| protocol.NavigationCapabilityHomePicker	518		attemptRequest.NavigationCapabilities &^= protocol.NavigationCapabilityBack \| protocol.NavigationCapabilityHomePicker

@@ -524,11 +524,11 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
524		enterHomePicker := func() {	524		enterHomePicker := func() {
525		dialer = homeRoute.dialer	525		dialer = homeRoute.dialer
526		attemptRequest = homeRoute.request	526		attemptRequest = homeRoute.request
527	-	attemptRequest.Intent = ports.IntentAttach	527	+	attemptRequest.Intent = protocol.IntentAttach
528		attemptRequest.NavigationCapabilities = protocol.NavigationCapabilityBack	528		attemptRequest.NavigationCapabilities = protocol.NavigationCapabilityBack
529		attemptRequest.StartupOverlay = protocol.StartupOverlaySessionPicker	529		attemptRequest.StartupOverlay = protocol.StartupOverlaySessionPicker
530		attemptRequest.RemoteTarget = nil	530		attemptRequest.RemoteTarget = nil
531	-	attemptRequest.EnvironmentPolicy = ports.EnvironmentPolicyClientOwned	531	+	attemptRequest.EnvironmentPolicy = protocol.EnvironmentPolicyClientOwned
532		attemptRequest.Remote = homeRoute.request.Remote \|\| r.remote	532		attemptRequest.Remote = homeRoute.request.Remote \|\| r.remote
533		resumeToken = 0	533		resumeToken = 0
534		remote = syncReconnectRemote(reconnect, homeRoute.request.Remote \|\| r.remote)	534		remote = syncReconnectRemote(reconnect, homeRoute.request.Remote \|\| r.remote)

@@ -556,11 +556,11 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
556		return attachResult{err: errors.New("vev: home route unavailable")}	556		return attachResult{err: errors.New("vev: home route unavailable")}
557		}	557		}
558		request := cloneAttachRequest(homeRoute.request)	558		request := cloneAttachRequest(homeRoute.request)
559	-	request.Intent = ports.IntentAttach	559	+	request.Intent = protocol.IntentAttach
560		request.NavigationCapabilities = protocol.NavigationCapabilityBack	560		request.NavigationCapabilities = protocol.NavigationCapabilityBack
561		request.StartupOverlay = protocol.StartupOverlaySessionPicker	561		request.StartupOverlay = protocol.StartupOverlaySessionPicker
562		request.RemoteTarget = nil	562		request.RemoteTarget = nil
563	-	request.EnvironmentPolicy = ports.EnvironmentPolicyClientOwned	563	+	request.EnvironmentPolicy = protocol.EnvironmentPolicyClientOwned
564		request.Remote = false	564		request.Remote = false
565		if err := validateAttachRequest(request); err != nil {	565		if err := validateAttachRequest(request); err != nil {
566		return attachResult{err: err}	566		return attachResult{err: err}

@@ -627,7 +627,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
627		return ctx.Err()	627		return ctx.Err()
628		}	628		}
629		backoff = nextReconnectBackoff(backoff, defaultReconnectBackoff.max)	629		backoff = nextReconnectBackoff(backoff, defaultReconnectBackoff.max)
630	-	attemptRequest.Intent = ports.IntentResume	630	+	attemptRequest.Intent = protocol.IntentResume
631		continue	631		continue
632		}	632		}
633		ms.dialed = true	633		ms.dialed = true

@@ -733,9 +733,9 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
733		dialer = selection.selected.dialer	733		dialer = selection.selected.dialer
734		attemptRequest = cloneAttachRequest(selection.selected.request)	734		attemptRequest = cloneAttachRequest(selection.selected.request)
735		if selection.selected.resumeToken != 0 {	735		if selection.selected.resumeToken != 0 {
736	-	attemptRequest.Intent = ports.IntentResume	736	+	attemptRequest.Intent = protocol.IntentResume
737		} else {	737		} else {
738	-	attemptRequest.Intent = ports.IntentAttach	738	+	attemptRequest.Intent = protocol.IntentAttach
739		}	739		}
740		// Back is transient to the picker overlay. Re-derive the home-picker	740		// Back is transient to the picker overlay. Re-derive the home-picker
741		// capability from the selected route instead of trusting request	741		// capability from the selected route instead of trusting request

@@ -795,7 +795,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
795		if result.sessionName != "" {	795		if result.sessionName != "" {
796		routeRequest.SessionName = result.sessionName	796		routeRequest.SessionName = result.sessionName
797		}	797		}
798	-	routeRequest.Intent = ports.IntentAttach	798	+	routeRequest.Intent = protocol.IntentAttach
799		routeRequest.NavigationCapabilities = 0	799		routeRequest.NavigationCapabilities = 0
800		routeRequest.StartupOverlay = protocol.StartupOverlayNone	800		routeRequest.StartupOverlay = protocol.StartupOverlayNone
801		homeRoute = &attachRoute{dialer: dialer, request: routeRequest}	801		homeRoute = &attachRoute{dialer: dialer, request: routeRequest}

@@ -832,7 +832,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
832		if result.target.ExactTarget != nil {	832		if result.target.ExactTarget != nil {
833		nextRequest.ExactTarget = result.target.ExactTarget	833		nextRequest.ExactTarget = result.target.ExactTarget
834		}	834		}
835	-	if homeRoute != nil && (nextRequest.RemoteTarget != nil \|\| nextRequest.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned) {	835	+	if homeRoute != nil && (nextRequest.RemoteTarget != nil \|\| nextRequest.EnvironmentPolicy == protocol.EnvironmentPolicyDaemonOwned) {
836		nextRequest.NavigationCapabilities \|= protocol.NavigationCapabilityHomePicker	836		nextRequest.NavigationCapabilities \|= protocol.NavigationCapabilityHomePicker
837		}	837		}
838		if attemptRequest.StartupOverlay == protocol.StartupOverlaySessionPicker {	838		if attemptRequest.StartupOverlay == protocol.StartupOverlaySessionPicker {

@@ -875,7 +875,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
875		continue	875		continue
876		}	876		}
877		if routeNavigationPending && routeNavigationResumeFallback && resumeNeedsExactAttach(result.err) {	877		if routeNavigationPending && routeNavigationResumeFallback && resumeNeedsExactAttach(result.err) {
878	-	attemptRequest.Intent = ports.IntentAttach	878	+	attemptRequest.Intent = protocol.IntentAttach
879		resumeToken = 0	879		resumeToken = 0
880		routeNavigationResumeFallback = false	880		routeNavigationResumeFallback = false
881		continue	881		continue

@@ -896,7 +896,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
896		continue	896		continue
897		}	897		}
898		if returnResumeFallback && resumeNeedsExactAttach(result.err) {	898		if returnResumeFallback && resumeNeedsExactAttach(result.err) {
899	-	attemptRequest.Intent = ports.IntentAttach	899	+	attemptRequest.Intent = protocol.IntentAttach
900		resumeToken = 0	900		resumeToken = 0
901		returnResumeFallback = false	901		returnResumeFallback = false
902		continue	902		continue

@@ -928,7 +928,7 @@ func (r *Runner) Run(ctx context.Context, request AttachRequest) (retErr error)
928		return ctx.Err()	928		return ctx.Err()
929		}	929		}
930		backoff = nextReconnectBackoff(backoff, defaultReconnectBackoff.max)	930		backoff = nextReconnectBackoff(backoff, defaultReconnectBackoff.max)
931	-	attemptRequest.Intent = ports.IntentResume	931	+	attemptRequest.Intent = protocol.IntentResume
932		}	932		}
933		}	933		}
934			934

@@ -1089,7 +1089,7 @@ type attachResult struct {
1089		routePosition *protocol.RoutePosition	1089		routePosition *protocol.RoutePosition
1090		welcomed bool	1090		welcomed bool
1091		transportClosed bool	1091		transportClosed bool
1092	-	target *ports.AttachTarget	1092	+	target *protocol.AttachTarget
1093		action protocol.NavigationAction	1093		action protocol.NavigationAction
1094		homePickerTarget bool	1094		homePickerTarget bool
1095		routeAction *protocol.RouteNavigationAction	1095		routeAction *protocol.RouteNavigationAction

@@ -1099,7 +1099,7 @@ type attachResult struct {
1099		// AttachTargetError requests that the composition root replace the current	1099		// AttachTargetError requests that the composition root replace the current
1100		// transport with the selected endpoint. The daemon never opens that endpoint.	1100		// transport with the selected endpoint. The daemon never opens that endpoint.
1101		type AttachTargetError struct {	1101		type AttachTargetError struct {
1102	-	Target ports.AttachTarget	1102	+	Target protocol.AttachTarget
1103		}	1103		}
1104			1104
1105		func (e *AttachTargetError) Error() string {	1105		func (e *AttachTargetError) Error() string {

@@ -1219,8 +1219,8 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1219		SessionName: request.RemoteTarget.SessionName,	1219		SessionName: request.RemoteTarget.SessionName,
1220		}	1220		}
1221		}	1221		}
1222	-	hello := ports.Hello{	1222	+	hello := protocol.Hello{
1223	-	Version: ports.ProtocolVersion,	1223	+	Version: protocol.Version,
1224		Intent: intent,	1224		Intent: intent,
1225		ClientID: clientID,	1225		ClientID: clientID,
1226		ResumeToken: resumeToken,	1226		ResumeToken: resumeToken,

@@ -1490,7 +1490,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1490		requestID uint64	1490		requestID uint64
1491		action protocol.ParkedRouteAction	1491		action protocol.ParkedRouteAction
1492		leaseID protocol.ParkedRouteLeaseID	1492		leaseID protocol.ParkedRouteLeaseID
1493	-	fallbackTarget *ports.AttachTarget	1493	+	fallbackTarget *protocol.AttachTarget
1494		timer ports.Timer	1494		timer ports.Timer
1495		}	1495		}
1496		var parkedPending *parkedRoutePending	1496		var parkedPending *parkedRoutePending

@@ -1600,7 +1600,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1600		awaitParkedFull := func() {	1600		awaitParkedFull := func() {
1601		clearParkedFull()	1601		clearParkedFull()
1602		parkedWaitingFull = true	1602		parkedWaitingFull = true
1603	-	parkedFullTimer = clk.NewTimer(ports.HandshakeTimeout)	1603	+	parkedFullTimer = clk.NewTimer(protocol.HandshakeTimeout)
1604		}	1604		}
1605		parkedFullC := func() <-chan time.Time {	1605		parkedFullC := func() <-chan time.Time {
1606		if parkedFullTimer == nil {	1606		if parkedFullTimer == nil {

@@ -1654,7 +1654,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1654		case controlCh <- ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: payload}:	1654		case controlCh <- ports.Frame{Type: ports.MsgParkedRouteRequest, Payload: payload}:
1655		parkedPending = &parkedRoutePending{	1655		parkedPending = &parkedRoutePending{
1656		requestID: request.RequestID, action: action, leaseID: leaseID,	1656		requestID: request.RequestID, action: action, leaseID: leaseID,
1657	-	timer: clk.NewTimer(ports.HandshakeTimeout),	1657	+	timer: clk.NewTimer(protocol.HandshakeTimeout),
1658		}	1658		}
1659		return nil	1659		return nil
1660		case <-loopCtx.Done():	1660		case <-loopCtx.Done():

@@ -1827,7 +1827,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1827		return welcomedResult(fmt.Errorf("dismissing reconnect toast: %w", err))	1827		return welcomedResult(fmt.Errorf("dismissing reconnect toast: %w", err))
1828		}	1828		}
1829		select {	1829		select {
1830	-	case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(ports.ClientNotice{Action: ports.ClientNoticeLinkConnected})}:	1830	+	case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkConnected})}:
1831		case <-loopCtx.Done():	1831		case <-loopCtx.Done():
1832		return welcomedResult(nil)	1832		return welcomedResult(nil)
1833		}	1833		}

@@ -1836,7 +1836,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1836		if ev.State == ports.LinkStateDegraded {	1836		if ev.State == ports.LinkStateDegraded {
1837		log.Warn("UDP link degraded")	1837		log.Warn("UDP link degraded")
1838		select {	1838		select {
1839	-	case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(ports.ClientNotice{Action: ports.ClientNoticeLinkDegraded})}:	1839	+	case sendCh <- ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: protocol.ClientNoticeLinkDegraded})}:
1840		case <-loopCtx.Done():	1840		case <-loopCtx.Done():
1841		return welcomedResult(nil)	1841		return welcomedResult(nil)
1842		}	1842		}

@@ -1896,7 +1896,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
1896		// repeated gaps while that reset is in flight.	1896		// repeated gaps while that reset is in flight.
1897		if !outputResetRequested {	1897		if !outputResetRequested {
1898		select {	1898		select {
1899	-	case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}:	1899	+	case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
1900		outputResetRequested = true	1900		outputResetRequested = true
1901		case <-loopCtx.Done():	1901		case <-loopCtx.Done():
1902		return loopCanceledResult()	1902		return loopCanceledResult()

@@ -2111,7 +2111,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
2111		transitionWaitingFull = true	2111		transitionWaitingFull = true
2112		if !outputResetRequested {	2112		if !outputResetRequested {
2113		select {	2113		select {
2114	-	case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}:	2114	+	case sendCh <- ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}:
2115		outputResetRequested = true	2115		outputResetRequested = true
2116		case <-loopCtx.Done():	2116		case <-loopCtx.Done():
2117		return loopCanceledResult()	2117		return loopCanceledResult()

@@ -2145,7 +2145,7 @@ func (a *attachAttempt) run(ctx context.Context) attachResult {
2145		return welcomedResult(fmt.Errorf("vev: decoding detached: %w", derr))	2145		return welcomedResult(fmt.Errorf("vev: decoding detached: %w", derr))
2146		}	2146		}
2147		ms.detached = true	2147		ms.detached = true
2148	-	if d.Reason == ports.ReasonDetach {	2148	+	if d.Reason == protocol.ReasonDetach {
2149		log.Info("detached cleanly", "reason", d.Reason)	2149		log.Info("detached cleanly", "reason", d.Reason)
2150		} else {	2150		} else {
2151		log.Warn("detached by daemon", "reason", d.Reason)	2151		log.Warn("detached by daemon", "reason", d.Reason)

@@ -2785,7 +2785,7 @@ func (p *stdinPump) run() {
2785		return	2785		return
2786		}	2786		}
2787		inputSeq++	2787		inputSeq++
2788	-	if !send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{InputSeq: inputSeq, Data: append([]byte(nil), data...)})}) {	2788	+	if !send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{InputSeq: inputSeq, Data: append([]byte(nil), data...)})}) {
2789		undeliveredMu.Lock()	2789		undeliveredMu.Lock()
2790		undelivered = append(undelivered, data...)	2790		undelivered = append(undelivered, data...)
2791		undeliveredMu.Unlock()	2791		undeliveredMu.Unlock()

@@ -2799,7 +2799,7 @@ func (p *stdinPump) run() {
2799		reader: p.clipboard,	2799		reader: p.clipboard,
2800		log: p.logger,	2800		log: p.logger,
2801		sendNotice: func(action uint8) {	2801		sendNotice: func(action uint8) {
2802	-	send(ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(ports.ClientNotice{Action: action})})	2802	+	send(ports.Frame{Type: ports.MsgClientNotice, Payload: ports.MarshalClientNotice(protocol.ClientNotice{Action: action})})
2803		},	2803		},
2804		sendImage: func(mime string, data []byte) {	2804		sendImage: func(mime string, data []byte) {
2805		inputSeq++	2805		inputSeq++

@@ -2945,7 +2945,7 @@ func (p *stdinPump) run() {
2945		disarmMarkerDeadline()	2945		disarmMarkerDeadline()
2946		markers.flush(sink)	2946		markers.flush(sink)
2947		select {	2947		select {
2948	-	case p.out <- ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})}:	2948	+	case p.out <- ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}:
2949		case <-p.ctx.Done():	2949		case <-p.ctx.Done():
2950		}	2950		}
2951		p.cancel()	2951		p.cancel()

@@ -3002,13 +3002,13 @@ func runResize(ctx context.Context, events <-chan domain.Geometry, out chan<- po
3002		// the user learns why the session went away.	3002		// the user learns why the session went away.
3003		func detachedResult(reason uint8) error {	3003		func detachedResult(reason uint8) error {
3004		switch reason {	3004		switch reason {
3005	-	case ports.ReasonDetach:	3005	+	case protocol.ReasonDetach:
3006		return nil	3006		return nil
3007	-	case ports.ReasonSessionKilled:	3007	+	case protocol.ReasonSessionKilled:
3008		return &DetachedError{Reason: reason, Text: "session was killed"}	3008		return &DetachedError{Reason: reason, Text: "session was killed"}
3009	-	case ports.ReasonServerShutdown:	3009	+	case protocol.ReasonServerShutdown:
3010		return &DetachedError{Reason: reason, Text: "daemon shut down"}	3010		return &DetachedError{Reason: reason, Text: "daemon shut down"}
3011	-	case ports.ReasonReplaced:	3011	+	case protocol.ReasonReplaced:
3012		return &DetachedError{Reason: reason, Text: "session taken over by another client"}	3012		return &DetachedError{Reason: reason, Text: "session taken over by another client"}
3013		default:	3013		default:
3014		return &DetachedError{Reason: reason, Text: "detached by daemon"}	3014		return &DetachedError{Reason: reason, Text: "detached by daemon"}

M internal/usecase/client/client_test.go +153 -153


@@ -265,7 +265,7 @@ func attachTestDependencies(transport ports.Transport, terminal ports.Terminal,
265		return testDependencies(transportDialer{transport: transport}, terminal, clock, nil, nil)	265		return testDependencies(transportDialer{transport: transport}, terminal, clock, nil, nil)
266		}	266		}
267			267
268	-	const testPreWelcomeTimeout = ports.HandshakeTimeout	268	+	const testPreWelcomeTimeout = protocol.HandshakeTimeout
269			269
270		func newHandshakeClock(t testing.T, timerCount int) (portsmocks.MockClock, <-chan chan time.Time) {	270		func newHandshakeClock(t testing.T, timerCount int) (portsmocks.MockClock, <-chan chan time.Time) {
271		t.Helper()	271		t.Helper()

@@ -294,7 +294,7 @@ func TestRunBoundsBlockedDial(t *testing.T) {
294			294
295		errCh := make(chan error, 1)	295		errCh := make(chan error, 1)
296		go func() {	296		go func() {
297	-	errCh <- runTestClient(context.Background(), testDependencies(dialer, nil, clk, nil, nil), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main"})	297	+	errCh <- runTestClient(context.Background(), testDependencies(dialer, nil, clk, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main"})
298		}()	298		}()
299		timerC := <-createdTimers	299		timerC := <-createdTimers
300		<-started	300		<-started

@@ -353,7 +353,7 @@ func TestRunBoundsPreWelcomeOperations(t *testing.T) {
353			353
354		errCh := make(chan error, 1)	354		errCh := make(chan error, 1)
355		go func() {	355		go func() {
356	-	errCh <- runTestClient(ctx, testDependencies(dialer, term, clk, nil, nil), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: false})	356	+	errCh <- runTestClient(ctx, testDependencies(dialer, term, clk, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: false})
357		}()	357		}()
358			358
359		var timerC chan time.Time	359		var timerC chan time.Time

@@ -399,7 +399,7 @@ func TestAttachHelloIncludesTrueColor(t *testing.T) {
399		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)	399		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)
400		defer in.unblock()	400		defer in.unblock()
401			401
402	-	gotHello := make(chan ports.Hello, 1)	402	+	gotHello := make(chan protocol.Hello, 1)
403		tr := portsmocks.NewMockTransport(t)	403		tr := portsmocks.NewMockTransport(t)
404		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	404		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
405		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	405		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()

@@ -410,13 +410,13 @@ func TestAttachHelloIncludesTrueColor(t *testing.T) {
410		return nil	410		return nil
411		}).Once()	411		}).Once()
412		unblock := scriptRecv(tr,	412		unblock := scriptRecv(tr,
413	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	413	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
414	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	414	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
415		)	415		)
416		defer unblock()	416		defer unblock()
417		tr.EXPECT().Close().Return(nil).Once()	417		tr.EXPECT().Close().Return(nil).Once()
418			418
419	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	419	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
420		require.NoError(t, err)	420		require.NoError(t, err)
421			421
422		select {	422		select {

@@ -434,18 +434,18 @@ func TestAttachPublishesCommittedRouteSnapshot(t *testing.T) {
434		defer term.in.unblock()	434		defer term.in.unblock()
435		lifecycle := domain.SessionLifecycleID{9, 8, 7}	435		lifecycle := domain.SessionLifecycleID{9, 8, 7}
436		tr := &recordingTransport{recvs: []recvItem{	436		tr := &recordingTransport{recvs: []recvItem{
437	-	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	437	+	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
438		SessionID: "s1",	438		SessionID: "s1",
439		SessionName: "main",	439		SessionName: "main",
440		CommittedIdentity: &protocol.CommittedRouteIdentity{	440		CommittedIdentity: &protocol.CommittedRouteIdentity{
441		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "main"},	441		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "main"},
442		},	442		},
443		}))},	443		}))},
444	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	444	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
445		}}	445		}}
446			446
447		err := runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), client.AttachRequest{	447		err := runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), client.AttachRequest{
448	-	Intent: ports.IntentAttach,	448	+	Intent: protocol.IntentAttach,
449		SessionName: "main",	449		SessionName: "main",
450		Origin: protocol.RouteOriginLocal,	450		Origin: protocol.RouteOriginLocal,
451		OriginKey: "local",	451		OriginKey: "local",

@@ -485,8 +485,8 @@ func TestLocalOnlyHandoffBetweenLocalSessionsKeepsClientRunning(t *testing.T) {
485		firstLifecycle := domain.SessionLifecycleID{1}	485		firstLifecycle := domain.SessionLifecycleID{1}
486		secondLifecycle := domain.SessionLifecycleID{2}	486		secondLifecycle := domain.SessionLifecycleID{2}
487		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {	487		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
488	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	488	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
489	-	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,	489	+	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
490		CommittedIdentity: &protocol.CommittedRouteIdentity{	490		CommittedIdentity: &protocol.CommittedRouteIdentity{
491		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},	491		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
492		},	492		},

@@ -495,19 +495,19 @@ func TestLocalOnlyHandoffBetweenLocalSessionsKeepsClientRunning(t *testing.T) {
495		secondTarget := protocol.ExactSessionTarget{LifecycleID: secondLifecycle, SessionName: "second"}	495		secondTarget := protocol.ExactSessionTarget{LifecycleID: secondLifecycle, SessionName: "second"}
496		first := &recordingTransport{recvs: []recvItem{	496		first := &recordingTransport{recvs: []recvItem{
497		{f: welcome("first", firstLifecycle)},	497		{f: welcome("first", firstLifecycle)},
498	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	498	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
499	-	Session: "second", Intent: ports.IntentAttach, ExactTarget: &secondTarget,	499	+	Session: "second", Intent: protocol.IntentAttach, ExactTarget: &secondTarget,
500	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned, SamePeer: true,	500	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned, SamePeer: true,
501		}))},	501		}))},
502		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: secondTarget}))},	502		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: secondTarget}))},
503	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	503	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
504		}}	504		}}
505		dialer := &sequenceDialer{trs: []ports.Transport{first}}	505		dialer := &sequenceDialer{trs: []ports.Transport{first}}
506			506
507		err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{	507		err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{
508	-	Intent: ports.IntentAttach, SessionName: "first",	508	+	Intent: protocol.IntentAttach, SessionName: "first",
509		Origin: protocol.RouteOriginLocal, OriginKey: "local",	509		Origin: protocol.RouteOriginLocal, OriginKey: "local",
510	-	EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	510	+	EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
511		})	511		})
512			512
513		require.NoError(t, err)	513		require.NoError(t, err)

@@ -523,14 +523,14 @@ func TestAttachHelloPreservesCompleteAttachRequest(t *testing.T) {
523		SessionName: "work", LiveTabID: "tab-1",	523		SessionName: "work", LiveTabID: "tab-1",
524		}	524		}
525		request := client.AttachRequest{	525		request := client.AttachRequest{
526	-	Intent: ports.IntentAttach, SessionName: "work", Remote: true,	526	+	Intent: protocol.IntentAttach, SessionName: "work", Remote: true,
527	-	RemoteTarget: target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	527	+	RemoteTarget: target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
528		NavigationCapabilities: protocol.NavigationCapabilityHomePicker,	528		NavigationCapabilities: protocol.NavigationCapabilityHomePicker,
529		StartupOverlay: protocol.StartupOverlayNone,	529		StartupOverlay: protocol.StartupOverlayNone,
530		}	530		}
531		tr := &recordingTransport{recvs: []recvItem{	531		tr := &recordingTransport{recvs: []recvItem{
532		{f: welcomeFrame(0)},	532		{f: welcomeFrame(0)},
533	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	533	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
534		}}	534		}}
535			535
536		require.NoError(t, runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), request))	536		require.NoError(t, runTestClient(context.Background(), attachTestDependencies(tr, term, realClock{}), request))

@@ -551,8 +551,8 @@ func TestStoppedLocalHandoffDialsReplacementTransport(t *testing.T) {
551		targetLifecycle := domain.SessionLifecycleID{2}	551		targetLifecycle := domain.SessionLifecycleID{2}
552		target := protocol.ExactSessionTarget{LifecycleID: targetLifecycle, SessionName: "stopped"}	552		target := protocol.ExactSessionTarget{LifecycleID: targetLifecycle, SessionName: "stopped"}
553		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {	553		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
554	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	554	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
555	-	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,	555	+	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
556		CommittedIdentity: &protocol.CommittedRouteIdentity{	556		CommittedIdentity: &protocol.CommittedRouteIdentity{
557		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},	557		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
558		},	558		},

@@ -560,21 +560,21 @@ func TestStoppedLocalHandoffDialsReplacementTransport(t *testing.T) {
560		}	560		}
561		first := &recordingTransport{recvs: []recvItem{	561		first := &recordingTransport{recvs: []recvItem{
562		{f: welcome("source", sourceLifecycle)},	562		{f: welcome("source", sourceLifecycle)},
563	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	563	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
564	-	Session: "stopped", Intent: ports.IntentAttach, ExactTarget: &target,	564	+	Session: "stopped", Intent: protocol.IntentAttach, ExactTarget: &target,
565	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	565	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
566		}))},	566		}))},
567		}}	567		}}
568		second := &recordingTransport{recvs: []recvItem{	568		second := &recordingTransport{recvs: []recvItem{
569		{f: welcome("stopped", targetLifecycle)},	569		{f: welcome("stopped", targetLifecycle)},
570	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	570	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
571		}}	571		}}
572		dialer := &sequenceDialer{trs: []ports.Transport{first, second}}	572		dialer := &sequenceDialer{trs: []ports.Transport{first, second}}
573			573
574		err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{	574		err := runTestClient(context.Background(), testDependencies(dialer, term, realClock{}, nil, nil), client.AttachRequest{
575	-	Intent: ports.IntentAttach, SessionName: "source",	575	+	Intent: protocol.IntentAttach, SessionName: "source",
576		Origin: protocol.RouteOriginLocal, OriginKey: "local",	576		Origin: protocol.RouteOriginLocal, OriginKey: "local",
577	-	EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	577	+	EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
578		})	578		})
579			579
580		require.NoError(t, err)	580		require.NoError(t, err)

@@ -588,8 +588,8 @@ func TestAcceptedHomeActionUsesCapturedRouteAfterRequestMetadataRebase(t *testin
588		localLifecycle := domain.SessionLifecycleID{1}	588		localLifecycle := domain.SessionLifecycleID{1}
589		remoteLifecycle := domain.SessionLifecycleID{2}	589		remoteLifecycle := domain.SessionLifecycleID{2}
590		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {	590		welcome := func(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
591	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	591	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
592	-	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,	592	+	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
593		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},	593		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
594		}))	594		}))
595		}	595		}

@@ -599,9 +599,9 @@ func TestAcceptedHomeActionUsesCapturedRouteAfterRequestMetadataRebase(t *testin
599		}	599		}
600		local1 := &recordingTransport{recvs: []recvItem{	600		local1 := &recordingTransport{recvs: []recvItem{
601		{f: welcome("local", localLifecycle)},	601		{f: welcome("local", localLifecycle)},
602	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	602	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
603	-	Endpoint: "remote", Session: "work", Intent: ports.IntentAttach,	603	+	Endpoint: "remote", Session: "work", Intent: protocol.IntentAttach,
604	-	RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	604	+	RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
605		}))},	605		}))},
606		}}	606		}}
607		remote := &recordingTransport{recvs: []recvItem{	607		remote := &recordingTransport{recvs: []recvItem{

@@ -610,31 +610,31 @@ func TestAcceptedHomeActionUsesCapturedRouteAfterRequestMetadataRebase(t *testin
610		}}	610		}}
611		local2 := &recordingTransport{recvs: []recvItem{	611		local2 := &recordingTransport{recvs: []recvItem{
612		{f: welcome("local", localLifecycle)},	612		{f: welcome("local", localLifecycle)},
613	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	613	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
614		}}	614		}}
615		localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2}}	615		localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2}}
616		remoteDialer := &sequenceDialer{trs: []ports.Transport{remote}}	616		remoteDialer := &sequenceDialer{trs: []ports.Transport{remote}}
617		deps := testDependencies(localDialer, term, realClock{}, nil, nil)	617		deps := testDependencies(localDialer, term, realClock{}, nil, nil)
618	-	deps.AttachHandoff = func(ports.AttachTarget) (ports.Dialer, client.AttachRequest, error) {	618	+	deps.AttachHandoff = func(protocol.AttachTarget) (ports.Dialer, client.AttachRequest, error) {
619		target := protocol.ExactSessionTarget{LifecycleID: remoteLifecycle, SessionName: "work"}	619		target := protocol.ExactSessionTarget{LifecycleID: remoteLifecycle, SessionName: "work"}
620		return remoteDialer, client.AttachRequest{	620		return remoteDialer, client.AttachRequest{
621	-	Intent: ports.IntentAttach, SessionName: "work", Remote: true,	621	+	Intent: protocol.IntentAttach, SessionName: "work", Remote: true,
622		Origin: protocol.RouteOriginRemote, OriginKey: "remote", ExactTarget: &target,	622		Origin: protocol.RouteOriginRemote, OriginKey: "remote", ExactTarget: &target,
623	-	EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	623	+	EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
624		// Deliberately omit the copied Home capability. The accepted server	624		// Deliberately omit the copied Home capability. The accepted server
625		// action remains valid because Runner retained the concrete home route.	625		// action remains valid because Runner retained the concrete home route.
626		}, nil	626		}, nil
627		}	627		}
628			628
629		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{	629		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
630	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	630	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
631		}))	631		}))
632		require.Equal(t, protocol.StartupOverlaySessionPicker, helloFromSend(t, local2).StartupOverlay)	632		require.Equal(t, protocol.StartupOverlaySessionPicker, helloFromSend(t, local2).StartupOverlay)
633		}	633		}
634			634
635		func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) ports.Frame {	635		func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) ports.Frame {
636	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	636	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
637	-	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: ports.CapabilityResume,	637	+	SessionID: name, SessionName: name, ResumeToken: 1, Capabilities: protocol.CapabilityResume,
638		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},	638		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name}},
639		}))	639		}))
640		}	640		}

@@ -642,16 +642,16 @@ func hybridWelcomeFrame(name string, lifecycle domain.SessionLifecycleID) ports.
642		func hybridLocalBootstrap(lifecycle domain.SessionLifecycleID, target domain.RemoteSessionTarget) *recordingTransport {	642		func hybridLocalBootstrap(lifecycle domain.SessionLifecycleID, target domain.RemoteSessionTarget) *recordingTransport {
643		return &recordingTransport{recvs: []recvItem{	643		return &recordingTransport{recvs: []recvItem{
644		{f: hybridWelcomeFrame("local", lifecycle)},	644		{f: hybridWelcomeFrame("local", lifecycle)},
645	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	645	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
646	-	Endpoint: target.Endpoint, Session: target.SessionName, Intent: ports.IntentAttach,	646	+	Endpoint: target.Endpoint, Session: target.SessionName, Intent: protocol.IntentAttach,
647	-	RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	647	+	RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
648		}))},	648		}))},
649		}}	649		}}
650		}	650		}
651			651
652		func hybridPickerDependencies(localDialer ports.Dialer, term ports.Terminal, clock ports.Clock, remoteByEndpoint map[string]ports.Dialer) client.Dependencies {	652		func hybridPickerDependencies(localDialer ports.Dialer, term ports.Terminal, clock ports.Clock, remoteByEndpoint map[string]ports.Dialer) client.Dependencies {
653		deps := testDependencies(localDialer, term, clock, nil, nil)	653		deps := testDependencies(localDialer, term, clock, nil, nil)
654	-	deps.AttachHandoff = func(target ports.AttachTarget) (ports.Dialer, client.AttachRequest, error) {	654	+	deps.AttachHandoff = func(target protocol.AttachTarget) (ports.Dialer, client.AttachRequest, error) {
655		if target.RemoteTarget == nil {	655		if target.RemoteTarget == nil {
656		return nil, client.AttachRequest{}, errors.New("hybrid picker target is not remote")	656		return nil, client.AttachRequest{}, errors.New("hybrid picker target is not remote")
657		}	657		}

@@ -661,9 +661,9 @@ func hybridPickerDependencies(localDialer ports.Dialer, term ports.Terminal, clo
661		}	661		}
662		selection := *target.RemoteTarget	662		selection := *target.RemoteTarget
663		return dialer, client.AttachRequest{	663		return dialer, client.AttachRequest{
664	-	Intent: ports.IntentAttach, SessionName: target.Session, Remote: true,	664	+	Intent: protocol.IntentAttach, SessionName: target.Session, Remote: true,
665		Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,	665		Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,
666	-	RemoteTarget: &selection, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	666	+	RemoteTarget: &selection, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
667		}, nil	667		}, nil
668		}	668		}
669		return deps	669		return deps

@@ -721,7 +721,7 @@ func TestHybridPickerSameHostSwitchReusesRemoteTransport(t *testing.T) {
721		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},	721		{f: frameOf(ports.MsgCommittedRouteIdentity, mustMarshalCommittedIdentity(protocol.CommittedRouteIdentity{Target: protocol.ExactSessionTarget{LifecycleID: remoteTargetLifecycle, SessionName: "target"}})), wait: switchSent},
722		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}))},	722		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteSwitched}))},
723		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 2, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("target frame")}))},	723		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 2, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("target frame")}))},
724	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	724	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
725		}}	725		}}
726		remote.onSend = hybridParkedRequestHandler(parkedRequests, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{	726		remote.onSend = hybridParkedRequestHandler(parkedRequests, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
727		protocol.ParkedRoutePrepare: parkSent,	727		protocol.ParkedRoutePrepare: parkSent,

@@ -729,9 +729,9 @@ func TestHybridPickerSameHostSwitchReusesRemoteTransport(t *testing.T) {
729		})	729		})
730		localPicker := &recordingTransport{recvs: []recvItem{	730		localPicker := &recordingTransport{recvs: []recvItem{
731		{f: hybridWelcomeFrame("local", localLifecycle)},	731		{f: hybridWelcomeFrame("local", localLifecycle)},
732	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	732	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
733	-	Endpoint: "remote", Session: "target", Intent: ports.IntentAttach,	733	+	Endpoint: "remote", Session: "target", Intent: protocol.IntentAttach,
734	-	RemoteTarget: &targetTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	734	+	RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
735		}))},	735		}))},
736		}}	736		}}
737		var resizeOnce sync.Once	737		var resizeOnce sync.Once

@@ -745,7 +745,7 @@ func TestHybridPickerSameHostSwitchReusesRemoteTransport(t *testing.T) {
745		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})	745		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
746			746
747		err := runTestClient(context.Background(), deps, client.AttachRequest{	747		err := runTestClient(context.Background(), deps, client.AttachRequest{
748	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	748	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
749		})	749		})
750			750
751		require.NoError(t, err)	751		require.NoError(t, err)

@@ -812,14 +812,14 @@ func TestHybridPickerExpiredSwitchFallsBackToNewDial(t *testing.T) {
812		})	812		})
813		localPicker := &recordingTransport{recvs: []recvItem{	813		localPicker := &recordingTransport{recvs: []recvItem{
814		{f: hybridWelcomeFrame("local", localLifecycle)},	814		{f: hybridWelcomeFrame("local", localLifecycle)},
815	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	815	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
816	-	Endpoint: "remote", Session: "target", Intent: ports.IntentAttach,	816	+	Endpoint: "remote", Session: "target", Intent: protocol.IntentAttach,
817	-	RemoteTarget: &targetTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	817	+	RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
818		}))},	818		}))},
819		}}	819		}}
820		targetRemote := &recordingTransport{recvs: []recvItem{	820		targetRemote := &recordingTransport{recvs: []recvItem{
821		{f: hybridWelcomeFrame("target", targetLifecycle)},	821		{f: hybridWelcomeFrame("target", targetLifecycle)},
822	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	822	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
823		}}	823		}}
824		localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}	824		localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}
825		remoteDialer := &sequenceDialer{trs: []ports.Transport{	825		remoteDialer := &sequenceDialer{trs: []ports.Transport{

@@ -828,7 +828,7 @@ func TestHybridPickerExpiredSwitchFallsBackToNewDial(t *testing.T) {
828		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})	828		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
829			829
830		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{	830		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
831	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	831	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
832		}))	832		}))
833		select {	833		select {
834		case requestErr := <-parkedRequestErrors:	834		case requestErr := <-parkedRequestErrors:

@@ -855,7 +855,7 @@ func TestHybridPickerPrepareResponseTimeoutClosesRetainedTransport(t *testing.T)
855		ch := make(chan time.Time, 1)	855		ch := make(chan time.Time, 1)
856		timer.EXPECT().C().Return(ch).Maybe()	856		timer.EXPECT().C().Return(ch).Maybe()
857		timer.EXPECT().Reset(mock.Anything).Return(true).Maybe()	857		timer.EXPECT().Reset(mock.Anything).Return(true).Maybe()
858	-	if duration == ports.HandshakeTimeout {	858	+	if duration == protocol.HandshakeTimeout {
859		record := &deadlineTimer{ch: ch}	859		record := &deadlineTimer{ch: ch}
860		timer.EXPECT().Stop().Run(func() { record.stopped.Store(true) }).Return(true).Maybe()	860		timer.EXPECT().Stop().Run(func() { record.stopped.Store(true) }).Return(true).Maybe()
861		deadlineMu.Lock()	861		deadlineMu.Lock()

@@ -900,7 +900,7 @@ func TestHybridPickerPrepareResponseTimeoutClosesRetainedTransport(t *testing.T)
900		result := make(chan error, 1)	900		result := make(chan error, 1)
901		go func() {	901		go func() {
902		result <- runTestClient(ctx, deps, client.AttachRequest{	902		result <- runTestClient(ctx, deps, client.AttachRequest{
903	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	903	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
904		})	904		})
905		}()	905		}()
906		select {	906		select {

@@ -954,7 +954,7 @@ func TestHybridPickerBackResumesRetainedRemoteTransport(t *testing.T) {
954		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},	954		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 1, Status: protocol.ParkedRouteReady})), wait: parkSent},
955		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed})), wait: resumeSent},	955		{f: frameOf(ports.MsgParkedRouteResponse, ports.MarshalParkedRouteResponse(protocol.ParkedRouteResponse{RequestID: 2, Status: protocol.ParkedRouteResumed})), wait: resumeSent},
956		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("source frame")}))},	956		{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, New: 1, Size: domain.Size{Cols: 80, Rows: 24}, Full: true, Data: []byte("source frame")}))},
957	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	957	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
958		}}	958		}}
959		remote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{	959		remote.onSend = hybridParkedRequestHandler(nil, parkedRequestErrors, map[protocol.ParkedRouteAction]chan struct{}{
960		protocol.ParkedRoutePrepare: parkSent,	960		protocol.ParkedRoutePrepare: parkSent,

@@ -969,7 +969,7 @@ func TestHybridPickerBackResumesRetainedRemoteTransport(t *testing.T) {
969		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})	969		deps := hybridPickerDependencies(localDialer, term, realClock{}, map[string]ports.Dialer{"remote": remoteDialer})
970			970
971		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{	971		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
972	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	972	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
973		}))	973		}))
974		select {	974		select {
975		case requestErr := <-parkedRequestErrors:	975		case requestErr := <-parkedRequestErrors:

@@ -1010,14 +1010,14 @@ func TestHybridPickerDifferentHostFallsBackToNewRemoteDial(t *testing.T) {
1010		})	1010		})
1011		localPicker := &recordingTransport{recvs: []recvItem{	1011		localPicker := &recordingTransport{recvs: []recvItem{
1012		{f: hybridWelcomeFrame("local", localLifecycle)},	1012		{f: hybridWelcomeFrame("local", localLifecycle)},
1013	-	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(ports.AttachTarget{	1013	+	{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(protocol.AttachTarget{
1014	-	Endpoint: targetTarget.Endpoint, Session: targetTarget.SessionName, Intent: ports.IntentAttach,	1014	+	Endpoint: targetTarget.Endpoint, Session: targetTarget.SessionName, Intent: protocol.IntentAttach,
1015	-	RemoteTarget: &targetTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	1015	+	RemoteTarget: &targetTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
1016		}))},	1016		}))},
1017		}}	1017		}}
1018		targetRemote := &recordingTransport{recvs: []recvItem{	1018		targetRemote := &recordingTransport{recvs: []recvItem{
1019		{f: hybridWelcomeFrame("target", targetLifecycle)},	1019		{f: hybridWelcomeFrame("target", targetLifecycle)},
1020	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1020	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1021		}}	1021		}}
1022		localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}	1022		localDialer := &sequenceDialer{trs: []ports.Transport{localInitial, localPicker}}
1023		sourceDialer := &sequenceDialer{trs: []ports.Transport{markedDatagramTransport{Transport: sourceRemote}}}	1023		sourceDialer := &sequenceDialer{trs: []ports.Transport{markedDatagramTransport{Transport: sourceRemote}}}

@@ -1028,7 +1028,7 @@ func TestHybridPickerDifferentHostFallsBackToNewRemoteDial(t *testing.T) {
1028		})	1028		})
1029			1029
1030		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{	1030		require.NoError(t, runTestClient(context.Background(), deps, client.AttachRequest{
1031	-	Intent: ports.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",	1031	+	Intent: protocol.IntentAttach, SessionName: "local", Origin: protocol.RouteOriginLocal, OriginKey: "local",
1032		}))	1032		}))
1033		select {	1033		select {
1034		case requestErr := <-parkedRequestErrors:	1034		case requestErr := <-parkedRequestErrors:

@@ -1049,11 +1049,11 @@ func TestRouteNavigationPreservesRemoteHomePickerAcrossLocalReturn(t *testing.T)
1049		newLifecycle := domain.SessionLifecycleID{3, 3, 3}	1049		newLifecycle := domain.SessionLifecycleID{3, 3, 3}
1050		remoteNewLifecycle := domain.SessionLifecycleID{4, 4, 4}	1050		remoteNewLifecycle := domain.SessionLifecycleID{4, 4, 4}
1051		welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {	1051		welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {
1052	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	1052	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
1053		SessionID: name + "-id",	1053		SessionID: name + "-id",
1054		SessionName: name,	1054		SessionName: name,
1055		ResumeToken: token,	1055		ResumeToken: token,
1056	-	Capabilities: ports.CapabilityResume,	1056	+	Capabilities: protocol.CapabilityResume,
1057		CommittedIdentity: &protocol.CommittedRouteIdentity{	1057		CommittedIdentity: &protocol.CommittedRouteIdentity{
1058		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},	1058		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
1059		},	1059		},

@@ -1066,9 +1066,9 @@ func TestRouteNavigationPreservesRemoteHomePickerAcrossLocalReturn(t *testing.T)
1066		SessionName: "remote-manual",	1066		SessionName: "remote-manual",
1067		LiveTabID: "tab-1",	1067		LiveTabID: "tab-1",
1068		}	1068		}
1069	-	remoteHandoff := ports.AttachTarget{	1069	+	remoteHandoff := protocol.AttachTarget{
1070	-	Endpoint: "remote", Session: "remote-manual", Intent: ports.IntentAttach,	1070	+	Endpoint: "remote", Session: "remote-manual", Intent: protocol.IntentAttach,
1071	-	RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	1071	+	RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
1072		}	1072		}
1073			1073
1074		local1 := &recordingTransport{recvs: []recvItem{	1074		local1 := &recordingTransport{recvs: []recvItem{

@@ -1102,23 +1102,23 @@ func TestRouteNavigationPreservesRemoteHomePickerAcrossLocalReturn(t *testing.T)
1102		}}	1102		}}
1103		remote3 := &recordingTransport{recvs: []recvItem{	1103		remote3 := &recordingTransport{recvs: []recvItem{
1104		{f: welcome("remote-new", remoteNewLifecycle, 22)},	1104		{f: welcome("remote-new", remoteNewLifecycle, 22)},
1105	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1105	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1106		}}	1106		}}
1107		localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2, local3}}	1107		localDialer := &sequenceDialer{trs: []ports.Transport{local1, local2, local3}}
1108		remoteDialer := &sequenceDialer{trs: []ports.Transport{remote1, remote2, remote3}}	1108		remoteDialer := &sequenceDialer{trs: []ports.Transport{remote1, remote2, remote3}}
1109			1109
1110		deps := testDependencies(localDialer, term, realClock{}, nil, nil)	1110		deps := testDependencies(localDialer, term, realClock{}, nil, nil)
1111	-	deps.AttachHandoff = func(target ports.AttachTarget) (ports.Dialer, client.AttachRequest, error) {	1111	+	deps.AttachHandoff = func(target protocol.AttachTarget) (ports.Dialer, client.AttachRequest, error) {
1112		require.Equal(t, remoteHandoff, target)	1112		require.Equal(t, remoteHandoff, target)
1113		return remoteDialer, client.AttachRequest{	1113		return remoteDialer, client.AttachRequest{
1114	-	Intent: ports.IntentAttach, SessionName: target.Session, Remote: true,	1114	+	Intent: protocol.IntentAttach, SessionName: target.Session, Remote: true,
1115		Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,	1115		Origin: protocol.RouteOriginDiscovery, OriginKey: target.Endpoint,
1116	-	RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	1116	+	RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
1117		}, nil	1117		}, nil
1118		}	1118		}
1119			1119
1120		err := runTestClient(context.Background(), deps, client.AttachRequest{	1120		err := runTestClient(context.Background(), deps, client.AttachRequest{
1121	-	Intent: ports.IntentAttach, SessionName: "test", Origin: protocol.RouteOriginLocal, OriginKey: "local",	1121	+	Intent: protocol.IntentAttach, SessionName: "test", Origin: protocol.RouteOriginLocal, OriginKey: "local",
1122		})	1122		})
1123		remoteHello := helloFromSend(t, remote2)	1123		remoteHello := helloFromSend(t, remote2)
1124		require.NoError(t, err)	1124		require.NoError(t, err)

@@ -1168,18 +1168,18 @@ func TestAttachTargetHandoffReturnsValidatedTargetAndClosesTransport(t *testing.
1168		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)	1168		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)
1169		defer in.unblock()	1169		defer in.unblock()
1170			1170
1171	-	target := ports.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: ports.IntentAttach}	1171	+	target := protocol.AttachTarget{Endpoint: "remote.example", Session: "work", Intent: protocol.IntentAttach}
1172		tr := portsmocks.NewMockTransport(t)	1172		tr := portsmocks.NewMockTransport(t)
1173		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	1173		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
1174		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1174		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1175		unblock := scriptRecv(tr,	1175		unblock := scriptRecv(tr,
1176	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "local"}))},	1176	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "local"}))},
1177		recvItem{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(target))},	1177		recvItem{f: frameOf(ports.MsgAttachTarget, ports.MarshalAttachTarget(target))},
1178		)	1178		)
1179		defer unblock()	1179		defer unblock()
1180		tr.EXPECT().Close().Return(nil).Once()	1180		tr.EXPECT().Close().Return(nil).Once()
1181			1181
1182	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"})	1182	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"})
1183		var handoff *client.AttachTargetError	1183		var handoff *client.AttachTargetError
1184		require.ErrorAs(t, err, &handoff)	1184		require.ErrorAs(t, err, &handoff)
1185		require.Equal(t, target, handoff.Target)	1185		require.Equal(t, target, handoff.Target)

@@ -1195,7 +1195,7 @@ func TestAttachHelloIncludesCompleteLocalEnvironment(t *testing.T) {
1195		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)	1195		tm, in := newHappyTerminal(t, &out, &restoreCount, resizeCh)
1196		defer in.unblock()	1196		defer in.unblock()
1197			1197
1198	-	gotHello := make(chan ports.Hello, 1)	1198	+	gotHello := make(chan protocol.Hello, 1)
1199		tr := portsmocks.NewMockTransport(t)	1199		tr := portsmocks.NewMockTransport(t)
1200		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	1200		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
1201		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	1201		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()

@@ -1208,13 +1208,13 @@ func TestAttachHelloIncludesCompleteLocalEnvironment(t *testing.T) {
1208		return nil	1208		return nil
1209		}).Once()	1209		}).Once()
1210		unblock := scriptRecv(tr,	1210		unblock := scriptRecv(tr,
1211	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1211	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1212	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1212	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1213		)	1213		)
1214		defer unblock()	1214		defer unblock()
1215		tr.EXPECT().Close().Return(nil).Once()	1215		tr.EXPECT().Close().Return(nil).Once()
1216			1216
1217	-	require.NoError(t, runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral}))	1217	+	require.NoError(t, runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral}))
1218		require.Equal(t, os.Environ(), (<-gotHello).Env)	1218		require.Equal(t, os.Environ(), (<-gotHello).Env)
1219		}	1219		}
1220			1220

@@ -1235,13 +1235,13 @@ func TestAttachHelloRequestsSingleOutputForDatagramTransport(t *testing.T) {
1235		return nil	1235		return nil
1236		}).Once()	1236		}).Once()
1237		unblock := scriptRecv(tr,	1237		unblock := scriptRecv(tr,
1238	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1238	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1239	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1239	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1240		)	1240		)
1241		defer unblock()	1241		defer unblock()
1242		tr.EXPECT().Close().Return(nil).Once()	1242		tr.EXPECT().Close().Return(nil).Once()
1243			1243
1244	-	require.NoError(t, runTestClient(context.Background(), attachTestDependencies(markedDatagramTransport{tr}, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral}))	1244	+	require.NoError(t, runTestClient(context.Background(), attachTestDependencies(markedDatagramTransport{tr}, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral}))
1245		}	1245		}
1246			1246
1247		func TestAttachHappyPath(t *testing.T) {	1247		func TestAttachHappyPath(t *testing.T) {

@@ -1256,14 +1256,14 @@ func TestAttachHappyPath(t *testing.T) {
1256		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	1256		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
1257		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1257		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1258		unblock := scriptRecv(tr,	1258		unblock := scriptRecv(tr,
1259	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1", SessionName: "main"}))},	1259	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main"}))},
1260		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},	1260		recvItem{f: frameOf(ports.MsgOutput, mustMarshalOutput(protocol.Output{Epoch: 1, Size: domain.Size{Cols: 1, Rows: 1}, Data: []byte("hello world")}))},
1261	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1261	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1262		)	1262		)
1263		defer unblock()	1263		defer unblock()
1264		tr.EXPECT().Close().Return(nil).Once()	1264		tr.EXPECT().Close().Return(nil).Once()
1265			1265
1266	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1266	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1267		require.NoError(t, err)	1267		require.NoError(t, err)
1268		require.Equal(t, "\x1b]10;?\x07\x1b]11;?\x07\x1b]4;0;?;1;?;2;?;3;?;4;?;5;?;6;?;7;?;8;?;9;?;10;?;11;?;12;?;13;?;14;?;15;?\x07\x1b[?2031$phello world", out.String())	1268		require.Equal(t, "\x1b]10;?\x07\x1b]11;?\x07\x1b]4;0;?;1;?;2;?;3;?;4;?;5;?;6;?;7;?;8;?;9;?;10;?;11;?;12;?;13;?;14;?;15;?\x07\x1b[?2031$phello world", out.String())
1269		require.Equal(t, int32(1), restoreCount.Load(), "restore must run exactly once")	1269		require.Equal(t, int32(1), restoreCount.Load(), "restore must run exactly once")

@@ -1277,16 +1277,16 @@ func TestAttachVersionMismatch(t *testing.T) {
1277		tr := portsmocks.NewMockTransport(t)	1277		tr := portsmocks.NewMockTransport(t)
1278		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1278		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1279		tr.EXPECT().Recv().Return(	1279		tr.EXPECT().Recv().Return(
1280	-	frameOf(ports.MsgError, ports.MarshalErrorMsg(ports.ErrorMsg{Code: ports.ErrVersionMismatch, Text: "version mismatch"})),	1280	+	frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
1281		nil,	1281		nil,
1282		).Once()	1282		).Once()
1283		tr.EXPECT().Close().Return(nil).Once()	1283		tr.EXPECT().Close().Return(nil).Once()
1284			1284
1285	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main"})	1285	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main"})
1286		require.Error(t, err)	1286		require.Error(t, err)
1287		var pe *client.ProtocolError	1287		var pe *client.ProtocolError
1288		require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)	1288		require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)
1289	-	require.Equal(t, ports.ErrVersionMismatch, pe.Code)	1289	+	require.Equal(t, protocol.ErrVersionMismatch, pe.Code)
1290		tr.AssertNotCalled(t, "Send", isType(ports.MsgTheme))	1290		tr.AssertNotCalled(t, "Send", isType(ports.MsgTheme))
1291		}	1291		}
1292			1292

@@ -1303,13 +1303,13 @@ func TestAttachRestoredOnRecvErrorMidStream(t *testing.T) {
1303		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1303		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1304		boom := errors.New("connection reset")	1304		boom := errors.New("connection reset")
1305		unblock := scriptRecv(tr,	1305		unblock := scriptRecv(tr,
1306	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1306	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1307		recvItem{err: boom},	1307		recvItem{err: boom},
1308		)	1308		)
1309		defer unblock()	1309		defer unblock()
1310		tr.EXPECT().Close().Return(nil).Once()	1310		tr.EXPECT().Close().Return(nil).Once()
1311			1311
1312	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1312	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1313		require.Error(t, err)	1313		require.Error(t, err)
1314		require.Equal(t, int32(1), restoreCount.Load(), "restore must run after mid-stream Recv error")	1314		require.Equal(t, int32(1), restoreCount.Load(), "restore must run after mid-stream Recv error")
1315		}	1315		}

@@ -1326,13 +1326,13 @@ func TestAttachDaemonVanishedOnEOF(t *testing.T) {
1326		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	1326		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
1327		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1327		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1328		unblock := scriptRecv(tr,	1328		unblock := scriptRecv(tr,
1329	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1329	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1330		recvItem{err: io.EOF},	1330		recvItem{err: io.EOF},
1331		)	1331		)
1332		defer unblock()	1332		defer unblock()
1333		tr.EXPECT().Close().Return(nil).Once()	1333		tr.EXPECT().Close().Return(nil).Once()
1334			1334
1335	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1335	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1336		require.Error(t, err)	1336		require.Error(t, err)
1337		require.ErrorIs(t, err, io.EOF)	1337		require.ErrorIs(t, err, io.EOF)
1338		require.Equal(t, int32(1), restoreCount.Load())	1338		require.Equal(t, int32(1), restoreCount.Load())

@@ -1366,8 +1366,8 @@ func TestAttachStdinForwardsSGRMouseReportAsSingleFrame(t *testing.T) {
1366		close(allowDetach)	1366		close(allowDetach)
1367		return nil	1367		return nil
1368		}).Once()	1368		}).Once()
1369	-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))	1369	+	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
1370	-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))	1370	+	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
1371		recvCh := make(chan recvItem, 1)	1371		recvCh := make(chan recvItem, 1)
1372		recvCh <- recvItem{f: welcome}	1372		recvCh <- recvItem{f: welcome}
1373		closed := make(chan struct{})	1373		closed := make(chan struct{})

@@ -1389,7 +1389,7 @@ func TestAttachStdinForwardsSGRMouseReportAsSingleFrame(t *testing.T) {
1389		}).Maybe()	1389		}).Maybe()
1390		tr.EXPECT().Close().Return(nil).Once()	1390		tr.EXPECT().Close().Return(nil).Once()
1391			1391
1392	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1392	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1393		require.NoError(t, err)	1393		require.NoError(t, err)
1394		select {	1394		select {
1395		case got := <-gotInput:	1395		case got := <-gotInput:

@@ -1428,8 +1428,8 @@ func TestAttachStdinCoalescesSplitBracketedPaste(t *testing.T) {
1428		close(allowDetach)	1428		close(allowDetach)
1429		return nil	1429		return nil
1430		}).Once()	1430		}).Once()
1431	-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))	1431	+	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
1432	-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))	1432	+	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
1433		recvCh := make(chan recvItem, 1)	1433		recvCh := make(chan recvItem, 1)
1434		recvCh <- recvItem{f: welcome}	1434		recvCh <- recvItem{f: welcome}
1435		closed := make(chan struct{})	1435		closed := make(chan struct{})

@@ -1451,7 +1451,7 @@ func TestAttachStdinCoalescesSplitBracketedPaste(t *testing.T) {
1451		}).Maybe()	1451		}).Maybe()
1452		tr.EXPECT().Close().Return(nil).Once()	1452		tr.EXPECT().Close().Return(nil).Once()
1453			1453
1454	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1454	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1455		require.NoError(t, err)	1455		require.NoError(t, err)
1456		select {	1456		select {
1457		case got := <-gotInput:	1457		case got := <-gotInput:

@@ -1485,8 +1485,8 @@ func TestAttachForwardsResize(t *testing.T) {
1485		return nil	1485		return nil
1486		}).Once()	1486		}).Once()
1487			1487
1488	-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))	1488	+	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
1489	-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))	1489	+	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
1490		recvCh := make(chan recvItem, 2)	1490		recvCh := make(chan recvItem, 2)
1491		recvCh <- recvItem{f: welcome}	1491		recvCh <- recvItem{f: welcome}
1492		done := make(chan struct{})	1492		done := make(chan struct{})

@@ -1516,7 +1516,7 @@ func TestAttachForwardsResize(t *testing.T) {
1516		resizeCh <- domain.Geometry{Size: domain.Size{Cols: 120, Rows: 40}}	1516		resizeCh <- domain.Geometry{Size: domain.Size{Cols: 120, Rows: 40}}
1517		}()	1517		}()
1518			1518
1519	-	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: ""})	1519	+	err := runTestClient(context.Background(), attachTestDependencies(tr, tm, realClock{}), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: ""})
1520		require.NoError(t, err)	1520		require.NoError(t, err)
1521		select {	1521		select {
1522		case r := <-gotResize:	1522		case r := <-gotResize:

@@ -1539,7 +1539,7 @@ func TestRunRestoresRawModeAfterAttachError(t *testing.T) {
1539		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1539		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1540		boom := errors.New("connection reset")	1540		boom := errors.New("connection reset")
1541		unblock := scriptRecv(tr,	1541		unblock := scriptRecv(tr,
1542	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1542	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1543		recvItem{err: boom},	1543		recvItem{err: boom},
1544		)	1544		)
1545		defer unblock()	1545		defer unblock()

@@ -1547,7 +1547,7 @@ func TestRunRestoresRawModeAfterAttachError(t *testing.T) {
1547		d := portsmocks.NewMockDialer(t)	1547		d := portsmocks.NewMockDialer(t)
1548		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()	1548		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()
1549			1549
1550	-	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: "", Remote: false})	1550	+	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: "", Remote: false})
1551		require.Error(t, err)	1551		require.Error(t, err)
1552		require.Equal(t, int32(1), restoreCount.Load(), "Run must restore raw mode after attach attempt errors")	1552		require.Equal(t, int32(1), restoreCount.Load(), "Run must restore raw mode after attach attempt errors")
1553		}	1553		}

@@ -1560,14 +1560,14 @@ func TestRunDoesNotEnterRawBeforePreWelcomeError(t *testing.T) {
1560		tr := portsmocks.NewMockTransport(t)	1560		tr := portsmocks.NewMockTransport(t)
1561		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	1561		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
1562		tr.EXPECT().Recv().Return(	1562		tr.EXPECT().Recv().Return(
1563	-	frameOf(ports.MsgError, ports.MarshalErrorMsg(ports.ErrorMsg{Code: ports.ErrVersionMismatch, Text: "version mismatch"})),	1563	+	frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"})),
1564		nil,	1564		nil,
1565		).Once()	1565		).Once()
1566		tr.EXPECT().Close().Return(nil).Once()	1566		tr.EXPECT().Close().Return(nil).Once()
1567		d := portsmocks.NewMockDialer(t)	1567		d := portsmocks.NewMockDialer(t)
1568		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()	1568		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()
1569			1569
1570	-	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: false})	1570	+	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: false})
1571		require.Error(t, err)	1571		require.Error(t, err)
1572		var pe *client.ProtocolError	1572		var pe *client.ProtocolError
1573		require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)	1573		require.True(t, errors.As(err, &pe), "want *client.ProtocolError, got %T", err)

@@ -1580,7 +1580,7 @@ func TestRunPhaseASingleAttempt(t *testing.T) {
1580		d.EXPECT().Dial(mock.Anything).Return(nil, dialErr).Once()	1580		d.EXPECT().Dial(mock.Anything).Return(nil, dialErr).Once()
1581		tm := portsmocks.NewMockTerminal(t)	1581		tm := portsmocks.NewMockTerminal(t)
1582			1582
1583	-	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: ports.IntentEphemeral, SessionName: "", Remote: false})	1583	+	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, nil, nil), client.AttachRequest{Intent: protocol.IntentEphemeral, SessionName: "", Remote: false})
1584		require.ErrorIs(t, err, dialErr)	1584		require.ErrorIs(t, err, dialErr)
1585		}	1585		}
1586			1586

@@ -1688,7 +1688,7 @@ func (t *runTerminal) In() io.Reader { return t.in }
1688		func (t *runTerminal) Out() io.Writer { return &t.out }	1688		func (t *runTerminal) Out() io.Writer { return &t.out }
1689		func (t *runTerminal) Flush() error { return nil }	1689		func (t *runTerminal) Flush() error { return nil }
1690			1690
1691	-	func helloFromSend(t testing.T, tr recordingTransport) ports.Hello {	1691	+	func helloFromSend(t testing.T, tr recordingTransport) protocol.Hello {
1692		t.Helper()	1692		t.Helper()
1693		sends := tr.Sends()	1693		sends := tr.Sends()
1694		require.NotEmpty(t, sends)	1694		require.NotEmpty(t, sends)

@@ -1699,7 +1699,7 @@ func helloFromSend(t testing.T, tr recordingTransport) ports.Hello {
1699		}	1699		}
1700			1700
1701		func welcomeFrame(token uint64) ports.Frame {	1701		func welcomeFrame(token uint64) ports.Frame {
1702	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1", SessionName: "main", ResumeToken: token, Capabilities: ports.CapabilityResume}))	1702	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: "main", ResumeToken: token, Capabilities: protocol.CapabilityResume}))
1703		}	1703		}
1704			1704
1705		func TestRunReconnectsWithRotatedTokenAndSameClientID(t *testing.T) {	1705		func TestRunReconnectsWithRotatedTokenAndSameClientID(t *testing.T) {

@@ -1707,12 +1707,12 @@ func TestRunReconnectsWithRotatedTokenAndSameClientID(t *testing.T) {
1707		defer term.in.unblock()	1707		defer term.in.unblock()
1708		tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}	1708		tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}
1709		tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {err: io.EOF}}}	1709		tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {err: io.EOF}}}
1710	-	tr3 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(33)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))}}}	1710	+	tr3 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(33)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
1711		d := &sequenceDialer{trs: []ports.Transport{tr1, tr2, tr3}}	1711		d := &sequenceDialer{trs: []ports.Transport{tr1, tr2, tr3}}
1712		clock := &reconnectTestClock{}	1712		clock := &reconnectTestClock{}
1713		result := make(chan error, 1)	1713		result := make(chan error, 1)
1714		go func() {	1714		go func() {
1715	-	result <- runTestClient(context.Background(), testDependencies(d, term, clock, nil, nil), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: false})	1715	+	result <- runTestClient(context.Background(), testDependencies(d, term, clock, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: false})
1716		}()	1716		}()
1717		clock.fireReconnect(t)	1717		clock.fireReconnect(t)
1718		clock.fireReconnect(t)	1718		clock.fireReconnect(t)

@@ -1724,11 +1724,11 @@ func TestRunReconnectsWithRotatedTokenAndSameClientID(t *testing.T) {
1724		h1 := helloFromSend(t, tr1)	1724		h1 := helloFromSend(t, tr1)
1725		h2 := helloFromSend(t, tr2)	1725		h2 := helloFromSend(t, tr2)
1726		h3 := helloFromSend(t, tr3)	1726		h3 := helloFromSend(t, tr3)
1727	-	require.Equal(t, ports.IntentAttach, h1.Intent)	1727	+	require.Equal(t, protocol.IntentAttach, h1.Intent)
1728		require.Zero(t, h1.ResumeToken)	1728		require.Zero(t, h1.ResumeToken)
1729	-	require.Equal(t, ports.IntentResume, h2.Intent)	1729	+	require.Equal(t, protocol.IntentResume, h2.Intent)
1730		require.Equal(t, uint64(11), h2.ResumeToken)	1730		require.Equal(t, uint64(11), h2.ResumeToken)
1731	-	require.Equal(t, ports.IntentResume, h3.Intent)	1731	+	require.Equal(t, protocol.IntentResume, h3.Intent)
1732		require.Equal(t, uint64(22), h3.ResumeToken)	1732		require.Equal(t, uint64(22), h3.ResumeToken)
1733		require.Equal(t, h1.ClientID, h2.ClientID)	1733		require.Equal(t, h1.ClientID, h2.ClientID)
1734		require.Equal(t, h1.ClientID, h3.ClientID)	1734		require.Equal(t, h1.ClientID, h3.ClientID)

@@ -1742,8 +1742,8 @@ func TestReconnectRestoresLastPublishedRouteTab(t *testing.T) {
1742		lifecycle := domain.SessionLifecycleID{7, 8, 9}	1742		lifecycle := domain.SessionLifecycleID{7, 8, 9}
1743		target := protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}	1743		target := protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: "work"}
1744		welcome := func(token uint64) ports.Frame {	1744		welcome := func(token uint64) ports.Frame {
1745	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	1745	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
1746	-	SessionID: "work", SessionName: "work", ResumeToken: token, Capabilities: ports.CapabilityResume,	1746	+	SessionID: "work", SessionName: "work", ResumeToken: token, Capabilities: protocol.CapabilityResume,
1747		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: target},	1747		CommittedIdentity: &protocol.CommittedRouteIdentity{Target: target},
1748		}))	1748		}))
1749		}	1749		}

@@ -1754,14 +1754,14 @@ func TestReconnectRestoresLastPublishedRouteTab(t *testing.T) {
1754		}}	1754		}}
1755		tr2 := &recordingTransport{recvs: []recvItem{	1755		tr2 := &recordingTransport{recvs: []recvItem{
1756		{f: welcome(22)},	1756		{f: welcome(22)},
1757	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1757	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1758		}}	1758		}}
1759		dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}	1759		dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
1760		clock := &reconnectTestClock{}	1760		clock := &reconnectTestClock{}
1761		result := make(chan error, 1)	1761		result := make(chan error, 1)
1762		go func() {	1762		go func() {
1763		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{	1763		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{
1764	-	Intent: ports.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local",	1764	+	Intent: protocol.IntentAttach, SessionName: "work", Origin: protocol.RouteOriginLocal, OriginKey: "local",
1765		})	1765		})
1766		}()	1766		}()
1767		clock.fireReconnect(t)	1767		clock.fireReconnect(t)

@@ -1781,8 +1781,8 @@ func TestRemoteReconnectDropsStalePickerTargetAfterDaemonSessionSwitch(t *testin
1781		SessionName: "old", LiveTabID: "tab-1",	1781		SessionName: "old", LiveTabID: "tab-1",
1782		}	1782		}
1783		welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {	1783		welcome := func(name string, lifecycle domain.SessionLifecycleID, token uint64) ports.Frame {
1784	-	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{	1784	+	return frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{
1785	-	SessionID: name, SessionName: name, ResumeToken: token, Capabilities: ports.CapabilityResume,	1785	+	SessionID: name, SessionName: name, ResumeToken: token, Capabilities: protocol.CapabilityResume,
1786		CommittedIdentity: &protocol.CommittedRouteIdentity{	1786		CommittedIdentity: &protocol.CommittedRouteIdentity{
1787		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},	1787		Target: protocol.ExactSessionTarget{LifecycleID: lifecycle, SessionName: name},
1788		},	1788		},

@@ -1797,23 +1797,23 @@ func TestRemoteReconnectDropsStalePickerTargetAfterDaemonSessionSwitch(t *testin
1797		}}	1797		}}
1798		tr2 := &recordingTransport{recvs: []recvItem{	1798		tr2 := &recordingTransport{recvs: []recvItem{
1799		{f: welcome("new", newLifecycle, 22)},	1799		{f: welcome("new", newLifecycle, 22)},
1800	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1800	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1801		}}	1801		}}
1802		dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}	1802		dialer := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
1803		clock := &reconnectTestClock{}	1803		clock := &reconnectTestClock{}
1804		result := make(chan error, 1)	1804		result := make(chan error, 1)
1805		go func() {	1805		go func() {
1806		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{	1806		result <- runTestClient(context.Background(), testDependencies(dialer, term, clock, nil, nil), client.AttachRequest{
1807	-	Intent: ports.IntentAttach, SessionName: "old", Remote: true,	1807	+	Intent: protocol.IntentAttach, SessionName: "old", Remote: true,
1808		Origin: protocol.RouteOriginDiscovery, OriginKey: "remote",	1808		Origin: protocol.RouteOriginDiscovery, OriginKey: "remote",
1809	-	RemoteTarget: remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	1809	+	RemoteTarget: remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
1810		})	1810		})
1811		}()	1811		}()
1812		clock.fireReconnect(t)	1812		clock.fireReconnect(t)
1813		require.NoError(t, <-result)	1813		require.NoError(t, <-result)
1814			1814
1815		reconnectHello := helloFromSend(t, tr2)	1815		reconnectHello := helloFromSend(t, tr2)
1816	-	require.Equal(t, ports.IntentResume, reconnectHello.Intent)	1816	+	require.Equal(t, protocol.IntentResume, reconnectHello.Intent)
1817		require.Equal(t, "new", reconnectHello.Name)	1817		require.Equal(t, "new", reconnectHello.Name)
1818		require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"}, reconnectHello.ExactTarget)	1818		require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: newLifecycle, SessionName: "new"}, reconnectHello.ExactTarget)
1819		require.Nil(t, reconnectHello.RemoteTarget)	1819		require.Nil(t, reconnectHello.RemoteTarget)

@@ -1832,35 +1832,35 @@ func TestAttachRememberRemoteHost(t *testing.T) {
1832		{	1832		{
1833		name: "remote success",	1833		name: "remote success",
1834		request: client.AttachRequest{	1834		request: client.AttachRequest{
1835	-	Intent: ports.IntentAttach,	1835	+	Intent: protocol.IntentAttach,
1836		SessionName: "main",	1836		SessionName: "main",
1837		Remote: true,	1837		Remote: true,
1838		},	1838		},
1839		remember: func() error { return nil },	1839		remember: func() error { return nil },
1840		recv: []recvItem{	1840		recv: []recvItem{
1841	-	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1841	+	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1842	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1842	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1843		},	1843		},
1844		wantCalled: true,	1844		wantCalled: true,
1845		},	1845		},
1846		{	1846		{
1847		name: "callback failure does not fail attach",	1847		name: "callback failure does not fail attach",
1848		request: client.AttachRequest{	1848		request: client.AttachRequest{
1849	-	Intent: ports.IntentAttach,	1849	+	Intent: protocol.IntentAttach,
1850		SessionName: "main",	1850		SessionName: "main",
1851		Remote: true,	1851		Remote: true,
1852		},	1852		},
1853		remember: func() error { return errors.New("disk full") },	1853		remember: func() error { return errors.New("disk full") },
1854		recv: []recvItem{	1854		recv: []recvItem{
1855	-	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1855	+	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1856	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1856	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1857		},	1857		},
1858		wantCalled: true,	1858		wantCalled: true,
1859		},	1859		},
1860		{	1860		{
1861		name: "local attach does not call callback",	1861		name: "local attach does not call callback",
1862		request: client.AttachRequest{	1862		request: client.AttachRequest{
1863	-	Intent: ports.IntentAttach,	1863	+	Intent: protocol.IntentAttach,
1864		SessionName: "main",	1864		SessionName: "main",
1865		Remote: false,	1865		Remote: false,
1866		},	1866		},

@@ -1869,14 +1869,14 @@ func TestAttachRememberRemoteHost(t *testing.T) {
1869		return nil	1869		return nil
1870		},	1870		},
1871		recv: []recvItem{	1871		recv: []recvItem{
1872	-	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1872	+	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1873	-	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	1873	+	{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
1874		},	1874		},
1875		},	1875		},
1876		{	1876		{
1877		name: "rejected before welcome does not call callback",	1877		name: "rejected before welcome does not call callback",
1878		request: client.AttachRequest{	1878		request: client.AttachRequest{
1879	-	Intent: ports.IntentAttach,	1879	+	Intent: protocol.IntentAttach,
1880		SessionName: "main",	1880		SessionName: "main",
1881		Remote: true,	1881		Remote: true,
1882		},	1882		},

@@ -1885,7 +1885,7 @@ func TestAttachRememberRemoteHost(t *testing.T) {
1885		return nil	1885		return nil
1886		},	1886		},
1887		recv: []recvItem{	1887		recv: []recvItem{
1888	-	{f: frameOf(ports.MsgError, ports.MarshalErrorMsg(ports.ErrorMsg{Code: ports.ErrVersionMismatch, Text: "version mismatch"}))},	1888	+	{f: frameOf(ports.MsgError, ports.MarshalErrorMsg(protocol.ErrorMsg{Code: protocol.ErrVersionMismatch, Text: "version mismatch"}))},
1889		},	1889		},
1890		preWelcomeReject: true,	1890		preWelcomeReject: true,
1891		wantErr: true,	1891		wantErr: true,

@@ -1893,13 +1893,13 @@ func TestAttachRememberRemoteHost(t *testing.T) {
1893		{	1893		{
1894		name: "post-welcome error still uses happy terminal fixture",	1894		name: "post-welcome error still uses happy terminal fixture",
1895		request: client.AttachRequest{	1895		request: client.AttachRequest{
1896	-	Intent: ports.IntentAttach,	1896	+	Intent: protocol.IntentAttach,
1897		SessionName: "main",	1897		SessionName: "main",
1898		Remote: true,	1898		Remote: true,
1899		},	1899		},
1900		remember: func() error { return nil },	1900		remember: func() error { return nil },
1901		recv: []recvItem{	1901		recv: []recvItem{
1902	-	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	1902	+	{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
1903		{err: errors.New("connection reset")},	1903		{err: errors.New("connection reset")},
1904		},	1904		},
1905		wantCalled: true,	1905		wantCalled: true,

@@ -1984,7 +1984,7 @@ func TestRunRememberRemoteHostAtMostOnceAcrossReconnects(t *testing.T) {
1984		learnerDone := make(chan struct{})	1984		learnerDone := make(chan struct{})
1985			1985
1986		tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}	1986		tr1 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {err: io.EOF}}}
1987	-	tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))}}}	1987	+	tr2 := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(22)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))}}}
1988		d := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}	1988		d := &sequenceDialer{trs: []ports.Transport{tr1, tr2}}
1989			1989
1990		deps := testDependencies(d, term, realClock{}, nil, nil)	1990		deps := testDependencies(d, term, realClock{}, nil, nil)

@@ -1996,7 +1996,7 @@ func TestRunRememberRemoteHostAtMostOnceAcrossReconnects(t *testing.T) {
1996		}).Once()	1996		}).Once()
1997		deps.RemoteHostLearner = learner	1997		deps.RemoteHostLearner = learner
1998		err := runTestClient(context.Background(), deps, client.AttachRequest{	1998		err := runTestClient(context.Background(), deps, client.AttachRequest{
1999	-	Intent: ports.IntentAttach,	1999	+	Intent: protocol.IntentAttach,
2000		SessionName: "main",	2000		SessionName: "main",
2001		Remote: true,	2001		Remote: true,
2002		})	2002		})

@@ -2036,8 +2036,8 @@ func TestAttachRememberRemoteHostDoesNotBlockAfterWelcome(t *testing.T) {
2036		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	2036		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
2037		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	2037		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
2038		unblock := scriptRecv(tr,	2038		unblock := scriptRecv(tr,
2039	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	2039	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
2040	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	2040	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
2041		)	2041		)
2042		defer unblock()	2042		defer unblock()
2043		tr.EXPECT().Close().Return(nil).Once()	2043		tr.EXPECT().Close().Return(nil).Once()

@@ -2055,7 +2055,7 @@ func TestAttachRememberRemoteHostDoesNotBlockAfterWelcome(t *testing.T) {
2055		errCh := make(chan error, 1)	2055		errCh := make(chan error, 1)
2056		go func() {	2056		go func() {
2057		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{	2057		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{
2058	-	Intent: ports.IntentAttach,	2058	+	Intent: protocol.IntentAttach,
2059		SessionName: "main",	2059		SessionName: "main",
2060		Remote: true,	2060		Remote: true,
2061		})	2061		})

@@ -2117,8 +2117,8 @@ func TestRunRestoresTerminalBeforeWaitingForLearner(t *testing.T) {
2117		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	2117		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
2118		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	2118		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
2119		unblock := scriptRecv(tr,	2119		unblock := scriptRecv(tr,
2120	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	2120	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
2121	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	2121	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
2122		)	2122		)
2123		defer unblock()	2123		defer unblock()
2124		tr.EXPECT().Close().Return(nil).Once()	2124		tr.EXPECT().Close().Return(nil).Once()

@@ -2136,7 +2136,7 @@ func TestRunRestoresTerminalBeforeWaitingForLearner(t *testing.T) {
2136		errCh := make(chan error, 1)	2136		errCh := make(chan error, 1)
2137		go func() {	2137		go func() {
2138		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{	2138		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{
2139	-	Intent: ports.IntentAttach,	2139	+	Intent: protocol.IntentAttach,
2140		SessionName: "main",	2140		SessionName: "main",
2141		Remote: true,	2141		Remote: true,
2142		})	2142		})

@@ -2214,8 +2214,8 @@ func TestRunReturnsWhenRemoteHostLearnerStalls(t *testing.T) {
2214		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	2214		tr.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
2215		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	2215		tr.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
2216		unblock := scriptRecv(tr,	2216		unblock := scriptRecv(tr,
2217	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	2217	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
2218	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	2218	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
2219		)	2219		)
2220		defer unblock()	2220		defer unblock()
2221		tr.EXPECT().Close().Return(nil).Once()	2221		tr.EXPECT().Close().Return(nil).Once()

@@ -2232,7 +2232,7 @@ func TestRunReturnsWhenRemoteHostLearnerStalls(t *testing.T) {
2232		errCh := make(chan error, 1)	2232		errCh := make(chan error, 1)
2233		go func() {	2233		go func() {
2234		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{	2234		errCh <- runTestClient(context.Background(), deps, client.AttachRequest{
2235	-	Intent: ports.IntentAttach,	2235	+	Intent: protocol.IntentAttach,
2236		SessionName: "main",	2236		SessionName: "main",
2237		Remote: true,	2237		Remote: true,
2238		})	2238		})

@@ -2267,10 +2267,10 @@ func TestRunReturnsWhenRemoteHostLearnerStalls(t *testing.T) {
2267		func TestRunDoesNotRetryTerminalDetachedError(t *testing.T) {	2267		func TestRunDoesNotRetryTerminalDetachedError(t *testing.T) {
2268		term := newRunTerminal()	2268		term := newRunTerminal()
2269		defer term.in.unblock()	2269		defer term.in.unblock()
2270	-	tr := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonSessionKilled}))}}}	2270	+	tr := &recordingTransport{recvs: []recvItem{{f: welcomeFrame(11)}, {f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonSessionKilled}))}}}
2271		d := &sequenceDialer{trs: []ports.Transport{tr}}	2271		d := &sequenceDialer{trs: []ports.Transport{tr}}
2272			2272
2273	-	err := runTestClient(context.Background(), testDependencies(d, term, realClock{}, nil, nil), client.AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: false})	2273	+	err := runTestClient(context.Background(), testDependencies(d, term, realClock{}, nil, nil), client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: false})
2274		require.Error(t, err)	2274		require.Error(t, err)
2275		var de *client.DetachedError	2275		var de *client.DetachedError
2276		require.True(t, errors.As(err, &de))	2276		require.True(t, errors.As(err, &de))

M internal/usecase/client/clipboard_intercept.go +3 -2

 	"log/slog"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // ctrlV is the byte a Ctrl+V keypress sends on the wire.
 		if !errors.Is(err, ports.ErrNoClipboardImage) {
 			c.log.Warn("clipboard image read failed", "err", err)
 			if c.sendNotice != nil {
-				c.sendNotice(ports.ClientNoticeClipboardFallback)
+				c.sendNotice(protocol.ClientNoticeClipboardFallback)
 			}
 		}
 		c.next([]byte{ctrlV})
 	if len(data) > maxClipboardImagePush {
 		c.log.Warn("clipboard image too large to send, forwarding Ctrl+V instead", "size", len(data), "cap", maxClipboardImagePush)
 		if c.sendNotice != nil {
-			c.sendNotice(ports.ClientNoticeClipboardTooLarge)
+			c.sendNotice(protocol.ClientNoticeClipboardTooLarge)
 		}
 		c.next([]byte{ctrlV})
 		return

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


@@ -86,8 +86,8 @@ func TestClipboardInterceptFailureNotifiesDaemonAndForwardsCtrlV(t *testing.T) {
86		reader ports.ClipboardReader	86		reader ports.ClipboardReader
87		want uint8	87		want uint8
88		}{	88		}{
89	-	{name: "image read failure", reader: &ciFakeReader{err: errors.New("boom")}, want: ports.ClientNoticeClipboardFallback},	89	+	{name: "image read failure", reader: &ciFakeReader{err: errors.New("boom")}, want: protocol.ClientNoticeClipboardFallback},
90	-	{name: "oversized image", reader: &ciFakeReader{mime: "image/png", data: make([]byte, maxClipboardImagePush+1)}, want: ports.ClientNoticeClipboardTooLarge},	90	+	{name: "oversized image", reader: &ciFakeReader{mime: "image/png", data: make([]byte, maxClipboardImagePush+1)}, want: protocol.ClientNoticeClipboardTooLarge},
91		}	91		}
92		for _, tt := range tests {	92		for _, tt := range tests {
93		t.Run(tt.name, func(t *testing.T) {	93		t.Run(tt.name, func(t *testing.T) {

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


@@ -64,8 +64,8 @@ func runRemoteClipboardTest(t *testing.T, remote bool, clip ports.ClipboardReade
64		}).Maybe()	64		}).Maybe()
65		tr.EXPECT().Send(isType(ports.MsgClientNotice)).Return(nil).Maybe()	65		tr.EXPECT().Send(isType(ports.MsgClientNotice)).Return(nil).Maybe()
66			66
67	-	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))	67	+	welcome := frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
68	-	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))	68	+	detached := frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
69		recvCh := make(chan recvItem, 1)	69		recvCh := make(chan recvItem, 1)
70		recvCh <- recvItem{f: welcome}	70		recvCh <- recvItem{f: welcome}
71		closed := make(chan struct{})	71		closed := make(chan struct{})

@@ -90,7 +90,7 @@ func runRemoteClipboardTest(t *testing.T, remote bool, clip ports.ClipboardReade
90		d := portsmocks.NewMockDialer(t)	90		d := portsmocks.NewMockDialer(t)
91		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()	91		d.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()
92			92
93	-	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, clip, nil), client.AttachRequest{Intent: ports.IntentEphemeral, Remote: remote})	93	+	err := runTestClient(context.Background(), testDependencies(d, tm, realClock{}, clip, nil), client.AttachRequest{Intent: protocol.IntentEphemeral, Remote: remote})
94		require.NoError(t, err)	94		require.NoError(t, err)
95		return gotInput, gotImage	95		return gotInput, gotImage
96		}	96		}

@@ -176,11 +176,11 @@ func TestRunRemoteClipboardFailureNotifiesDaemonAndWritesOutputVerbatim(t *testi
176		clipboard := portsmocks.NewMockClipboardReader(t)	176		clipboard := portsmocks.NewMockClipboardReader(t)
177		clipboard.EXPECT().ReadImage(mock.Anything).Return("", nil, errors.New("read failed")).Once()	177		clipboard.EXPECT().ReadImage(mock.Anything).Return("", nil, errors.New("read failed")).Once()
178		transport := &clipboardToastLifecycleTransport{recv: make(chan ports.Frame, 8), sends: make(chan ports.Frame, 16)}	178		transport := &clipboardToastLifecycleTransport{recv: make(chan ports.Frame, 8), sends: make(chan ports.Frame, 16)}
179	-	transport.recv <- frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))	179	+	transport.recv <- frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))
180			180
181		result := make(chan error, 1)	181		result := make(chan error, 1)
182		go func() {	182		go func() {
183	-	result <- client.NewRunner(client.Dependencies{Dialer: clipboardToastLifecycleDialer{transport: transport}, Terminal: term, Clock: realClock{}, DisableCapabilityProbe: true, Clipboard: clipboard}).Run(context.Background(), client.AttachRequest{Intent: ports.IntentEphemeral, Remote: true})	183	+	result <- client.NewRunner(client.Dependencies{Dialer: clipboardToastLifecycleDialer{transport: transport}, Terminal: term, Clock: realClock{}, DisableCapabilityProbe: true, Clipboard: clipboard}).Run(context.Background(), client.AttachRequest{Intent: protocol.IntentEphemeral, Remote: true})
184		}()	184		}()
185			185
186		var gotNotice bool	186		var gotNotice bool

@@ -192,7 +192,7 @@ func TestRunRemoteClipboardFailureNotifiesDaemonAndWritesOutputVerbatim(t *testi
192		}	192		}
193		notice, err := ports.UnmarshalClientNotice(sent.Payload)	193		notice, err := ports.UnmarshalClientNotice(sent.Payload)
194		require.NoError(t, err)	194		require.NoError(t, err)
195	-	require.Equal(t, ports.ClientNoticeClipboardFallback, notice.Action)	195	+	require.Equal(t, protocol.ClientNoticeClipboardFallback, notice.Action)
196		gotNotice = true	196		gotNotice = true
197		case <-time.After(time.Second):	197		case <-time.After(time.Second):
198		t.Fatal("client did not notify daemon of clipboard failure")	198		t.Fatal("client did not notify daemon of clipboard failure")

@@ -200,7 +200,7 @@ func TestRunRemoteClipboardFailureNotifiesDaemonAndWritesOutputVerbatim(t *testi
200		}	200		}
201		beforeOutput := out.String()	201		beforeOutput := out.String()
202		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")}))	202		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")}))
203	-	transport.recv <- frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))	203	+	transport.recv <- frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))
204			204
205		select {	205		select {
206		case err := <-result:	206		case err := <-result:

M internal/usecase/client/handshake.go +3 -2

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 var errHandshakeTimeout = errors.New("handshake timed out")
 	if clock == nil {
 		clock = systemClock{}
 	}
-	timer := clock.NewTimer(ports.HandshakeTimeout)
+	timer := clock.NewTimer(protocol.HandshakeTimeout)
 	if timer == nil {
-		timer = systemClock{}.NewTimer(ports.HandshakeTimeout)
+		timer = systemClock{}.NewTimer(protocol.HandshakeTimeout)
 	}
 	stop := make(chan struct{})
 	done := make(chan struct{})

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

 	"testing"
 	"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: protocol.NavigationCapabilityHomePicker}, valid: false},
+		{name: "home picker without remote route", request: AttachRequest{Intent: protocol.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: protocol.NavigationCapabilityHomePicker}, valid: true},
+		{name: "home picker on daemon-owned remote route", request: AttachRequest{Intent: protocol.IntentAttach, SessionName: "work", Remote: true, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}, 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: protocol.StartupOverlaySessionPicker, NavigationCapabilities: protocol.NavigationCapabilityBack}, valid: false},
+		{name: "back on remote-target route", request: AttachRequest{Intent: protocol.IntentAttach, SessionName: "work", RemoteTarget: remoteRoute, EnvironmentPolicy: protocol.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: protocol.NavigationCapabilityBack}, valid: false},
 		{name: "startup picker without back", request: AttachRequest{StartupOverlay: protocol.StartupOverlaySessionPicker}, valid: false},

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


@@ -43,7 +43,7 @@ func newAttachPaletteClock() *attachPaletteClock {
43		func (*attachPaletteClock) Now() time.Time { return time.Time{} }	43		func (*attachPaletteClock) Now() time.Time { return time.Time{} }
44		func (c *attachPaletteClock) NewTimer(delay time.Duration) ports.Timer {	44		func (c *attachPaletteClock) NewTimer(delay time.Duration) ports.Timer {
45		timer := &attachPaletteTimer{ch: make(chan time.Time, 1), stopped: make(chan struct{}), duration: delay}	45		timer := &attachPaletteTimer{ch: make(chan time.Time, 1), stopped: make(chan struct{}), duration: delay}
46	-	if delay == ports.HandshakeTimeout {	46	+	if delay == protocol.HandshakeTimeout {
47		select {	47		select {
48		case c.handshakeTimers <- timer:	48		case c.handshakeTimers <- timer:
49		default:	49		default:

@@ -118,7 +118,7 @@ type attachPaletteTransport struct {
118		frames []ports.Frame	118		frames []ports.Frame
119		themes []protocol.Theme	119		themes []protocol.Theme
120		themeCh chan protocol.Theme	120		themeCh chan protocol.Theme
121	-	inputCh chan ports.Input	121	+	inputCh chan protocol.Input
122		detached chan ports.Frame	122		detached chan ports.Frame
123		themeSendErr error	123		themeSendErr error
124		welcomed bool	124		welcomed bool

@@ -127,7 +127,7 @@ type attachPaletteTransport struct {
127		func newAttachPaletteTransport() *attachPaletteTransport {	127		func newAttachPaletteTransport() *attachPaletteTransport {
128		return &attachPaletteTransport{	128		return &attachPaletteTransport{
129		themeCh: make(chan protocol.Theme, 16),	129		themeCh: make(chan protocol.Theme, 16),
130	-	inputCh: make(chan ports.Input, 16),	130	+	inputCh: make(chan protocol.Input, 16),
131		detached: make(chan ports.Frame, 1),	131		detached: make(chan ports.Frame, 1),
132		}	132		}
133		}	133		}

@@ -163,7 +163,7 @@ func (t *attachPaletteTransport) Recv() (ports.Frame, error) {
163		if !t.welcomed {	163		if !t.welcomed {
164		t.welcomed = true	164		t.welcomed = true
165		t.mu.Unlock()	165		t.mu.Unlock()
166	-	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(ports.Welcome{SessionID: "s"})}, nil	166	+	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
167		}	167		}
168		t.mu.Unlock()	168		t.mu.Unlock()
169		return <-t.detached, nil	169		return <-t.detached, nil

@@ -205,7 +205,7 @@ func startAttachPaletteHarnessWithInputAndWriteError(state *terminalThemeState,
205		ms := &milestones{}	205		ms := &milestones{}
206		runner := &Runner{term: term, clock: clock, logger: slog.New(slog.DiscardHandler)}	206		runner := &Runner{term: term, clock: clock, logger: slog.New(slog.DiscardHandler)}
207		attempt := &attachAttempt{	207		attempt := &attachAttempt{
208	-	runner: runner, transport: transport, request: AttachRequest{Intent: ports.IntentAttach},	208	+	runner: runner, transport: transport, request: AttachRequest{Intent: protocol.IntentAttach},
209		milestones: ms, themeState: state,	209		milestones: ms, themeState: state,
210		enterRaw: func() error { ms.rawEntered = true; return nil },	210		enterRaw: func() error { ms.rawEntered = true; return nil },
211		reconnect: &reconnectUI{term: term, rawEntered: new(bool)},	211		reconnect: &reconnectUI{term: term, rawEntered: new(bool)},

@@ -239,7 +239,7 @@ func (h attachPaletteHarness) nextTimer(t testing.T) *attachPaletteTimer {
239		}	239		}
240		func (h attachPaletteHarness) detach(t testing.T) {	240		func (h attachPaletteHarness) detach(t testing.T) {
241		t.Helper()	241		t.Helper()
242	-	h.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach})}	242	+	h.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
243		result := <-h.done	243		result := <-h.done
244		require.NoError(t, result.err)	244		require.NoError(t, result.err)
245		select {	245		select {

@@ -325,7 +325,7 @@ func TestAttachReconnectPreservesStandaloneEscapeBeforeClaimRevocation(t *testin
325			325
326		// Detach starts reconnect teardown. The residual must already be owned by	326		// Detach starts reconnect teardown. The residual must already be owned by
327		// the lifecycle reader at the precise point the old claim is revoked.	327		// the lifecycle reader at the precise point the old claim is revoked.
328	-	first.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach})}	328	+	first.transport.detached <- ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}
329		require.Equal(t, []byte("\x1b"), <-revoked)	329		require.Equal(t, []byte("\x1b"), <-revoked)
330		release()	330		release()
331		require.NoError(t, (<-first.done).err)	331		require.NoError(t, (<-first.done).err)

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


@@ -109,10 +109,10 @@ func (t *paletteAttachTransport) Recv() (ports.Frame, error) {
109		first := len(t.sent) == 1	109		first := len(t.sent) == 1
110		t.mu.Unlock()	110		t.mu.Unlock()
111		if first {	111		if first {
112	-	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(ports.Welcome{SessionID: "s"})}, nil	112	+	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s"})}, nil
113		}	113		}
114		<-t.finalSet	114		<-t.finalSet
115	-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach})}, nil	115	+	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach})}, nil
116		}	116		}
117		func (*paletteAttachTransport) Close() error { return nil }	117		func (*paletteAttachTransport) Close() error { return nil }
118			118

@@ -142,7 +142,7 @@ func TestAttachPublishesOnlyClearedAndDefinitiveInitialPalette(t *testing.T) {
142		ms := &milestones{}	142		ms := &milestones{}
143		runner := &Runner{term: term, clock: paletteAttachClock{}, logger: slog.New(slog.DiscardHandler)}	143		runner := &Runner{term: term, clock: paletteAttachClock{}, logger: slog.New(slog.DiscardHandler)}
144		attempt := &attachAttempt{	144		attempt := &attachAttempt{
145	-	runner: runner, transport: transport, request: AttachRequest{Intent: ports.IntentAttach},	145	+	runner: runner, transport: transport, request: AttachRequest{Intent: protocol.IntentAttach},
146		milestones: ms, themeState: &terminalThemeState{},	146		milestones: ms, themeState: &terminalThemeState{},
147		enterRaw: func() error { ms.rawEntered = true; return nil },	147		enterRaw: func() error { ms.rawEntered = true; return nil },
148		reconnect: &reconnectUI{term: term, rawEntered: new(bool)},	148		reconnect: &reconnectUI{term: term, rawEntered: new(bool)},

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

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type reconnectBackoff struct {
 		return true
 	}
 	protocolErr, ok := errors.AsType[*ProtocolError](err)
-	return ok && (protocolErr.Code == ports.ErrNoSuchSession || protocolErr.Code == ports.ErrNoSuchTarget)
+	return ok && (protocolErr.Code == protocol.ErrNoSuchSession || protocolErr.Code == protocol.ErrNoSuchTarget)
 }
 func shouldReconnect(err error) bool {

M internal/usecase/client/reconnect_toast_test.go +45 -45


@@ -134,11 +134,11 @@ func reconnectToastWelcome(token uint64) ports.Frame {
134		}	134		}
135			135
136		func reconnectToastWelcomeNamed(name string, token uint64) ports.Frame {	136		func reconnectToastWelcomeNamed(name string, token uint64) ports.Frame {
137	-	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(ports.Welcome{SessionID: "s1", SessionName: name, ResumeToken: token, Capabilities: ports.CapabilityResume})}	137	+	return ports.Frame{Type: ports.MsgWelcome, Payload: ports.MarshalWelcome(protocol.Welcome{SessionID: "s1", SessionName: name, ResumeToken: token, Capabilities: protocol.CapabilityResume})}
138		}	138		}
139			139
140		func reconnectToastDetach(reason uint8) ports.Frame {	140		func reconnectToastDetach(reason uint8) ports.Frame {
141	-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: reason})}	141	+	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: reason})}
142		}	142		}
143			143
144		type reconnectToastRecv struct {	144		type reconnectToastRecv struct {

@@ -205,7 +205,7 @@ func (s *reconnectToastSentFrames) find(match func(ports.Frame) bool) (ports.Fra
205		type reconnectToastLinkTransport struct {	205		type reconnectToastLinkTransport struct {
206		recvCh chan reconnectToastRecv	206		recvCh chan reconnectToastRecv
207		sends *reconnectToastSentFrames	207		sends *reconnectToastSentFrames
208	-	clientNotices chan ports.ClientNotice	208	+	clientNotices chan protocol.ClientNotice
209		events chan ports.LinkEvent	209		events chan ports.LinkEvent
210		state ports.LinkState	210		state ports.LinkState
211		}	211		}

@@ -214,7 +214,7 @@ func newReconnectToastLinkTransport() *reconnectToastLinkTransport {
214		return &reconnectToastLinkTransport{	214		return &reconnectToastLinkTransport{
215		recvCh: make(chan reconnectToastRecv, 4),	215		recvCh: make(chan reconnectToastRecv, 4),
216		sends: newReconnectToastSentFrames(),	216		sends: newReconnectToastSentFrames(),
217	-	clientNotices: make(chan ports.ClientNotice, 2),	217	+	clientNotices: make(chan protocol.ClientNotice, 2),
218		events: make(chan ports.LinkEvent, 4),	218		events: make(chan ports.LinkEvent, 4),
219		state: ports.LinkStateConnected,	219		state: ports.LinkStateConnected,
220		}	220		}

@@ -298,7 +298,7 @@ func assertReconnectToastAttemptPublishesOnlyClearedTheme(t testing.T, tr reco
298		require.True(t, tr.wasClosed())	298		require.True(t, tr.wasClosed())
299		}	299		}
300			300
301	-	func reconnectToastHelloFromSend(t testing.T, tr reconnectToastRecordingTransport) ports.Hello {	301	+	func reconnectToastHelloFromSend(t testing.T, tr reconnectToastRecordingTransport) protocol.Hello {
302		t.Helper()	302		t.Helper()
303		frames := tr.sentFrames()	303		frames := tr.sentFrames()
304		require.NotEmpty(t, frames)	304		require.NotEmpty(t, frames)

@@ -362,9 +362,9 @@ func TestResumeNeedsExactAttach(t *testing.T) {
362		want bool	362		want bool
363		}{	363		}{
364		{name: "moved resume token", err: errRouteTargetChanged, want: true},	364		{name: "moved resume token", err: errRouteTargetChanged, want: true},
365	-	{name: "missing target", err: &ProtocolError{Code: ports.ErrNoSuchTarget}, want: true},	365	+	{name: "missing target", err: &ProtocolError{Code: protocol.ErrNoSuchTarget}, want: true},
366	-	{name: "missing session", err: &ProtocolError{Code: ports.ErrNoSuchSession}, want: true},	366	+	{name: "missing session", err: &ProtocolError{Code: protocol.ErrNoSuchSession}, want: true},
367	-	{name: "internal", err: &ProtocolError{Code: ports.ErrInternal}},	367	+	{name: "internal", err: &ProtocolError{Code: protocol.ErrInternal}},
368		{name: "transport", err: io.EOF},	368		{name: "transport", err: io.EOF},
369		} {	369		} {
370		t.Run(test.name, func(t *testing.T) {	370		t.Run(test.name, func(t *testing.T) {

@@ -386,7 +386,7 @@ func TestProbingToastReconcilesDaemonOutputAndDismissal(t *testing.T) {
386			386
387		resultCh := make(chan attachResult, 1)	387		resultCh := make(chan attachResult, 1)
388		ms := milestones{}	388		ms := milestones{}
389	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	389	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
390		go func() { resultCh <- attempt.run(context.Background()) }()	390		go func() { resultCh <- attempt.run(context.Background()) }()
391			391
392		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}	392		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}

@@ -408,7 +408,7 @@ func TestProbingToastReconcilesDaemonOutputAndDismissal(t *testing.T) {
408		require.Contains(t, redrawn, "probing UDP path")	408		require.Contains(t, redrawn, "probing UDP path")
409			409
410		tr.events <- ports.LinkEvent{State: ports.LinkStateConnected}	410		tr.events <- ports.LinkEvent{State: ports.LinkStateConnected}
411	-	require.Equal(t, ports.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)	411	+	require.Equal(t, protocol.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)
412		require.Equal(t, term.size, requireResize(t, tr.sends).Size)	412		require.Equal(t, term.size, requireResize(t, tr.sends).Size)
413			413
414		beforeAwaitingReset := out.String()	414		beforeAwaitingReset := out.String()

@@ -461,7 +461,7 @@ func TestProbingToastReconcilesDaemonOutputAndDismissal(t *testing.T) {
461		}, time.Second, time.Millisecond)	461		}, time.Second, time.Millisecond)
462		requireAckedState(t, tr.sends, 2, 5)	462		requireAckedState(t, tr.sends, 2, 5)
463			463
464	-	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)}	464	+	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
465		result := requireAttachResult(t, resultCh)	465		result := requireAttachResult(t, resultCh)
466		require.NoError(t, result.err)	466		require.NoError(t, result.err)
467		}	467		}

@@ -479,7 +479,7 @@ func TestActiveReconnectToastStageTransitionReconcilesBeforeRedraw(t *testing.T)
479			479
480		resultCh := make(chan attachResult, 1)	480		resultCh := make(chan attachResult, 1)
481		ms := milestones{}	481		ms := milestones{}
482	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	482	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
483		go func() { resultCh <- attempt.run(context.Background()) }()	483		go func() { resultCh <- attempt.run(context.Background()) }()
484			484
485		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}	485		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}

@@ -547,7 +547,7 @@ func TestActiveReconnectToastStageTransitionReconcilesBeforeRedraw(t *testing.T)
547		require.Eventually(t, func() bool { return flushes.Load() > beforeIncrementFlushes }, time.Second, time.Millisecond)	547		require.Eventually(t, func() bool { return flushes.Load() > beforeIncrementFlushes }, time.Second, time.Millisecond)
548		requireAckedState(t, tr.sends, 2, 5)	548		requireAckedState(t, tr.sends, 2, 5)
549			549
550	-	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)}	550	+	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
551		result := requireAttachResult(t, resultCh)	551		result := requireAttachResult(t, resultCh)
552		require.NoError(t, result.err)	552		require.NoError(t, result.err)
553		}	553		}

@@ -693,7 +693,7 @@ func TestLocalReconnectStatusFlushesDaemonOutputBeforeObservationAndAck(t *testi
693			693
694		resultCh := make(chan attachResult, 1)	694		resultCh := make(chan attachResult, 1)
695		ms := milestones{}	695		ms := milestones{}
696	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main"}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	696	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main"}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
697		attempt.runner.runtimeObserver = observer	697		attempt.runner.runtimeObserver = observer
698		go func() { resultCh <- attempt.run(context.Background()) }()	698		go func() { resultCh <- attempt.run(context.Background()) }()
699			699

@@ -725,7 +725,7 @@ func TestLocalReconnectStatusFlushesDaemonOutputBeforeObservationAndAck(t *testi
725		requireAckedState(t, tr.sends, 1, 2)	725		requireAckedState(t, tr.sends, 1, 2)
726		require.Greater(t, flushes.Load(), beforeOutput, "daemon output must be flushed before ACK")	726		require.Greater(t, flushes.Load(), beforeOutput, "daemon output must be flushed before ACK")
727			727
728	-	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)}	728	+	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
729		require.NoError(t, requireAttachResult(t, resultCh).err)	729		require.NoError(t, requireAttachResult(t, resultCh).err)
730		}	730		}
731			731

@@ -748,14 +748,14 @@ func TestLocalReconnectStatusTransitionsDoNotRequestAuthoritativeReset(t *testin
748			748
749		resultCh := make(chan attachResult, 1)	749		resultCh := make(chan attachResult, 1)
750		ms := milestones{}	750		ms := milestones{}
751	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main"}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	751	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main"}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
752		go func() { resultCh <- attempt.run(context.Background()) }()	752		go func() { resultCh <- attempt.run(context.Background()) }()
753			753
754		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}	754		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}
755		require.Eventually(t, func() bool { return strings.Contains(out.String(), statusReconnect) }, time.Second, time.Millisecond)	755		require.Eventually(t, func() bool { return strings.Contains(out.String(), statusReconnect) }, time.Second, time.Millisecond)
756		tr.events <- ports.LinkEvent{State: tt.transition}	756		tr.events <- ports.LinkEvent{State: tt.transition}
757		if tt.transition == ports.LinkStateConnected {	757		if tt.transition == ports.LinkStateConnected {
758	-	require.Equal(t, ports.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)	758	+	require.Equal(t, protocol.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)
759		}	759		}
760			760
761		const output = "local status output remains visible"	761		const output = "local status output remains visible"

@@ -772,7 +772,7 @@ func TestLocalReconnectStatusTransitionsDoNotRequestAuthoritativeReset(t *testin
772		_, sentResize := tr.sends.find(func(frame ports.Frame) bool { return frame.Type == ports.MsgResize })	772		_, sentResize := tr.sends.find(func(frame ports.Frame) bool { return frame.Type == ports.MsgResize })
773		require.False(t, sentResize, "local reconnect status must not request a daemon reset")	773		require.False(t, sentResize, "local reconnect status must not request a daemon reset")
774			774
775	-	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)}	775	+	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
776		require.NoError(t, requireAttachResult(t, resultCh).err)	776		require.NoError(t, requireAttachResult(t, resultCh).err)
777		})	777		})
778		}	778		}

@@ -820,7 +820,7 @@ func TestReconnectOverlayRedrawFailureDoesNotObserveOrAckOutput(t *testing.T) {
820			820
821		resultCh := make(chan attachResult, 1)	821		resultCh := make(chan attachResult, 1)
822		ms := milestones{}	822		ms := milestones{}
823	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	823	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
824		attempt.runner.runtimeObserver = observer	824		attempt.runner.runtimeObserver = observer
825		go func() { resultCh <- attempt.run(context.Background()) }()	825		go func() { resultCh <- attempt.run(context.Background()) }()
826			826

@@ -852,20 +852,20 @@ func TestReconnectLinkEventsNotifyDaemonWithoutLocalTerminalWrites(t *testing.T)
852			852
853		resultCh := make(chan attachResult, 1)	853		resultCh := make(chan attachResult, 1)
854		ms := milestones{}	854		ms := milestones{}
855	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	855	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
856		go func() { resultCh <- attempt.run(context.Background()) }()	856		go func() { resultCh <- attempt.run(context.Background()) }()
857			857
858		tr.events <- ports.LinkEvent{State: ports.LinkStateDegraded}	858		tr.events <- ports.LinkEvent{State: ports.LinkStateDegraded}
859		tr.events <- ports.LinkEvent{State: ports.LinkStateConnected}	859		tr.events <- ports.LinkEvent{State: ports.LinkStateConnected}
860	-	require.Equal(t, ports.ClientNoticeLinkDegraded, (<-tr.clientNotices).Action)	860	+	require.Equal(t, protocol.ClientNoticeLinkDegraded, (<-tr.clientNotices).Action)
861	-	require.Equal(t, ports.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)	861	+	require.Equal(t, protocol.ClientNoticeLinkConnected, (<-tr.clientNotices).Action)
862		select {	862		select {
863		case bytes := <-out.completed:	863		case bytes := <-out.completed:
864		t.Fatalf("link notices wrote client-local terminal bytes: %q", bytes)	864		t.Fatalf("link notices wrote client-local terminal bytes: %q", bytes)
865		default:	865		default:
866		}	866		}
867			867
868	-	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)}	868	+	tr.recvCh <- reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)}
869		result := requireAttachResult(t, resultCh)	869		result := requireAttachResult(t, resultCh)
870		require.NoError(t, result.err)	870		require.NoError(t, result.err)
871		require.True(t, result.welcomed)	871		require.True(t, result.welcomed)

@@ -879,7 +879,7 @@ func TestAttachAttemptOfflineLinkEventReturnsReconnectableError(t *testing.T) {
879			879
880		resultCh := make(chan attachResult, 1)	880		resultCh := make(chan attachResult, 1)
881		ms := milestones{}	881		ms := milestones{}
882	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	882	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
883		go func() { resultCh <- attempt.run(context.Background()) }()	883		go func() { resultCh <- attempt.run(context.Background()) }()
884			884
885		tr.events <- ports.LinkEvent{State: ports.LinkStateOffline}	885		tr.events <- ports.LinkEvent{State: ports.LinkStateOffline}

@@ -988,7 +988,7 @@ func TestPreSenderReconnectResetIsBounded(t *testing.T) {
988		ctx, cancel := context.WithCancel(context.Background())	988		ctx, cancel := context.WithCancel(context.Background())
989		defer cancel()	989		defer cancel()
990		ms := milestones{}	990		ms := milestones{}
991	-	attempt := newReconnectAttachAttempt(term.term, tr, clock, AttachRequest{Intent: ports.IntentResume, SessionName: "requested", Remote: true}, 12, &terminalThemeState{}, nil, &ms)	991	+	attempt := newReconnectAttachAttempt(term.term, tr, clock, AttachRequest{Intent: protocol.IntentResume, SessionName: "requested", Remote: true}, 12, &terminalThemeState{}, nil, &ms)
992		attempt.reconnect.showing = true	992		attempt.reconnect.showing = true
993		resultCh := make(chan attachResult, 1)	993		resultCh := make(chan attachResult, 1)
994		go func() { resultCh <- attempt.run(ctx) }()	994		go func() { resultCh <- attempt.run(ctx) }()

@@ -1078,7 +1078,7 @@ func TestReconnectResetEnqueueCancellationExitsCleanly(t *testing.T) {
1078			1078
1079		resultCh := make(chan attachResult, 1)	1079		resultCh := make(chan attachResult, 1)
1080		ms := milestones{}	1080		ms := milestones{}
1081	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	1081	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
1082		go func() { resultCh <- attempt.run(ctx) }()	1082		go func() { resultCh <- attempt.run(ctx) }()
1083			1083
1084		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}	1084		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}

@@ -1118,7 +1118,7 @@ func TestReconnectResetCancellationPreservesQueuedSenderError(t *testing.T) {
1118			1118
1119		resultCh := make(chan attachResult, 1)	1119		resultCh := make(chan attachResult, 1)
1120		ms := milestones{}	1120		ms := milestones{}
1121	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	1121	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
1122		go func() { resultCh <- attempt.run(context.Background()) }()	1122		go func() { resultCh <- attempt.run(context.Background()) }()
1123			1123
1124		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}	1124		tr.events <- ports.LinkEvent{State: ports.LinkStateProbing}

@@ -1157,7 +1157,7 @@ func TestAttachAttemptReturnsWhileSenderSendIsBlockedAfterCancellation(t *testin
1157			1157
1158		resultCh := make(chan attachResult, 1)	1158		resultCh := make(chan attachResult, 1)
1159		ms := milestones{}	1159		ms := milestones{}
1160	-	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)	1160	+	attempt := newReconnectAttachAttempt(term.term, tr, newReconnectHandshakeClock(t), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true}, 0, &terminalThemeState{}, tr.LinkEvents(), &ms)
1161		go func() { resultCh <- attempt.run(context.Background()) }()	1161		go func() { resultCh <- attempt.run(context.Background()) }()
1162			1162
1163		tr.armed.Store(true)	1163		tr.armed.Store(true)

@@ -1188,8 +1188,8 @@ func TestDetachedResultLegacyReplacementCompatibilityAndCleanDetach(t *testing.T
1188		reason uint8	1188		reason uint8
1189		wantText string	1189		wantText string
1190		}{	1190		}{
1191	-	{name: "clean detach", reason: ports.ReasonDetach},	1191	+	{name: "clean detach", reason: protocol.ReasonDetach},
1192	-	{name: "legacy replacement", reason: ports.ReasonReplaced, wantText: "session taken over by another client"},	1192	+	{name: "legacy replacement", reason: protocol.ReasonReplaced, wantText: "session taken over by another client"},
1193		} {	1193		} {
1194		t.Run(tt.name, func(t *testing.T) {	1194		t.Run(tt.name, func(t *testing.T) {
1195		err := detachedResult(tt.reason)	1195		err := detachedResult(tt.reason)

@@ -1376,7 +1376,7 @@ func TestReconnectRetryFailuresPreserveAttachError(t *testing.T) {
1376		)	1376		)
1377		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr}}	1377		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr}}
1378			1378
1379	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true})	1379	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true})
1380		require.ErrorIs(t, err, attachErr)	1380		require.ErrorIs(t, err, attachErr)
1381		require.ErrorIs(t, err, retryErr)	1381		require.ErrorIs(t, err, retryErr)
1382		})	1382		})

@@ -1433,7 +1433,7 @@ func TestReconnectRetrySleepFailuresPreserveDialError(t *testing.T) {
1433		dialer.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()	1433		dialer.EXPECT().Dial(mock.Anything).Return(tr, nil).Once()
1434		dialer.EXPECT().Dial(mock.Anything).Run(func(context.Context) { armed.Store(true) }).Return(nil, dialErr).Once()	1434		dialer.EXPECT().Dial(mock.Anything).Run(func(context.Context) { armed.Store(true) }).Return(nil, dialErr).Once()
1435			1435
1436	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true})	1436	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true})
1437		require.ErrorIs(t, err, dialErr)	1437		require.ErrorIs(t, err, dialErr)
1438		require.ErrorIs(t, err, retryErr)	1438		require.ErrorIs(t, err, retryErr)
1439		})	1439		})

@@ -1463,7 +1463,7 @@ func TestRemoteReconnectToastFailedDrawDoesNotBlankBounds(t *testing.T) {
1463		}}	1463		}}
1464		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr}}	1464		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr}}
1465			1465
1466	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true})	1466	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true})
1467		require.ErrorContains(t, err, "reconnect toast write failed")	1467		require.ErrorContains(t, err, "reconnect toast write failed")
1468		require.True(t, out.failed)	1468		require.True(t, out.failed)
1469		require.NotContains(t, out.String(), strings.Repeat(" ", reconnectToastBoundsFor(term.size, reconnectStageMessage(reconnectStageSSH)).Width))	1469		require.NotContains(t, out.String(), strings.Repeat(" ", reconnectToastBoundsFor(term.size, reconnectStageMessage(reconnectStageSSH)).Width))

@@ -1540,7 +1540,7 @@ func TestReconnectCancellationPreservesContextWhenStatusClearFails(t *testing.T)
1540		dialer := portsmocks.NewMockDialer(t)	1540		dialer := portsmocks.NewMockDialer(t)
1541		tt.configure(dialer, tr)	1541		tt.configure(dialer, tr)
1542			1542
1543	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: ports.IntentAttach, SessionName: "main"})	1543	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: protocol.IntentAttach, SessionName: "main"})
1544		require.ErrorIs(t, err, context.Canceled)	1544		require.ErrorIs(t, err, context.Canceled)
1545		require.ErrorIs(t, err, clearErr)	1545		require.ErrorIs(t, err, clearErr)
1546		})	1546		})

@@ -1572,11 +1572,11 @@ func TestRemoteReconnectToastLifecycleWithWrappedTransportError(t *testing.T) {
1572		}}	1572		}}
1573		tr2 := &reconnectToastRecordingTransport{recvs: []reconnectToastRecv{	1573		tr2 := &reconnectToastRecordingTransport{recvs: []reconnectToastRecv{
1574		{frame: reconnectToastWelcome(55)},	1574		{frame: reconnectToastWelcome(55)},
1575	-	{frame: reconnectToastDetach(ports.ReasonDetach)},	1575	+	{frame: reconnectToastDetach(protocol.ReasonDetach)},
1576		}}	1576		}}
1577		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr1, tr2}}	1577		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr1, tr2}}
1578			1578
1579	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true})	1579	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true})
1580		require.NoError(t, err)	1580		require.NoError(t, err)
1581		require.True(t, tr1.wasClosed())	1581		require.True(t, tr1.wasClosed())
1582		require.True(t, tr2.wasClosed())	1582		require.True(t, tr2.wasClosed())

@@ -1584,9 +1584,9 @@ func TestRemoteReconnectToastLifecycleWithWrappedTransportError(t *testing.T) {
1584			1584
1585		firstHello := reconnectToastHelloFromSend(t, tr1)	1585		firstHello := reconnectToastHelloFromSend(t, tr1)
1586		resumeHello := reconnectToastHelloFromSend(t, tr2)	1586		resumeHello := reconnectToastHelloFromSend(t, tr2)
1587	-	require.Equal(t, ports.IntentAttach, firstHello.Intent)	1587	+	require.Equal(t, protocol.IntentAttach, firstHello.Intent)
1588		require.Zero(t, firstHello.ResumeToken)	1588		require.Zero(t, firstHello.ResumeToken)
1589	-	require.Equal(t, ports.IntentResume, resumeHello.Intent)	1589	+	require.Equal(t, protocol.IntentResume, resumeHello.Intent)
1590		require.Equal(t, uint64(44), resumeHello.ResumeToken)	1590		require.Equal(t, uint64(44), resumeHello.ResumeToken)
1591		require.Equal(t, firstHello.ClientID, resumeHello.ClientID)	1591		require.Equal(t, firstHello.ClientID, resumeHello.ClientID)
1592			1592

@@ -1616,20 +1616,20 @@ func TestRemoteEphemeralReconnectUsesAssignedSessionName(t *testing.T) {
1616		}}	1616		}}
1617		tr2 := &reconnectToastRecordingTransport{recvs: []reconnectToastRecv{	1617		tr2 := &reconnectToastRecordingTransport{recvs: []reconnectToastRecv{
1618		{frame: reconnectToastWelcomeNamed("0", 55)},	1618		{frame: reconnectToastWelcomeNamed("0", 55)},
1619	-	{frame: reconnectToastDetach(ports.ReasonDetach)},	1619	+	{frame: reconnectToastDetach(protocol.ReasonDetach)},
1620		}}	1620		}}
1621		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr1, tr2}}	1621		dialer := &reconnectToastSequenceDialer{transports: []ports.Transport{tr1, tr2}}
1622			1622
1623	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: ports.IntentEphemeral, SessionName: "", Remote: true})	1623	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(context.Background(), AttachRequest{Intent: protocol.IntentEphemeral, SessionName: "", Remote: true})
1624		require.NoError(t, err)	1624		require.NoError(t, err)
1625		require.Equal(t, 2, dialer.calls)	1625		require.Equal(t, 2, dialer.calls)
1626			1626
1627		firstHello := reconnectToastHelloFromSend(t, tr1)	1627		firstHello := reconnectToastHelloFromSend(t, tr1)
1628		resumeHello := reconnectToastHelloFromSend(t, tr2)	1628		resumeHello := reconnectToastHelloFromSend(t, tr2)
1629	-	require.Equal(t, ports.IntentEphemeral, firstHello.Intent)	1629	+	require.Equal(t, protocol.IntentEphemeral, firstHello.Intent)
1630		require.Empty(t, firstHello.Name)	1630		require.Empty(t, firstHello.Name)
1631		require.Zero(t, firstHello.ResumeToken)	1631		require.Zero(t, firstHello.ResumeToken)
1632	-	require.Equal(t, ports.IntentResume, resumeHello.Intent)	1632	+	require.Equal(t, protocol.IntentResume, resumeHello.Intent)
1633		require.Equal(t, "0", resumeHello.Name)	1633		require.Equal(t, "0", resumeHello.Name)
1634		require.Equal(t, uint64(44), resumeHello.ResumeToken)	1634		require.Equal(t, uint64(44), resumeHello.ResumeToken)
1635		require.Equal(t, firstHello.ClientID, resumeHello.ClientID)	1635		require.Equal(t, firstHello.ClientID, resumeHello.ClientID)

@@ -1647,7 +1647,7 @@ func TestRemoteReconnectToastLifecycle(t *testing.T) {
1647		name: "clears on successful reconnect",	1647		name: "clears on successful reconnect",
1648		configure: func(t testing.T, dialer portsmocks.MockDialer) []*reconnectToastRecordingTransport {	1648		configure: func(t testing.T, dialer portsmocks.MockDialer) []*reconnectToastRecordingTransport {
1649		tr1 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(11)}, reconnectToastRecv{err: io.EOF})	1649		tr1 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(11)}, reconnectToastRecv{err: io.EOF})
1650	-	tr2 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(22)}, reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonDetach)})	1650	+	tr2 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(22)}, reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonDetach)})
1651		dialer.EXPECT().Dial(mock.Anything).Return(tr1, nil).Once()	1651		dialer.EXPECT().Dial(mock.Anything).Return(tr1, nil).Once()
1652		dialer.EXPECT().Dial(mock.Anything).Return(tr2, nil).Once()	1652		dialer.EXPECT().Dial(mock.Anything).Return(tr2, nil).Once()
1653		return []*reconnectToastRecordingTransport{tr1, tr2}	1653		return []*reconnectToastRecordingTransport{tr1, tr2}

@@ -1672,7 +1672,7 @@ func TestRemoteReconnectToastLifecycle(t *testing.T) {
1672		name: "clears on final exit",	1672		name: "clears on final exit",
1673		configure: func(t testing.T, dialer portsmocks.MockDialer) []*reconnectToastRecordingTransport {	1673		configure: func(t testing.T, dialer portsmocks.MockDialer) []*reconnectToastRecordingTransport {
1674		tr1 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(11)}, reconnectToastRecv{err: io.EOF})	1674		tr1 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(11)}, reconnectToastRecv{err: io.EOF})
1675	-	tr2 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(22)}, reconnectToastRecv{frame: reconnectToastDetach(ports.ReasonSessionKilled)})	1675	+	tr2 := newReconnectToastRecordingTransport(reconnectToastRecv{frame: reconnectToastWelcome(22)}, reconnectToastRecv{frame: reconnectToastDetach(protocol.ReasonSessionKilled)})
1676		dialer.EXPECT().Dial(mock.Anything).Return(tr1, nil).Once()	1676		dialer.EXPECT().Dial(mock.Anything).Return(tr1, nil).Once()
1677		dialer.EXPECT().Dial(mock.Anything).Return(tr2, nil).Once()	1677		dialer.EXPECT().Dial(mock.Anything).Return(tr2, nil).Once()
1678		return []*reconnectToastRecordingTransport{tr1, tr2}	1678		return []*reconnectToastRecordingTransport{tr1, tr2}

@@ -1704,7 +1704,7 @@ func TestRemoteReconnectToastLifecycle(t *testing.T) {
1704		dialer := portsmocks.NewMockDialer(t)	1704		dialer := portsmocks.NewMockDialer(t)
1705		transports := tt.configure(t, dialer)	1705		transports := tt.configure(t, dialer)
1706			1706
1707	-	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: ports.IntentAttach, SessionName: "main", Remote: true})	1707	+	err := NewRunner(Dependencies{Dialer: dialer, Terminal: term.term, Clock: newReconnectHandshakeClock(t), DisableCapabilityProbe: true, Logger: slog.New(slog.DiscardHandler)}).Run(ctx, AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", Remote: true})
1708		tt.wantErr(t, err)	1708		tt.wantErr(t, err)
1709		for _, transport := range transports {	1709		for _, transport := range transports {
1710		assertReconnectToastAttemptPublishesOnlyClearedTheme(t, transport)	1710		assertReconnectToastAttemptPublishesOnlyClearedTheme(t, transport)

M internal/usecase/client/remote_attach_validation_test.go +9 -10

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
 	"github.com/bnema/vev/internal/protocol"
 )
 		name    string
 		request AttachRequest
 	}{
-		{name: "missing session name", request: AttachRequest{Intent: ports.IntentAttach}},
+		{name: "missing session name", request: AttachRequest{Intent: protocol.IntentAttach}},
-		{name: "unsafe session name", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "bad name"}},
+		{name: "unsafe session name", request: AttachRequest{Intent: protocol.IntentAttach, SessionName: "bad name"}},
-		{name: "daemon-owned without remote", request: AttachRequest{Intent: ports.IntentAttach, SessionName: "main", EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}},
+		{name: "daemon-owned without remote", request: AttachRequest{Intent: protocol.IntentAttach, SessionName: "main", EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}},
-		{name: "ephemeral with navigation capability", request: AttachRequest{Intent: ports.IntentEphemeral, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}},
+		{name: "ephemeral with navigation capability", request: AttachRequest{Intent: protocol.IntentEphemeral, NavigationCapabilities: protocol.NavigationCapabilityHomePicker}},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 	tests := []struct {
 		name   string
-		policy ports.EnvironmentPolicy
+		policy protocol.EnvironmentPolicy
 		wantOK bool
 	}{
-		{name: "daemon owned", policy: ports.EnvironmentPolicyDaemonOwned, wantOK: true},
+		{name: "daemon owned", policy: protocol.EnvironmentPolicyDaemonOwned, wantOK: true},
-		{name: "client owned", policy: ports.EnvironmentPolicyClientOwned},
+		{name: "client owned", policy: protocol.EnvironmentPolicyClientOwned},
-		{name: "unknown", policy: ports.EnvironmentPolicy(99)},
+		{name: "unknown", policy: protocol.EnvironmentPolicy(99)},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			err := validateAttachRequest(AttachRequest{
-				Intent: ports.IntentAttach, SessionName: target.SessionName,
+				Intent: protocol.IntentAttach, SessionName: target.SessionName,
 				RemoteTarget: target, EnvironmentPolicy: test.policy,
 			})
 			if test.wantOK {

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


@@ -199,7 +199,7 @@ func routeFailureCode(err error) protocol.RouteFailureCode {
199		var protocolErr *ProtocolError	199		var protocolErr *ProtocolError
200		if errors.As(err, &protocolErr) {	200		if errors.As(err, &protocolErr) {
201		switch protocolErr.Code {	201		switch protocolErr.Code {
202	-	case ports.ErrNoSuchSession, ports.ErrNoSuchTarget:	202	+	case protocol.ErrNoSuchSession, protocol.ErrNoSuchTarget:
203		return protocol.RouteFailureNoSuchRoute	203		return protocol.RouteFailureNoSuchRoute
204		}	204		}
205		}	205		}

@@ -545,12 +545,12 @@ func (l *routeLedger) snapshot() protocol.RecentRouteSnapshot {
545		// samePeerHandoff restores a previously committed route on the daemon already	545		// samePeerHandoff restores a previously committed route on the daemon already
546		// connected to by the client. The daemon deliberately sends no tab state: the	546		// connected to by the client. The daemon deliberately sends no tab state: the
547		// ledger is the sole owner of per-route view memory.	547		// ledger is the sole owner of per-route view memory.
548	-	func (l *routeLedger) samePeerHandoff(active AttachRequest, target ports.AttachTarget) AttachRequest {	548	+	func (l *routeLedger) samePeerHandoff(active AttachRequest, target protocol.AttachTarget) AttachRequest {
549		origin := normalizeRouteOrigin(active.Origin, active.Remote)	549		origin := normalizeRouteOrigin(active.Origin, active.Remote)
550		originKey := normalizeRouteOriginKey(active.OriginKey, origin)	550		originKey := normalizeRouteOriginKey(active.OriginKey, origin)
551		environmentPolicy := target.EnvironmentPolicy	551		environmentPolicy := target.EnvironmentPolicy
552		if origin == protocol.RouteOriginLocal {	552		if origin == protocol.RouteOriginLocal {
553	-	environmentPolicy = ports.EnvironmentPolicyClientOwned	553	+	environmentPolicy = protocol.EnvironmentPolicyClientOwned
554		}	554		}
555			555
556		l.mu.RLock()	556		l.mu.RLock()

@@ -568,7 +568,7 @@ func (l *routeLedger) samePeerHandoff(active AttachRequest, target ports.AttachT
568		// original discovery target would make its Hello request a second,	568		// original discovery target would make its Hello request a second,
569		// incorrect remote handoff instead of a same-peer session switch.	569		// incorrect remote handoff instead of a same-peer session switch.
570		request.RemoteTarget = nil	570		request.RemoteTarget = nil
571	-	if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == ports.EnvironmentPolicyClientOwned {	571	+	if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == protocol.EnvironmentPolicyClientOwned {
572		request.NavigationCapabilities = 0	572		request.NavigationCapabilities = 0
573		request.StartupOverlay = protocol.StartupOverlayNone	573		request.StartupOverlay = protocol.StartupOverlayNone
574		}	574		}

@@ -586,7 +586,7 @@ func (l *routeLedger) samePeerHandoff(active AttachRequest, target ports.AttachT
586		request.ExactTarget = target.ExactTarget	586		request.ExactTarget = target.ExactTarget
587		request.PreferredTabID = ""	587		request.PreferredTabID = ""
588		request.RemoteTarget = nil	588		request.RemoteTarget = nil
589	-	if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == ports.EnvironmentPolicyClientOwned {	589	+	if request.EnvironmentPolicy != environmentPolicy && environmentPolicy == protocol.EnvironmentPolicyClientOwned {
590		request.NavigationCapabilities = 0	590		request.NavigationCapabilities = 0
591		request.StartupOverlay = protocol.StartupOverlayNone	591		request.StartupOverlay = protocol.StartupOverlayNone
592		}	592		}

M internal/usecase/client/routes_test.go +17 -18

 	"testing"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 			reachability: protocol.RouteReachabilityReachable,
 		},
 		request: AttachRequest{
-			Intent:      ports.IntentAttach,
+			Intent:      protocol.IntentAttach,
 			SessionName: target.SessionName,
 			Origin:      origin,
 		},
 func TestRouteCandidateRetainsHostLabelWithoutDiscoveryTarget(t *testing.T) {
 	target := routeTestTarget(1)
 	candidate := routeCandidateForAttach(AttachRequest{
-		Intent: ports.IntentAttach, SessionName: target.SessionName, Remote: true,
+		Intent: protocol.IntentAttach, SessionName: target.SessionName, Remote: true,
 		Origin: protocol.RouteOriginRemote, OriginKey: "user@remote", HostLabel: "remote",
 	}, protocol.CommittedRouteIdentity{Target: target}, nil, 0)
 		{name: "recreated session does not reuse remembered tab", target: recreated, wantExactTarget: &recreated},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
-			request := ledger.samePeerHandoff(second.request, ports.AttachTarget{
+			request := ledger.samePeerHandoff(second.request, protocol.AttachTarget{
 				Session:           first.target.SessionName,
-				Intent:            ports.IntentAttach,
+				Intent:            protocol.IntentAttach,
 				ExactTarget:       &tt.target,
-				EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			})
 			require.Equal(t, first.target.SessionName, request.SessionName)
 			require.Equal(t, tt.wantExactTarget, request.ExactTarget)
 			require.Equal(t, tt.wantTab, request.PreferredTabID)
-			require.Equal(t, ports.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
+			require.Equal(t, protocol.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
 		})
 	}
 }
 func TestRouteLedgerSamePeerHandoffClearsDaemonOwnedNavigationForLocalRoutes(t *testing.T) {
 	active := routeTestCandidate(2, protocol.RouteOriginLocal)
 	active.originKey = "local"
-	active.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	active.request.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 	active.request.NavigationCapabilities = protocol.NavigationCapabilityHomePicker
 	active.request.StartupOverlay = protocol.StartupOverlaySessionPicker
 			if tt.matched {
 				stored := routeTestCandidate(1, protocol.RouteOriginLocal)
 				stored.originKey = "local"
-				stored.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+				stored.request.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 				stored.request.NavigationCapabilities = protocol.NavigationCapabilityHomePicker
 				stored.request.StartupOverlay = protocol.StartupOverlaySessionPicker
 				_, err := ledger.commit(stored)
 				require.NoError(t, err)
 			}
-			request := ledger.samePeerHandoff(active.request, ports.AttachTarget{
+			request := ledger.samePeerHandoff(active.request, protocol.AttachTarget{
-				Session: target.SessionName, Intent: ports.IntentAttach, ExactTarget: &target,
+				Session: target.SessionName, Intent: protocol.IntentAttach, ExactTarget: &target,
-				EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			})
-			require.Equal(t, ports.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
+			require.Equal(t, protocol.EnvironmentPolicyClientOwned, request.EnvironmentPolicy)
 			require.Zero(t, request.NavigationCapabilities)
 			require.Equal(t, protocol.StartupOverlayNone, request.StartupOverlay)
 			require.NoError(t, validateAttachRequest(request))
 	work.originKey = "remote"
 	work.request.Remote = true
 	work.request.OriginKey = "remote"
-	work.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	work.request.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 	work.request.RemoteTarget = &domain.RemoteSessionTarget{
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: work.target.LifecycleID,
 		SessionName: work.target.SessionName, LiveTabID: "tab-work",
 	agents.originKey = "remote"
 	agents.request.Remote = true
 	agents.request.OriginKey = "remote"
-	agents.request.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	agents.request.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
-	request := ledger.samePeerHandoff(agents.request, ports.AttachTarget{
+	request := ledger.samePeerHandoff(agents.request, protocol.AttachTarget{
 		Session:           work.target.SessionName,
-		Intent:            ports.IntentAttach,
+		Intent:            protocol.IntentAttach,
 		ExactTarget:       &work.target,
-		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	})
 	require.True(t, request.Remote)

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


@@ -24,7 +24,7 @@ func TestCloseAndDialAttachTargetSkipsSamePeerSwitch(t *testing.T) {
24		term.term,	24		term.term,
25		transport,	25		transport,
26		newReconnectHandshakeClock(t),	26		newReconnectHandshakeClock(t),
27	-	AttachRequest{Intent: ports.IntentAttach, SessionName: "source"},	27	+	AttachRequest{Intent: protocol.IntentAttach, SessionName: "source"},
28		0,	28		0,
29		&terminalThemeState{},	29		&terminalThemeState{},
30		nil,	30		nil,

@@ -35,9 +35,9 @@ func TestCloseAndDialAttachTargetSkipsSamePeerSwitch(t *testing.T) {
35		go func() { resultCh <- attempt.run(ctx) }()	35		go func() { resultCh <- attempt.run(ctx) }()
36			36
37		exact := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{7}, SessionName: "stopped"}	37		exact := protocol.ExactSessionTarget{LifecycleID: domain.SessionLifecycleID{7}, SessionName: "stopped"}
38	-	target := ports.AttachTarget{	38	+	target := protocol.AttachTarget{
39	-	Session: "stopped", Intent: ports.IntentAttach, ExactTarget: &exact,	39	+	Session: "stopped", Intent: protocol.IntentAttach, ExactTarget: &exact,
40	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	40	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
41		}	41		}
42		transport.recvCh <- reconnectToastRecv{frame: ports.Frame{	42		transport.recvCh <- reconnectToastRecv{frame: ports.Frame{
43		Type: ports.MsgAttachTarget, Payload: ports.MarshalAttachTarget(target),	43		Type: ports.MsgAttachTarget, Payload: ports.MarshalAttachTarget(target),

M internal/usecase/client/session_connection.go +3 -2

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 var (
 func (t SessionTarget) validate() error {
 	switch t.Intent {
-	case ports.IntentEphemeral:
+	case protocol.IntentEphemeral:
 		if t.SessionName != "" {
 			return ErrEphemeralSessionName
 		}
 		return nil
-	case ports.IntentNew, ports.IntentAttach, ports.IntentResume:
+	case protocol.IntentNew, protocol.IntentAttach, protocol.IntentResume:
 		if t.SessionName == "" {
 			return domain.ErrInvalidSessionName
 		}

M internal/usecase/client/session_connection_test.go +11 -11

 import (
 	"testing"
-	"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"
 )
 func TestSessionConnectionUsesOneAttachShapeForLocalAndRemoteTransports(t *testing.T) {
-	target := client.SessionTarget{Intent: ports.IntentAttach, SessionName: "work"}
+	target := client.SessionTarget{Intent: protocol.IntentAttach, SessionName: "work"}
 	local := portsmocks.NewMockTransport(t)
 	remote := portsmocks.NewMockTransport(t)
 	require.NoError(t, err)
 	require.Equal(t, localConnection.AttachRequest(), remoteConnection.AttachRequest())
-	require.Equal(t, client.AttachRequest{Intent: ports.IntentAttach, SessionName: "work"}, localConnection.AttachRequest())
+	require.Equal(t, client.AttachRequest{Intent: protocol.IntentAttach, SessionName: "work"}, localConnection.AttachRequest())
 	require.Same(t, local, localConnection.Transport())
 	require.Same(t, remote, remoteConnection.Transport())
 }
 		wantErr   bool
 		wantErrIs error
 	}{
-		{name: "ephemeral", target: client.SessionTarget{Intent: ports.IntentEphemeral}},
+		{name: "ephemeral", target: client.SessionTarget{Intent: protocol.IntentEphemeral}},
-		{name: "named ephemeral", target: client.SessionTarget{Intent: ports.IntentEphemeral, SessionName: "work"}, wantErr: true, wantErrIs: client.ErrEphemeralSessionName},
+		{name: "named ephemeral", target: client.SessionTarget{Intent: protocol.IntentEphemeral, SessionName: "work"}, wantErr: true, wantErrIs: client.ErrEphemeralSessionName},
-		{name: "new", target: client.SessionTarget{Intent: ports.IntentNew, SessionName: "work"}},
+		{name: "new", target: client.SessionTarget{Intent: protocol.IntentNew, SessionName: "work"}},
-		{name: "attach", target: client.SessionTarget{Intent: ports.IntentAttach, SessionName: "work"}},
+		{name: "attach", target: client.SessionTarget{Intent: protocol.IntentAttach, SessionName: "work"}},
-		{name: "resume", target: client.SessionTarget{Intent: ports.IntentResume, SessionName: "work"}},
+		{name: "resume", target: client.SessionTarget{Intent: protocol.IntentResume, SessionName: "work"}},
-		{name: "missing named session", target: client.SessionTarget{Intent: ports.IntentAttach}, wantErr: true},
+		{name: "missing named session", target: client.SessionTarget{Intent: protocol.IntentAttach}, wantErr: true},
-		{name: "unsafe session", target: client.SessionTarget{Intent: ports.IntentAttach, SessionName: "my work"}, wantErr: true},
+		{name: "unsafe session", target: client.SessionTarget{Intent: protocol.IntentAttach, SessionName: "my work"}, wantErr: true},
 		{name: "unknown intent", target: client.SessionTarget{Intent: 99, SessionName: "work"}, wantErr: true},
 	}
 	for _, tt := range tests {
 }
 func TestSessionConnectionRequiresTransport(t *testing.T) {
-	_, err := client.NewSessionConnection(nil, client.SessionTarget{Intent: ports.IntentEphemeral})
+	_, err := client.NewSessionConnection(nil, client.SessionTarget{Intent: protocol.IntentEphemeral})
 	require.Error(t, err)
 }

M internal/usecase/client/transition_ui.go +3 -2

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 const (
 var transitionSpinnerFrames = [...]rune{'⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'}
-func transitionMessage(target ports.AttachTarget) string {
+func transitionMessage(target protocol.AttachTarget) string {
 	origin := target.Endpoint
 	if target.RemoteTarget != nil && target.RemoteTarget.DisplayOrigin != "" {
 		origin = target.RemoteTarget.DisplayOrigin
 	return &transitionUI{term: term, clock: clock, rawEntered: rawEntered}
 }
-func (u *transitionUI) start(target ports.AttachTarget) {
+func (u *transitionUI) start(target protocol.AttachTarget) {
 	if u == nil {
 		return
 	}

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestTransitionMessageDescribesSwitchAndStoppedRestore(t *testing.T) {
-	live := ports.AttachTarget{Endpoint: "remote", Session: "work"}
+	live := protocol.AttachTarget{Endpoint: "remote", Session: "work"}
 	stoppedTarget := domain.RemoteSessionTarget{
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: domain.SessionLifecycleID{1},
 		SessionName: "work", Stopped: true, StoppedTab: domain.NewStableTabSelector("tab-1"),
 	}
-	stopped := ports.AttachTarget{Endpoint: "remote", Session: "work", RemoteTarget: &stoppedTarget}
+	stopped := protocol.AttachTarget{Endpoint: "remote", Session: "work", RemoteTarget: &stoppedTarget}
 	require.Equal(t, "Switching to work@remote…", transitionMessage(live))
 	require.Equal(t, "Starting work@remote…", transitionMessage(stopped))
 			term := &transitionTestTerminal{}
 			raw := tt.raw
 			ui := newTransitionUI(term, clock, &raw)
-			ui.start(ports.AttachTarget{Endpoint: "remote", Session: "work"})
+			ui.start(protocol.AttachTarget{Endpoint: "remote", Session: "work"})
 			require.Equal(t, []time.Duration{transitionSpinnerDelay}, clock.delays)
 			require.NotNil(t, ui.tickC())

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


@@ -50,7 +50,7 @@ func TestBlockingRuntimeObserverDoesNotDelayTerminalFlushOrACK(t *testing.T) {
50		transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	50		transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
51		transport.EXPECT().Send(isType(ports.MsgAck)).Run(func(ports.Frame) { close(acked) }).Return(nil).Once()	51		transport.EXPECT().Send(isType(ports.MsgAck)).Run(func(ports.Frame) { close(acked) }).Return(nil).Once()
52		unblock := scriptRecv(transport,	52		unblock := scriptRecv(transport,
53	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	53	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
54		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}))},	54		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}))},
55		)	55		)
56		defer unblock()	56		defer unblock()

@@ -59,7 +59,7 @@ func TestBlockingRuntimeObserverDoesNotDelayTerminalFlushOrACK(t *testing.T) {
59		ctx, cancel := context.WithCancel(context.Background())	59		ctx, cancel := context.WithCancel(context.Background())
60		result := make(chan error, 1)	60		result := make(chan error, 1)
61		go func() {	61		go func() {
62	-	result <- runTestClient(ctx, testDependencies(transportDialer{transport: transport}, term, realClock{}, nil, reporter), client.AttachRequest{Intent: ports.IntentEphemeral})	62	+	result <- runTestClient(ctx, testDependencies(transportDialer{transport: transport}, term, realClock{}, nil, reporter), client.AttachRequest{Intent: protocol.IntentEphemeral})
63		}()	63		}()
64		awaitClientRuntime(t, observer.entered, "blocking observer")	64		awaitClientRuntime(t, observer.entered, "blocking observer")
65		awaitClientRuntime(t, flushed, "terminal flush")	65		awaitClientRuntime(t, flushed, "terminal flush")

@@ -90,15 +90,15 @@ func TestTerminalFlushBoundaryTransportObservability(t *testing.T) {
90		transport.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()	90		transport.EXPECT().Send(isType(ports.MsgHello)).Return(nil).Once()
91		transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()	91		transport.EXPECT().Send(isType(ports.MsgTheme)).Return(nil).Maybe()
92		unblock := scriptRecv(transport,	92		unblock := scriptRecv(transport,
93	-	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(ports.Welcome{SessionID: "s1"}))},	93	+	recvItem{f: frameOf(ports.MsgWelcome, ports.MarshalWelcome(protocol.Welcome{SessionID: "s1"}))},
94		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}))},	94		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}))},
95	-	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(ports.Detached{Reason: ports.ReasonDetach}))},	95	+	recvItem{f: frameOf(ports.MsgDetached, ports.MarshalDetached(protocol.Detached{Reason: protocol.ReasonDetach}))},
96		)	96		)
97		defer unblock()	97		defer unblock()
98		transport.EXPECT().Send(isType(ports.MsgAck)).Return(nil).Maybe()	98		transport.EXPECT().Send(isType(ports.MsgAck)).Return(nil).Maybe()
99		transport.EXPECT().Close().Return(nil).Once()	99		transport.EXPECT().Close().Return(nil).Once()
100			100
101	-	err := runTestClient(context.Background(), testDependencies(transportDialer{transport: transport}, term, realClock{}, nil, reporter), client.AttachRequest{Intent: ports.IntentEphemeral})	101	+	err := runTestClient(context.Background(), testDependencies(transportDialer{transport: transport}, term, realClock{}, nil, reporter), client.AttachRequest{Intent: protocol.IntentEphemeral})
102		require.NoError(t, err)	102		require.NoError(t, err)
103		reporter.Flush()	103		reporter.Flush()
104		require.Equal(t, "\x1b]10;?\x07\x1b]11;?\x07\x1b]4;0;?;1;?;2;?;3;?;4;?;5;?;6;?;7;?;8;?;9;?;10;?;11;?;12;?;13;?;14;?;15;?\x07\x1b[?2031$punchanged-by-observer", out.String(), "observer must not alter terminal bytes")	104		require.Equal(t, "\x1b]10;?\x07\x1b]11;?\x07\x1b]4;0;?;1;?;2;?;3;?;4;?;5;?;6;?;7;?;8;?;9;?;10;?;11;?;12;?;13;?;14;?;15;?\x07\x1b[?2031$punchanged-by-observer", out.String(), "observer must not alter terminal bytes")

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


@@ -250,7 +250,7 @@ func TestKillSessionAcquisitionTimeoutDoesNotPublishPartialInvalidation(t *testi
250		frozenByKill := make(chan *attachedClient, 3)	250		frozenByKill := make(chan *attachedClient, 3)
251		d.afterAttachmentEffectGateFrozen = func(_ string, ac *attachedClient) { frozenByKill <- ac }	251		d.afterAttachmentEffectGateFrozen = func(_ string, ac *attachedClient) { frozenByKill <- ac }
252		killDone := make(chan error, 1)	252		killDone := make(chan error, 1)
253	-	go func() { killDone <- d.killSession(sess, ports.ReasonSessionKilled, false) }()	253	+	go func() { killDone <- d.killSession(sess, protocol.ReasonSessionKilled, false) }()
254			254
255		require.Same(t, first, awaitTestValue(t, frozenByKill, "teardown did not acquire the first attachment effect gate"))	255		require.Same(t, first, awaitTestValue(t, frozenByKill, "teardown did not acquire the first attachment effect gate"))
256		deadline := awaitTestValue(t, clock.timers, "teardown did not arm the gate acquisition deadline")	256		deadline := awaitTestValue(t, clock.timers, "teardown did not arm the gate acquisition deadline")

@@ -343,7 +343,7 @@ func TestKillSessionInterruptsOnlyExactParticipantBlockedSends(t *testing.T) {
343		awaitTestCompletion(t, activeTransport.sendEntered, "active send did not block")	343		awaitTestCompletion(t, activeTransport.sendEntered, "active send did not block")
344			344
345		killDone := make(chan error, 1)	345		killDone := make(chan error, 1)
346	-	go func() { killDone <- d.killSession(sess, ports.ReasonSessionKilled, false) }()	346	+	go func() { killDone <- d.killSession(sess, protocol.ReasonSessionKilled, false) }()
347		select {	347		select {
348		case err := <-killDone:	348		case err := <-killDone:
349		require.NoError(t, err)	349		require.NoError(t, err)

@@ -380,7 +380,7 @@ func TestKillSessionInterruptsCapturedSendWithoutClosingNewerIncarnation(t *test
380		ac.replaceTransport(fresh)	380		ac.replaceTransport(fresh)
381		}	381		}
382			382
383	-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))	383	+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
384		awaitTestCompletion(t, sendDone, "captured incarnation attachment effect ticket did not retire")	384		awaitTestCompletion(t, sendDone, "captured incarnation attachment effect ticket did not retire")
385		require.True(t, stale.Closed(), "exact captured in-flight transport was not interrupted")	385		require.True(t, stale.Closed(), "exact captured in-flight transport was not interrupted")
386		require.False(t, fresh.Closed(), "newer transport incarnation was interrupted")	386		require.False(t, fresh.Closed(), "newer transport incarnation was interrupted")

@@ -408,7 +408,7 @@ func TestShutdownSignalsServeWhenParticipantGateAcquisitionTimesOut(t *testing.T
408		clock := &signalClock{timers: make(chan *signalTimer, 1)}	408		clock := &signalClock{timers: make(chan *signalTimer, 1)}
409		d.clock = clock	409		d.clock = clock
410		shutdownDone := make(chan bool, 1)	410		shutdownDone := make(chan bool, 1)
411	-	go func() { shutdownDone <- d.shutdownAll(ports.ReasonServerShutdown) }()	411	+	go func() { shutdownDone <- d.shutdownAll(protocol.ReasonServerShutdown) }()
412			412
413		deadline := awaitTestValue(t, clock.timers, "shutdown did not arm the gate acquisition deadline")	413		deadline := awaitTestValue(t, clock.timers, "shutdown did not arm the gate acquisition deadline")
414		deadline.ch <- clock.Now()	414		deadline.ch <- clock.Now()

@@ -437,7 +437,7 @@ func TestShutdownInterruptsBlockedParticipantSend(t *testing.T) {
437		awaitTestCompletion(t, blocked.sendEntered, "active send did not block")	437		awaitTestCompletion(t, blocked.sendEntered, "active send did not block")
438			438
439		shutdownDone := make(chan bool, 1)	439		shutdownDone := make(chan bool, 1)
440	-	go func() { shutdownDone <- d.shutdownAll(ports.ReasonServerShutdown) }()	440	+	go func() { shutdownDone <- d.shutdownAll(protocol.ReasonServerShutdown) }()
441		select {	441		select {
442		case incomplete := <-shutdownDone:	442		case incomplete := <-shutdownDone:
443		require.False(t, incomplete)	443		require.False(t, incomplete)

@@ -726,8 +726,8 @@ func TestAttachedNavigationCommandSendsResultAfterLocalTransition(t *testing.T)
726		token := source.captureAttachmentCapability(ac, transport)	726		token := source.captureAttachmentCapability(ac, transport)
727		token.lease = rc.attachmentLease(ac)	727		token.lease = rc.attachmentLease(ac)
728		ac.installTestAttachmentCapability(token)	728		ac.installTestAttachmentCapability(token)
729	-	payload, err := ports.MarshalCommandRequest(ports.CommandRequest{	729	+	payload, err := ports.MarshalCommandRequest(protocol.CommandRequest{
730	-	Version: ports.ProtocolVersion, RequestID: 1, Slug: "back-session", Attached: true,	730	+	Version: protocol.Version, RequestID: 1, Slug: "back-session", Attached: true,
731		})	731		})
732		require.NoError(t, err)	732		require.NoError(t, err)
733			733

@@ -735,7 +735,7 @@ func TestAttachedNavigationCommandSendsResultAfterLocalTransition(t *testing.T)
735		require.Same(t, source, ac.currentAttachmentSession())	735		require.Same(t, source, ac.currentAttachmentSession())
736		frames := transport.Sends()	736		frames := transport.Sends()
737		require.NotEmpty(t, frames)	737		require.NotEmpty(t, frames)
738	-	var result ports.CommandResult	738	+	var result protocol.CommandResult
739		for _, frame := range frames {	739		for _, frame := range frames {
740		if frame.Type != ports.MsgCommandResult {	740		if frame.Type != ports.MsgCommandResult {
741		continue	741		continue

M internal/usecase/daemon/attachment_output.go +1 -1


@@ -42,7 +42,7 @@ type attachmentOutput struct {
42			42
43		// reconfigureAttachmentOutput applies a replacement terminal's declared	43		// reconfigureAttachmentOutput applies a replacement terminal's declared
44		// capabilities to attachment-owned output state. Caller holds d.mu.	44		// capabilities to attachment-owned output state. Caller holds d.mu.
45	-	func (d Daemon) reconfigureAttachmentOutput(sess session, ac *attachedClient, h ports.Hello) {	45	+	func (d Daemon) reconfigureAttachmentOutput(sess session, ac *attachedClient, h protocol.Hello) {
46		if d == nil \|\| ac == nil \|\| ac.output == nil {	46		if d == nil \|\| ac == nil \|\| ac.output == nil {
47		return	47		return
48		}	48		}

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


@@ -24,10 +24,10 @@ func TestAttachmentLossParksOnlyThatAttachment(t *testing.T) {
24		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	24		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
25			25
26		firstTransport := &closeTrackingTransport{}	26		firstTransport := &closeTrackingTransport{}
27	-	sess, first, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), firstTransport)	27	+	sess, first, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), firstTransport)
28		require.NoError(t, err)	28		require.NoError(t, err)
29		secondTransport := &closeTrackingTransport{}	29		secondTransport := &closeTrackingTransport{}
30	-	_, second, err := d.route(helloResumeCapable(ports.IntentAttach, "work", 0), secondTransport)	30	+	_, second, err := d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), secondTransport)
31		require.NoError(t, err)	31		require.NoError(t, err)
32			32
33		d.clientGone(sess, first, firstTransport, false)	33		d.clientGone(sess, first, firstTransport, false)

@@ -51,10 +51,10 @@ func TestTwoAttachmentsParkIndependently(t *testing.T) {
51		defer release()	51		defer release()
52		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	52		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
53		firstTransport := &closeTrackingTransport{}	53		firstTransport := &closeTrackingTransport{}
54	-	sess, first, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), firstTransport)	54	+	sess, first, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), firstTransport)
55		require.NoError(t, err)	55		require.NoError(t, err)
56		secondTransport := &closeTrackingTransport{}	56		secondTransport := &closeTrackingTransport{}
57	-	_, second, err := d.route(helloResumeCapable(ports.IntentAttach, "work", 0), secondTransport)	57	+	_, second, err := d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), secondTransport)
58		require.NoError(t, err)	58		require.NoError(t, err)
59		firstToken, secondToken := first.resumeToken, second.resumeToken	59		firstToken, secondToken := first.resumeToken, second.resumeToken
60			60

@@ -76,10 +76,10 @@ func TestParkExpiryRemovesOnlyOneAttachment(t *testing.T) {
76		defer release()	76		defer release()
77		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	77		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
78		firstTransport := &closeTrackingTransport{}	78		firstTransport := &closeTrackingTransport{}
79	-	sess, first, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), firstTransport)	79	+	sess, first, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), firstTransport)
80		require.NoError(t, err)	80		require.NoError(t, err)
81		secondTransport := &closeTrackingTransport{}	81		secondTransport := &closeTrackingTransport{}
82	-	_, second, err := d.route(helloResumeCapable(ports.IntentAttach, "work", 0), secondTransport)	82	+	_, second, err := d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), secondTransport)
83		require.NoError(t, err)	83		require.NoError(t, err)
84		d.clientGone(sess, first, firstTransport, false)	84		d.clientGone(sess, first, firstTransport, false)
85		d.clientGone(sess, second, secondTransport, false)	85		d.clientGone(sess, second, secondTransport, false)

@@ -101,14 +101,14 @@ func TestResumeRotatesCredentialAndRejectsStaleTransport(t *testing.T) {
101		defer release()	101		defer release()
102		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	102		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
103		oldTransport := &closeTrackingTransport{}	103		oldTransport := &closeTrackingTransport{}
104	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	104	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
105		require.NoError(t, err)	105		require.NoError(t, err)
106		oldToken := ac.resumeToken	106		oldToken := ac.resumeToken
107		oldGeneration := ac.lifecycle.generationValue()	107		oldGeneration := ac.lifecycle.generationValue()
108		d.clientGone(sess, ac, oldTransport, false)	108		d.clientGone(sess, ac, oldTransport, false)
109			109
110		newTransport := &closeTrackingTransport{}	110		newTransport := &closeTrackingTransport{}
111	-	resumed, same, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", oldToken), newTransport, defaultSize)	111	+	resumed, same, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", oldToken), newTransport, defaultSize)
112		require.NoError(t, err)	112		require.NoError(t, err)
113		require.True(t, ok)	113		require.True(t, ok)
114		require.Same(t, sess, resumed)	114		require.Same(t, sess, resumed)

@@ -135,14 +135,14 @@ func TestSuccessfulResumeRejectsOldCredentialAfterWelcome(t *testing.T) {
135		defer release()	135		defer release()
136		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	136		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
137		oldTransport := &closeTrackingTransport{}	137		oldTransport := &closeTrackingTransport{}
138	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	138	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
139		require.NoError(t, err)	139		require.NoError(t, err)
140		oldToken := ac.resumeToken	140		oldToken := ac.resumeToken
141		ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})	141		ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1})
142		d.clientGone(sess, ac, oldTransport, false)	142		d.clientGone(sess, ac, oldTransport, false)
143			143
144		resumedTransport := &closeTrackingTransport{}	144		resumedTransport := &closeTrackingTransport{}
145	-	d.handleHello(resumedTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(ports.IntentResume, "work", oldToken))})	145	+	d.handleHello(resumedTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", oldToken))})
146		newToken := ac.resumeToken	146		newToken := ac.resumeToken
147		require.NotEqual(t, oldToken, newToken)	147		require.NotEqual(t, oldToken, newToken)
148		d.mu.Lock()	148		d.mu.Lock()

@@ -160,13 +160,13 @@ func TestFailedResumeHandshakeKeepsParkedCredential(t *testing.T) {
160		defer release()	160		defer release()
161		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	161		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
162		oldTransport := &closeTrackingTransport{}	162		oldTransport := &closeTrackingTransport{}
163	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	163	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
164		require.NoError(t, err)	164		require.NoError(t, err)
165		token := ac.resumeToken	165		token := ac.resumeToken
166		d.clientGone(sess, ac, oldTransport, false)	166		d.clientGone(sess, ac, oldTransport, false)
167			167
168		failed := &resumeWelcomeFailureTransport{}	168		failed := &resumeWelcomeFailureTransport{}
169	-	d.handleHello(failed, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(ports.IntentResume, "work", token))})	169	+	d.handleHello(failed, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, "work", token))})
170		require.Nil(t, ac.transport())	170		require.Nil(t, ac.transport())
171		d.mu.Lock()	171		d.mu.Lock()
172		parked := d.parked[token]	172		parked := d.parked[token]

@@ -176,7 +176,7 @@ func TestFailedResumeHandshakeKeepsParkedCredential(t *testing.T) {
176		require.False(t, claimed)	176		require.False(t, claimed)
177		require.Equal(t, token, ac.resumeToken)	177		require.Equal(t, token, ac.resumeToken)
178			178
179	-	_, resumed, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)	179	+	_, resumed, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)
180		require.NoError(t, err)	180		require.NoError(t, err)
181		require.True(t, ok)	181		require.True(t, ok)
182		require.Same(t, ac, resumed)	182		require.Same(t, ac, resumed)

@@ -187,7 +187,7 @@ func TestConcurrentResumeHasExactlyOneWinner(t *testing.T) {
187		defer release()	187		defer release()
188		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	188		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
189		oldTransport := &closeTrackingTransport{}	189		oldTransport := &closeTrackingTransport{}
190	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	190	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
191		require.NoError(t, err)	191		require.NoError(t, err)
192		token := ac.resumeToken	192		token := ac.resumeToken
193		d.clientGone(sess, ac, oldTransport, false)	193		d.clientGone(sess, ac, oldTransport, false)

@@ -199,7 +199,7 @@ func TestConcurrentResumeHasExactlyOneWinner(t *testing.T) {
199		results := make(chan result, 2)	199		results := make(chan result, 2)
200		for range 2 {	200		for range 2 {
201		go func() {	201		go func() {
202	-	_, _, ok, resumeErr := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)	202	+	_, _, ok, resumeErr := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)
203		results <- result{ok: ok, err: resumeErr}	203		results <- result{ok: ok, err: resumeErr}
204		}()	204		}()
205		}	205		}

@@ -219,18 +219,18 @@ func TestKillSessionClosesEveryAttachmentAndParkedCredential(t *testing.T) {
219		defer release()	219		defer release()
220		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	220		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
221		firstTransport := &closeTrackingTransport{}	221		firstTransport := &closeTrackingTransport{}
222	-	sess, _, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), firstTransport)	222	+	sess, _, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), firstTransport)
223		require.NoError(t, err)	223		require.NoError(t, err)
224		secondTransport := &closeTrackingTransport{}	224		secondTransport := &closeTrackingTransport{}
225	-	_, _, err = d.route(helloResumeCapable(ports.IntentAttach, "work", 0), secondTransport)	225	+	_, _, err = d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), secondTransport)
226		require.NoError(t, err)	226		require.NoError(t, err)
227		parkedTransport := &closeTrackingTransport{}	227		parkedTransport := &closeTrackingTransport{}
228	-	_, parkedAttachment, err := d.route(helloResumeCapable(ports.IntentAttach, "work", 0), parkedTransport)	228	+	_, parkedAttachment, err := d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), parkedTransport)
229		require.NoError(t, err)	229		require.NoError(t, err)
230		d.clientGone(sess, parkedAttachment, parkedTransport, false)	230		d.clientGone(sess, parkedAttachment, parkedTransport, false)
231		parkedToken := parkedAttachment.resumeToken	231		parkedToken := parkedAttachment.resumeToken
232			232
233	-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))	233	+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
234		d.waitNotifies()	234		d.waitNotifies()
235		require.True(t, firstTransport.Closed())	235		require.True(t, firstTransport.Closed())
236		require.True(t, secondTransport.Closed())	236		require.True(t, secondTransport.Closed())

@@ -246,14 +246,14 @@ func TestResumeCredentialIsInvalidAfterDaemonRestart(t *testing.T) {
246		defer release()	246		defer release()
247		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	247		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
248		transport := &closeTrackingTransport{}	248		transport := &closeTrackingTransport{}
249	-	_, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), transport)	249	+	_, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), transport)
250		require.NoError(t, err)	250		require.NoError(t, err)
251		token := ac.resumeToken	251		token := ac.resumeToken
252		restarted := newTestDaemon(t, newFactory(t, pty), stubClock{})	252		restarted := newTestDaemon(t, newFactory(t, pty), stubClock{})
253	-	_, _, err = restarted.route(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{})	253	+	_, _, err = restarted.route(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{})
254		var protocolErr *protoErr	254		var protocolErr *protoErr
255		require.ErrorAs(t, err, &protocolErr)	255		require.ErrorAs(t, err, &protocolErr)
256	-	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)	256	+	require.Equal(t, protocol.ErrNoSuchSession, protocolErr.code)
257		}	257		}
258			258
259		func TestHandleHelloAllowsMultipleAttachments(t *testing.T) {	259		func TestHandleHelloAllowsMultipleAttachments(t *testing.T) {

@@ -261,10 +261,10 @@ func TestHandleHelloAllowsMultipleAttachments(t *testing.T) {
261		defer release()	261		defer release()
262		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	262		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
263		firstTransport := &closeTrackingTransport{}	263		firstTransport := &closeTrackingTransport{}
264	-	sess, first, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), firstTransport)	264	+	sess, first, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), firstTransport)
265		require.NoError(t, err)	265		require.NoError(t, err)
266		secondTransport := &closeTrackingTransport{}	266		secondTransport := &closeTrackingTransport{}
267	-	_, second, err := d.route(helloResumeCapable(ports.IntentAttach, "work", 0), secondTransport)	267	+	_, second, err := d.route(helloResumeCapable(protocol.IntentAttach, "work", 0), secondTransport)
268		require.NoError(t, err)	268		require.NoError(t, err)
269		require.Equal(t, true, sess.attachmentRegistered(first))	269		require.Equal(t, true, sess.attachmentRegistered(first))
270		require.Equal(t, true, sess.attachmentRegistered(second))	270		require.Equal(t, true, sess.attachmentRegistered(second))

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


@@ -103,14 +103,14 @@ func TestAttachmentResizeKeepsPeerWindowAndExpandsSharedContent(t *testing.T) {
103		defer releasePTY()	103		defer releasePTY()
104		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	104		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
105		firstTransport, _ := newCapturingTransport(t)	105		firstTransport, _ := newCapturingTransport(t)
106	-	sess, first, err := d.route(ports.Hello{	106	+	sess, first, err := d.route(protocol.Hello{
107	-	Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work",	107	+	Version: protocol.Version, Intent: protocol.IntentNew, Name: "work",
108		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},	108		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},
109		}, firstTransport)	109		}, firstTransport)
110		require.NoError(t, err)	110		require.NoError(t, err)
111		secondTransport, _ := newCapturingTransport(t)	111		secondTransport, _ := newCapturingTransport(t)
112	-	_, second, err := d.route(ports.Hello{	112	+	_, second, err := d.route(protocol.Hello{
113	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",	113	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
114		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},	114		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},
115		}, secondTransport)	115		}, secondTransport)
116		require.NoError(t, err)	116		require.NoError(t, err)

@@ -147,10 +147,10 @@ func TestAttachmentFirstPaintDoesNotWaitForBlockedPeer(t *testing.T) {
147		clock := &signalClock{timers: make(chan *signalTimer, 16)}	147		clock := &signalClock{timers: make(chan *signalTimer, 16)}
148		d := newTestDaemon(t, newFactory(t, pty), clock)	148		d := newTestDaemon(t, newFactory(t, pty), clock)
149		oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}	149		oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
150	-	sess, old, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)	150	+	sess, old, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)
151		require.NoError(t, err)	151		require.NoError(t, err)
152		newTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}	152		newTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
153	-	_, fresh, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, newTransport)	153	+	_, fresh, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, newTransport)
154		require.NoError(t, err)	154		require.NoError(t, err)
155			155
156		rc := sess.renderCoordinator()	156		rc := sess.renderCoordinator()

@@ -183,7 +183,7 @@ func TestMultiAttachmentHandshakeFirstPaintNotGatedByBlockedPeer(t *testing.T) {
183		clock := &signalClock{timers: make(chan *signalTimer, 16)}	183		clock := &signalClock{timers: make(chan *signalTimer, 16)}
184		d := newTestDaemon(t, newFactory(t, pty), clock)	184		d := newTestDaemon(t, newFactory(t, pty), clock)
185		oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}	185		oldTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
186	-	sess, old, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)	186	+	sess, old, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, oldTransport)
187		require.NoError(t, err)	187		require.NoError(t, err)
188		rc := sess.renderCoordinator()	188		rc := sess.renderCoordinator()
189		require.True(t, rc.markAttachmentReady(rc.attachmentLease(old)))	189		require.True(t, rc.markAttachmentReady(rc.attachmentLease(old)))

@@ -201,7 +201,7 @@ func TestMultiAttachmentHandshakeFirstPaintNotGatedByBlockedPeer(t *testing.T) {
201		}()	201		}()
202		awaitTestCompletion(t, oldTransport.entered, "slow attachment did not begin its blocked output")	202		awaitTestCompletion(t, oldTransport.entered, "slow attachment did not begin its blocked output")
203			203
204	-	hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}	204	+	hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}
205		tr, sends, releaseConn := newConn(t, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)})	205		tr, sends, releaseConn := newConn(t, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(hello)})
206		defer releaseConn()	206		defer releaseConn()
207		handshakeDone := make(chan struct{})	207		handshakeDone := make(chan struct{})

@@ -223,10 +223,10 @@ func TestAttachmentPaintFanoutDoesNotWaitForBlockedPeer(t *testing.T) {
223		defer releasePTY()	223		defer releasePTY()
224		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	224		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
225		firstTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}	225		firstTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
226	-	sess, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, firstTransport)	226	+	sess, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1}}, firstTransport)
227		require.NoError(t, err)	227		require.NoError(t, err)
228		secondTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}	228		secondTransport := &blockedAttachmentTransport{entered: make(chan struct{}), release: make(chan struct{}), sends: make(chan ports.Frame, 8)}
229	-	_, _, err = d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, secondTransport)	229	+	_, _, err = d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{2}}, secondTransport)
230		require.NoError(t, err)	230		require.NoError(t, err)
231		rc := sess.renderCoordinator()	231		rc := sess.renderCoordinator()
232		for _, ac := range sess.snapshotAttachments() {	232		for _, ac := range sess.snapshotAttachments() {

@@ -259,14 +259,14 @@ func TestAttachmentResizeUsesLatestClaimedSessionGeometry(t *testing.T) {
259		defer releasePTY()	259		defer releasePTY()
260		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	260		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
261		firstTransport, _ := newCapturingTransport(t)	261		firstTransport, _ := newCapturingTransport(t)
262	-	sess, first, err := d.route(ports.Hello{	262	+	sess, first, err := d.route(protocol.Hello{
263	-	Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work",	263	+	Version: protocol.Version, Intent: protocol.IntentNew, Name: "work",
264		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},	264		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},
265		}, firstTransport)	265		}, firstTransport)
266		require.NoError(t, err)	266		require.NoError(t, err)
267		secondTransport, _ := newCapturingTransport(t)	267		secondTransport, _ := newCapturingTransport(t)
268	-	_, second, err := d.route(ports.Hello{	268	+	_, second, err := d.route(protocol.Hello{
269	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",	269	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
270		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},	270		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},
271		}, secondTransport)	271		}, secondTransport)
272		require.NoError(t, err)	272		require.NoError(t, err)

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


@@ -1016,7 +1016,7 @@ func (d Daemon) resizeAttachmentGeometryForLease(effect attachmentEffect, geom
1016		// attachment-routing operation: attachment publication also takes routingMu	1016		// attachment-routing operation: attachment publication also takes routingMu
1017		// before changing membership. Never retain sess.mu while touching notice or overlay	1017		// before changing membership. Never retain sess.mu while touching notice or overlay
1018		// state, and retain the routingMu -> sess.mu order used by attachment paths.	1018		// state, and retain the routingMu -> sess.mu order used by attachment paths.
1019	-	func (d Daemon) handleClientNotice(sess session, ac *attachedClient, notice ports.ClientNotice) {	1019	+	func (d Daemon) handleClientNotice(sess session, ac *attachedClient, notice protocol.ClientNotice) {
1020		if sess == nil \|\| ac == nil {	1020		if sess == nil \|\| ac == nil {
1021		return	1021		return
1022		}	1022		}

@@ -1036,7 +1036,7 @@ func (d Daemon) handleClientNotice(sess session, ac *attachedClient, notice po
1036		d.handleClientNoticeForAttachment(effect, notice)	1036		d.handleClientNoticeForAttachment(effect, notice)
1037		}	1037		}
1038			1038
1039	-	func (d Daemon) handleClientNoticeForAttachment(effect attachmentEffect, notice ports.ClientNotice) {	1039	+	func (d Daemon) handleClientNoticeForAttachment(effect attachmentEffect, notice protocol.ClientNotice) {
1040		d.notices.routingMu.Lock()	1040		d.notices.routingMu.Lock()
1041		if !effect.current() {	1041		if !effect.current() {
1042		d.notices.routingMu.Unlock()	1042		d.notices.routingMu.Unlock()

@@ -1060,7 +1060,7 @@ func (d Daemon) handleClientNoticeForAttachment(effect attachmentEffect, notic
1060		}	1060		}
1061		}	1061		}
1062			1062
1063	-	func (d Daemon) handleClientNoticeDirect(sess session, ac *attachedClient, notice ports.ClientNotice) {	1063	+	func (d Daemon) handleClientNoticeDirect(sess session, ac *attachedClient, notice protocol.ClientNotice) {
1064		d.notices.routingMu.Lock()	1064		d.notices.routingMu.Lock()
1065		sess.mu.Lock()	1065		sess.mu.Lock()
1066		_, current := sess.attachments[ac]	1066		_, current := sess.attachments[ac]

@@ -1079,15 +1079,15 @@ func (d Daemon) handleClientNoticeDirect(sess session, ac *attachedClient, not
1079		}	1079		}
1080		}	1080		}
1081			1081
1082	-	func (d Daemon) mutateClientNotice(sess session, ac *attachedClient, notice ports.ClientNotice) bool {	1082	+	func (d Daemon) mutateClientNotice(sess session, ac *attachedClient, notice protocol.ClientNotice) bool {
1083		switch notice.Action {	1083		switch notice.Action {
1084	-	case ports.ClientNoticeClipboardFallback:	1084	+	case protocol.ClientNoticeClipboardFallback:
1085		return d.recordClientNotice(sess, ac, domain.NoticeError, domain.NoticeClipboard, "image paste failed; sent Ctrl+V")	1085		return d.recordClientNotice(sess, ac, domain.NoticeError, domain.NoticeClipboard, "image paste failed; sent Ctrl+V")
1086	-	case ports.ClientNoticeClipboardTooLarge:	1086	+	case protocol.ClientNoticeClipboardTooLarge:
1087		return d.recordClientNotice(sess, ac, domain.NoticeWarn, domain.NoticeClipboardTooLarge, "image too large to paste")	1087		return d.recordClientNotice(sess, ac, domain.NoticeWarn, domain.NoticeClipboardTooLarge, "image too large to paste")
1088	-	case ports.ClientNoticeLinkDegraded:	1088	+	case protocol.ClientNoticeLinkDegraded:
1089		return d.recordClientNotice(sess, ac, domain.NoticeWarn, domain.NoticeConnection, "connection degraded")	1089		return d.recordClientNotice(sess, ac, domain.NoticeWarn, domain.NoticeConnection, "connection degraded")
1090	-	case ports.ClientNoticeLinkConnected:	1090	+	case protocol.ClientNoticeLinkConnected:
1091		return d.dismissToastWithoutRepaint(ac, domain.NoticeConnection, sess.id)	1091		return d.dismissToastWithoutRepaint(ac, domain.NoticeConnection, sess.id)
1092		default:	1092		default:
1093		return false	1093		return false

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


@@ -234,52 +234,52 @@ func (d Daemon) commandResultEffect(effect attachmentEffect) (*attachmentEffec
234		return effect.ac.beginAttachmentEffect(capability)	234		return effect.ac.beginAttachmentEffect(capability)
235		}	235		}
236			236
237	-	func (d Daemon) executeAttachedCommand(effect attachmentEffect, request ports.CommandRequest) ports.CommandResult {	237	+	func (d Daemon) executeAttachedCommand(effect attachmentEffect, request protocol.CommandRequest) protocol.CommandResult {
238	-	result := ports.CommandResult{RequestID: request.RequestID}	238	+	result := protocol.CommandResult{RequestID: request.RequestID}
239	-	if request.Version != ports.ProtocolVersion {	239	+	if request.Version != protocol.Version {
240	-	result.Code = ports.ErrInvalidCommandArgs	240	+	result.Code = protocol.ErrInvalidCommandArgs
241		result.Text = "unsupported command protocol version"	241		result.Text = "unsupported command protocol version"
242		return result	242		return result
243		}	243		}
244		if !request.Attached {	244		if !request.Attached {
245	-	result.Code = ports.ErrInvalidCommandArgs	245	+	result.Code = protocol.ErrInvalidCommandArgs
246		result.Text = "attached command flag is required"	246		result.Text = "attached command flag is required"
247		return result	247		return result
248		}	248		}
249		if request.RequestID == 0 {	249		if request.RequestID == 0 {
250	-	result.Code = ports.ErrInvalidCommandArgs	250	+	result.Code = protocol.ErrInvalidCommandArgs
251		result.Text = "command request id is required"	251		result.Text = "command request id is required"
252		return result	252		return result
253		}	253		}
254		if request.Self {	254		if request.Self {
255	-	result.Code = ports.ErrInvalidCommandArgs	255	+	result.Code = protocol.ErrInvalidCommandArgs
256		result.Text = "attached commands cannot target themselves"	256		result.Text = "attached commands cannot target themselves"
257		return result	257		return result
258		}	258		}
259		if request.TargetSession != "" \|\| request.TargetTab != "" \|\| request.TargetPane != "" {	259		if request.TargetSession != "" \|\| request.TargetTab != "" \|\| request.TargetPane != "" {
260	-	result.Code = ports.ErrInvalidCommandArgs	260	+	result.Code = protocol.ErrInvalidCommandArgs
261		result.Text = "attached commands cannot override their active session target"	261		result.Text = "attached commands cannot override their active session target"
262		return result	262		return result
263		}	263		}
264		sess := effect.sess	264		sess := effect.sess
265		if sess == nil \|\| !effect.current() {	265		if sess == nil \|\| !effect.current() {
266	-	result.Code = ports.ErrNoSuchTarget	266	+	result.Code = protocol.ErrNoSuchTarget
267		result.Text = "attached session is no longer active"	267		result.Text = "attached session is no longer active"
268		return result	268		return result
269		}	269		}
270		cmd, ok := command.BySlug(request.Slug)	270		cmd, ok := command.BySlug(request.Slug)
271		if !ok {	271		if !ok {
272	-	result.Code = ports.ErrUnknownCommand	272	+	result.Code = protocol.ErrUnknownCommand
273		result.Text = "unknown command: " + request.Slug	273		result.Text = "unknown command: " + request.Slug
274		return result	274		return result
275		}	275		}
276		if !cmd.PaletteVisible {	276		if !cmd.PaletteVisible {
277	-	result.Code = ports.ErrNotScriptable	277	+	result.Code = protocol.ErrNotScriptable
278		result.Text = request.Slug + " is not available in the palette"	278		result.Text = request.Slug + " is not available in the palette"
279		return result	279		return result
280		}	280		}
281		if cmd.Run == nil {	281		if cmd.Run == nil {
282	-	result.Code = ports.ErrNotScriptable	282	+	result.Code = protocol.ErrNotScriptable
283		result.Text = request.Slug + " is not scriptable"	283		result.Text = request.Slug + " is not scriptable"
284		return result	284		return result
285		}	285		}

@@ -293,11 +293,11 @@ func (d Daemon) executeAttachedCommand(effect attachmentEffect, request ports.
293		return result	293		return result
294		}	294		}
295		if errors.Is(err, command.ErrInvalidArguments) {	295		if errors.Is(err, command.ErrInvalidArguments) {
296	-	result.Code = ports.ErrInvalidCommandArgs	296	+	result.Code = protocol.ErrInvalidCommandArgs
297		result.Text = "usage: " + cmd.Usage	297		result.Text = "usage: " + cmd.Usage
298		return result	298		return result
299		}	299		}
300	-	result.Code = ports.ErrInternal	300	+	result.Code = protocol.ErrInternal
301		result.Text = err.Error()	301		result.Text = err.Error()
302		return result	302		return result
303		}	303		}

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

 import (
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 // clientGone detaches ac if it is still the session's current client. The
 		// (the client is actively awaiting it), but deadline-bounded so a
 		// wedged client cannot pin this conn handler and hang Serve's
 		// connWg.Wait.
-		d.boundedSend(ac, frameDetached(ports.ReasonDetach))
+		d.boundedSend(ac, frameDetached(protocol.ReasonDetach))
 	}
 	_ = ac.closeCapturedTransport(oldTr)
 	d.log.Info("client detached", "session", name, "explicit", explicit)

M internal/usecase/daemon/clipboard_test.go +1 -1


@@ -176,7 +176,7 @@ func TestKillSessionRemovesClipboardTempFiles(t *testing.T) {
176		path := string(injected)	176		path := string(injected)
177		require.FileExists(t, path)	177		require.FileExists(t, path)
178			178
179	-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))	179	+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
180		require.NoFileExists(t, path)	180		require.NoFileExists(t, path)
181		}	181		}
182			182

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

 	"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"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 	snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
 	d.mu.Lock()
 	entry := d.inactive[record.Name]
 	d.mu.Unlock()
-	require.Equal(t, ports.SessionBroken, entry.state)
+	require.Equal(t, protocol.SessionBroken, entry.state)
 	require.Equal(t, persisted, entry.record)
 }
 	d.mu.Lock()
 	entry := d.inactive[record.Name]
 	d.mu.Unlock()
-	require.Equal(t, ports.SessionBroken, entry.state)
+	require.Equal(t, protocol.SessionBroken, entry.state)
 	require.Equal(t, persisted, entry.record)
-	require.Equal(t, ports.SessionBroken, listSessions(t, d).Sessions[0].State)
+	require.Equal(t, protocol.SessionBroken, listSessions(t, d).Sessions[0].State)
 	select {
 	case <-entry.restoreDone:
 	default:
 	entry := d.inactive[record.Name]
 	d.mu.Unlock()
 	require.Equal(t, persisted, entry.record)
-	require.Equal(t, ports.SessionDown, entry.state)
+	require.Equal(t, protocol.SessionDown, entry.state)
 }
 func TestStaleIncompatibleRestoreCannotOverwriteNewerAuthority(t *testing.T) {
 	tests := []struct {
 		name        string
 		replacement func(domain.CatalogueRecord) domain.CatalogueRecord
-		state       ports.SessionState
+		state       protocol.SessionState
 	}{
 		{
 			name: "newer checkpoint",
 				record.Committed = &ref
 				return record
 			},
-			state: ports.SessionDown,
+			state: protocol.SessionDown,
 		},
 		{
 			name: "newer incarnation",
 				record.IncarnationID = domain.IncarnationID{9}
 				return record
 			},
-			state: ports.SessionDown,
+			state: protocol.SessionDown,
 		},
 		{
 			name: "degraded authority",
 				record.DegradedReason = "newer restore decision"
 				return record
 			},
-			state: ports.SessionBroken,
+			state: protocol.SessionBroken,
 		},
 	}
 	for _, tt := range tests {
 	d := newTestDaemon(t, nil, stubClock{})
 	d.catalogue = catalogue
 	d.persistEnabled = true
-	d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, make(chan struct{}))
+	d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, make(chan struct{}))
 	result := make(chan error, 1)
 	go func() {
 	d.catalogue = catalogue
 	d.persistEnabled = true
 	d.recovery = recoveryusecase.NewCoordinator(catalogue, noOpSnapshotRepository{}, nil)
-	d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+	d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 	target := picker.Target{
 		Name:              record.Name,
 	replacement.UpdatedAt = replacement.CreatedAt
 	require.NoError(t, catalogue.Replace(replacement.Name, replacement))
 	d.mu.Lock()
-	d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, ports.SessionDown, nil)
+	d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, protocol.SessionDown, nil)
 	d.mu.Unlock()
 	close(catalogue.release)
 	d.catalogue = catalogue
 	d.persistEnabled = true
 	d.recovery = recoveryusecase.NewCoordinator(catalogue, noOpSnapshotRepository{}, nil)
-	d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+	d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 	target := domain.RemoteSessionTarget{
 		Endpoint: "remote", DisplayOrigin: "remote", LifecycleID: record.IncarnationID,
 	transport, _ := newCapturingTransport(t)
 	result := make(chan error, 1)
 	go func() {
-		_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+		_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-			Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name,
+			Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name,
 			Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-			EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+			EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}, transport)
 		result <- err
 	}()
 	replacement.UpdatedAt = replacement.CreatedAt
 	require.NoError(t, catalogue.Replace(replacement.Name, replacement))
 	d.mu.Lock()
-	d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, ports.SessionDown, nil)
+	d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, protocol.SessionDown, nil)
 	d.mu.Unlock()
 	close(catalogue.release)
 	var protocolErr *protoErr
 	require.ErrorAs(t, <-result, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	require.Empty(t, catalogue.MetadataUpdates())
 	d.mu.Lock()
 	defer d.mu.Unlock()
 			d.catalogue = catalogue
 			d.persistEnabled = true
 			d.recovery = recoveryusecase.NewCoordinator(catalogue, noOpSnapshotRepository{}, nil)
-			d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+			d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 			target := test.target
 			target.Endpoint = "remote"
 			transport, _ := newCapturingTransport(t)
 			result := make(chan error, 1)
 			go func() {
-				_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+				_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-					Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name,
+					Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name,
 					Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-					EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+					EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 				}, transport)
 				result <- err
 			}()
 			require.NoError(t, catalogue.Replace(replacement.Name, replacement))
 			if test.updateMap {
 				d.mu.Lock()
-				d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, ports.SessionDown, nil)
+				d.inactive[replacement.Name] = inactiveSessionFromRecord(replacement, protocol.SessionDown, nil)
 				d.mu.Unlock()
 			}
 			close(catalogue.release)
 			var protocolErr *protoErr
 			require.ErrorAs(t, <-result, &protocolErr)
-			require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+			require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 			require.Empty(t, catalogue.MetadataUpdates())
 			d.mu.Lock()
 			defer d.mu.Unlock()

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

 	"time"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 const CommandRequestTimeout = 10 * time.Second
 // CommandRequestOutcome is the result delivered for one tracked request.
 type CommandRequestOutcome struct {
-	Result ports.CommandResult
+	Result protocol.CommandResult
 	Err    error
 }
 // Wait waits without holding the tracker or connection sender lock. Timeout
 // and cancellation remove only the matching request.
-func (t *CommandRequestTracker) Wait(ctx context.Context, clock ports.Clock, requestID, generation uint64, outcome <-chan CommandRequestOutcome) (ports.CommandResult, error) {
+func (t *CommandRequestTracker) Wait(ctx context.Context, clock ports.Clock, requestID, generation uint64, outcome <-chan CommandRequestOutcome) (protocol.CommandResult, error) {
 	if t == nil || clock == nil {
-		return ports.CommandResult{}, ErrCommandRequestUnavailable
+		return protocol.CommandResult{}, ErrCommandRequestUnavailable
 	}
 	if ctx == nil {
 		ctx = context.Background()
 	}
 	if err := ctx.Err(); err != nil {
 		t.Remove(requestID, generation)
-		return ports.CommandResult{}, err
+		return protocol.CommandResult{}, err
 	}
 	timer := clock.NewTimer(CommandRequestTimeout)
 	if timer == nil {
 		t.Remove(requestID, generation)
-		return ports.CommandResult{}, ErrCommandRequestTimeout
+		return protocol.CommandResult{}, ErrCommandRequestTimeout
 	}
 	defer timer.Stop()
 	select {
 		return completed.Result, completed.Err
 	case <-ctx.Done():
 		t.Remove(requestID, generation)
-		return ports.CommandResult{}, ctx.Err()
+		return protocol.CommandResult{}, ctx.Err()
 	case <-timer.C():
 		t.Remove(requestID, generation)
-		return ports.CommandResult{}, ErrCommandRequestTimeout
+		return protocol.CommandResult{}, ErrCommandRequestTimeout
 	}
 }
 // Complete accepts only the exact request generation. Unknown, late, and old
 // generation results are safe no-ops.
-func (t *CommandRequestTracker) Complete(generation uint64, result ports.CommandResult) {
+func (t *CommandRequestTracker) Complete(generation uint64, result protocol.CommandResult) {
 	t.finish(result.RequestID, generation, CommandRequestOutcome{Result: result})
 }

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type commandTrackerTestTimer struct {
 	// old connection must not complete the new request.
 	secondOutcome, ok := tracker.Track(requestID, 8)
 	require.True(t, ok)
-	tracker.Complete(4, ports.CommandResult{RequestID: requestID, OK: true})
+	tracker.Complete(4, protocol.CommandResult{RequestID: requestID, OK: true})
 	select {
 	case <-secondOutcome:
 		t.Fatal("late result from the old generation completed a newer request")
 	default:
 	}
-	tracker.Complete(8, ports.CommandResult{RequestID: requestID, OK: true})
+	tracker.Complete(8, protocol.CommandResult{RequestID: requestID, OK: true})
 	result := <-secondOutcome
 	require.True(t, result.Result.OK)

M internal/usecase/daemon/control.go +38 -37

 	"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"
 )
 func (d *Daemon) handleCommand(tr ports.Transport, f ports.Frame) error {
 	defer func() { _ = tr.Close() }()
-	if version, ok := ports.PeekCommandVersion(f.Payload); !ok || version != ports.ProtocolVersion {
+	if version, ok := ports.PeekCommandVersion(f.Payload); !ok || version != protocol.Version {
-		return d.sendCommandResult(tr, ports.CommandResult{Code: ports.ErrVersionMismatch, Text: "protocol version mismatch"})
+		return d.sendCommandResult(tr, protocol.CommandResult{Code: protocol.ErrVersionMismatch, Text: "protocol version mismatch"})
 	}
 	request, err := ports.UnmarshalCommandRequest(f.Payload)
 	if err != nil {
-		return d.sendCommandResult(tr, ports.CommandResult{Code: ports.ErrInternal, Text: "malformed command request"})
+		return d.sendCommandResult(tr, protocol.CommandResult{Code: protocol.ErrInternal, Text: "malformed command request"})
 	}
 	if request.Attached {
-		return d.sendCommandResult(tr, ports.CommandResult{
+		return d.sendCommandResult(tr, protocol.CommandResult{
 			RequestID: request.RequestID,
-			Code:      ports.ErrNotScriptable,
+			Code:      protocol.ErrNotScriptable,
 			Text:      "attached command relay is not enabled",
 		})
 	}
 	}
 	result, waitErr := tracker.Wait(commandCtx, commandClock, request.RequestID, generation, outcome)
 	if waitErr != nil {
-		return d.sendCommandResult(tr, ports.CommandResult{
+		return d.sendCommandResult(tr, protocol.CommandResult{
 			RequestID: request.RequestID,
-			Code:      ports.ErrInternal,
+			Code:      protocol.ErrInternal,
 			Text:      waitErr.Error(),
 		})
 	}
 // sendCommandResult gives one-shot control responses the same observable
 // transport-failure behavior regardless of which validation path produced it.
-func (d *Daemon) sendCommandResult(tr ports.Transport, result ports.CommandResult) error {
+func (d *Daemon) sendCommandResult(tr ports.Transport, result protocol.CommandResult) error {
 	if err := d.boundedControlSend(tr, frameCommandResult(result)); err != nil {
 		d.log.Warn("command response send failed", "err", err)
 		return err
 	return err
 }
-func frameCommandResult(result ports.CommandResult) ports.Frame {
+func frameCommandResult(result protocol.CommandResult) ports.Frame {
 	return ports.Frame{Type: ports.MsgCommandResult, Payload: ports.MarshalCommandResult(result)}
 }
-func (d *Daemon) dispatchCommand(ctx context.Context, request ports.CommandRequest) ports.CommandResult {
+func (d *Daemon) dispatchCommand(ctx context.Context, request protocol.CommandRequest) protocol.CommandResult {
 	cmd, ok := command.BySlug(request.Slug)
 	if !ok {
-		return commandFailure(ports.ErrUnknownCommand, "unknown command: "+request.Slug)
+		return commandFailure(protocol.ErrUnknownCommand, "unknown command: "+request.Slug)
 	}
 	if !cmd.Scriptable || cmd.Control == nil {
-		return commandFailure(ports.ErrNotScriptable, request.Slug+" requires an attached client")
+		return commandFailure(protocol.ErrNotScriptable, request.Slug+" requires an attached client")
 	}
 	if cmd.Target == command.TargetNone && !request.Self {
 		return d.runControl(cmd, controlExec{ctx: ctx, d: d, recoveryName: request.TargetSession}, request)
 	for {
 		select {
 		case <-ctx.Done():
-			return commandFailure(ports.ErrInternal, ctx.Err().Error())
+			return commandFailure(protocol.ErrInternal, ctx.Err().Error())
 		default:
 		}
 		if sess.dispatchMu.TryLock() {
 	return d.runControl(cmd, controlExec{ctx: ctx, d: d, sess: sess, tab: tb, target: daemonActionTarget{session: sess, tab: tb, pane: pane}}, request)
 }
-func (d *Daemon) runControl(cmd command.Command, exec controlExec, request ports.CommandRequest) ports.CommandResult {
+func (d *Daemon) runControl(cmd command.Command, exec controlExec, request protocol.CommandRequest) protocol.CommandResult {
 	result, err := cmd.Control(exec, request.Args, command.ControlOptions{JSON: request.JSON})
 	if err == nil {
-		return ports.CommandResult{OK: true, Output: result.Output}
+		return protocol.CommandResult{OK: true, Output: result.Output}
 	}
 	switch {
 	case errors.Is(err, command.ErrInvalidArguments), errors.Is(err, errSessionNameRequired), errors.Is(err, domain.ErrInvalidSessionName):
-		return commandFailure(ports.ErrInvalidCommandArgs, "usage: "+cmd.Usage)
+		return commandFailure(protocol.ErrInvalidCommandArgs, "usage: "+cmd.Usage)
 	case errors.Is(err, errSessionNameInUse):
-		return commandFailure(ports.ErrNameTaken, err.Error())
+		return commandFailure(protocol.ErrNameTaken, err.Error())
 	case isMoveCommandError(err):
 		return moveCommandFailure(err)
 	case errors.Is(err, layout.ErrNotInSplit):
-		return commandFailure(ports.ErrNoSuchTarget, "pane is not in a split")
+		return commandFailure(protocol.ErrNoSuchTarget, "pane is not in a split")
 	case errors.Is(err, layout.ErrTooSmall):
-		return commandFailure(ports.ErrNoSuchTarget, "pane cannot be resized further")
+		return commandFailure(protocol.ErrNoSuchTarget, "pane cannot be resized further")
 	default:
-		return commandFailure(ports.ErrInternal, err.Error())
+		return commandFailure(protocol.ErrInternal, err.Error())
 	}
 }
-func commandFailure(code uint16, text string) ports.CommandResult {
+func commandFailure(code uint16, text string) protocol.CommandResult {
-	return ports.CommandResult{Code: code, Text: text}
+	return protocol.CommandResult{Code: code, Text: text}
 }
 // resolveTargetSession applies explicit-name, stable-ID, then unique-session
 // resolution. A name paired with complete stable IDs is always advisory because
 // a process keeps its original VEV session component after relocation.
-func (d *Daemon) resolveTargetSession(request ports.CommandRequest) (*session, uint16, string) {
+func (d *Daemon) resolveTargetSession(request protocol.CommandRequest) (*session, uint16, string) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	named := d.findByNameLocked(request.TargetSession)
 	if request.Self && (request.TargetTab == "" || request.TargetPane == "") {
-		return nil, ports.ErrNoSuchTarget, "--self requires target tab and pane IDs"
+		return nil, protocol.ErrNoSuchTarget, "--self requires target tab and pane IDs"
 	}
 	if request.TargetSession != "" && request.TargetTab == "" && request.TargetPane == "" {
 		if named == nil {
-			return nil, ports.ErrNoSuchTarget, "no such session: " + request.TargetSession
+			return nil, protocol.ErrNoSuchTarget, "no such session: " + request.TargetSession
 		}
 		return named, 0, ""
 	}
 	if request.TargetTab != "" || request.TargetPane != "" {
 		if request.TargetTab == "" || request.TargetPane == "" {
-			return nil, ports.ErrNoSuchTarget, "target tab and pane IDs must be provided together"
+			return nil, protocol.ErrNoSuchTarget, "target tab and pane IDs must be provided together"
 		}
 		var match *session
 		for _, sess := range d.sessions {
 				continue
 			}
 			if match != nil {
-				return nil, ports.ErrAmbiguousTarget, "target tab and pane IDs are ambiguous"
+				return nil, protocol.ErrAmbiguousTarget, "target tab and pane IDs are ambiguous"
 			}
 			match = sess
 		}
 		if match != nil {
 			return match, 0, ""
 		}
-		return nil, ports.ErrNoSuchTarget, "no live session contains the target tab/pane"
+		return nil, protocol.ErrNoSuchTarget, "no live session contains the target tab/pane"
 	}
 	locals := sessionsSnapshot(d.sessions)
 	if len(locals) == 0 {
-		return nil, ports.ErrNoSuchTarget, "no live sessions"
+		return nil, protocol.ErrNoSuchTarget, "no live sessions"
 	}
 	if len(locals) != 1 {
-		return nil, ports.ErrAmbiguousTarget, "several sessions are live; use -s <session> or run from inside a pane"
+		return nil, protocol.ErrAmbiguousTarget, "several sessions are live; use -s <session> or run from inside a pane"
 	}
 	return locals[0], 0, ""
 }
 	return false
 }
-func resolveControlTarget(sess *session, kind command.TargetKind, request ports.CommandRequest) (*tab, *pane, uint16, string) {
+func resolveControlTarget(sess *session, kind command.TargetKind, request protocol.CommandRequest) (*tab, *pane, uint16, string) {
 	sess.mu.Lock()
 	tabs := append([]*tab(nil), sess.tabs...)
 	sess.mu.Unlock()
 			target := paneByStableIDLocked(tb, request.TargetPane)
 			tb.mu.Unlock()
 			if target == nil {
-				return nil, nil, ports.ErrNoSuchTarget, "target pane does not belong to target tab"
+				return nil, nil, protocol.ErrNoSuchTarget, "target pane does not belong to target tab"
 			}
 			return tb, target, 0, ""
 		}
-		return nil, nil, ports.ErrNoSuchTarget, "no such target tab"
+		return nil, nil, protocol.ErrNoSuchTarget, "no such target tab"
 	}
 	if len(tabs) == 0 {
-		return nil, nil, ports.ErrNoSuchTarget, "target session has no tabs"
+		return nil, nil, protocol.ErrNoSuchTarget, "target session has no tabs"
 	}
 	tb := tabs[0]
 	if kind != command.TargetPane {
 	target := tb.focusedPane()
 	tb.mu.Unlock()
 	if target == nil {
-		return nil, nil, ports.ErrNoSuchTarget, "no such target pane"
+		return nil, nil, protocol.ErrNoSuchTarget, "no such target pane"
 	}
 	return tb, target, 0, ""
 }
 		return "", err
 	}
 	if ok {
-		e.d.setStoppedRecovery(record, ports.SessionDown)
+		e.d.setStoppedRecovery(record, protocol.SessionDown)
 	}
 	return "", nil
 }
 		return rows[i].LifecycleID.String() < rows[j].LifecycleID.String()
 	})
 	catalog := ports.RemoteCatalog{
-		ProtocolVersion: ports.ProtocolVersion,
+		ProtocolVersion: protocol.Version,
 		SchemaVersion:   ports.RemoteCatalogSchemaVersion,
 		Sessions:        rows,
 	}

M internal/usecase/daemon/control_test.go +113 -112

 	"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/layout"
 	"github.com/stretchr/testify/require"
 	targetStableID := h.panes["pane-3"].stableID
 	h.tab.mu.Unlock()
-	result := sendCommand(t, h.daemon, ports.CommandRequest{
+	result := sendCommand(t, h.daemon, protocol.CommandRequest{
 		Slug:          "consume-or-expel-pane-left",
 		Self:          true,
 		TargetSession: "work",
 	h.session.installRenderCoordinator(rc)
 	before := h.snapshot()
-	result := sendCommand(t, h.daemon, ports.CommandRequest{
+	result := sendCommand(t, h.daemon, protocol.CommandRequest{
 		Slug:          "consume-or-expel-pane-left",
 		Self:          true,
 		TargetSession: "work",
 	clock := &signalClock{timers: make(chan *signalTimer, 1)}
 	d := newTestDaemon(t, factory, clock)
 	addControlSession(d, "work", "t_work", "p_work")
-	frame := commandFrame(t, ports.CommandRequest{
+	frame := commandFrame(t, protocol.CommandRequest{
 		RequestID: 17, Slug: "new-tab", TargetSession: "work",
 	})
 	tr, sends, releaseConn := newConn(t, frame)
 	timer.ch <- time.Time{}
 	result := awaitCommandResult(t, sends)
 	require.Equal(t, uint64(17), result.RequestID)
-	require.Equal(t, ports.ErrInternal, result.Code)
+	require.Equal(t, protocol.ErrInternal, result.Code)
 	require.Equal(t, ErrCommandRequestTimeout.Error(), result.Text)
 	require.NoError(t, <-done)
 	close(factory.release)
 	clock := &signalClock{timers: make(chan *signalTimer, 1)}
 	d := newTestDaemon(t, nil, clock)
 	tr := newBlockingControlSendTransport()
-	frame := commandFrame(t, ports.CommandRequest{RequestID: 41, Attached: true})
+	frame := commandFrame(t, protocol.CommandRequest{RequestID: 41, Attached: true})
 	done := make(chan error, 1)
 	go func() { done <- d.handleCommand(tr, frame) }()
 	sendErr := errors.New("command result send failed")
 	tr := &commandSendErrorTransport{err: sendErr}
-	err := d.handleCommand(tr, commandFrame(t, ports.CommandRequest{
+	err := d.handleCommand(tr, commandFrame(t, protocol.CommandRequest{
 		RequestID: 41,
 		Attached:  true,
 	}))
 func TestHandleCommandRejectsVersionBeforeDecodeOrDispatch(t *testing.T) {
 	// The version prefix is valid and mismatched, while the remainder is not a
 	// decodable request. The daemon must still return ErrVersionMismatch.
-	frame := ports.Frame{Type: ports.MsgCommand, Payload: []byte{0, byte(ports.ProtocolVersion + 1)}}
+	frame := ports.Frame{Type: ports.MsgCommand, Payload: []byte{0, byte(protocol.Version + 1)}}
 	tr, sends, _ := newConn(t, frame)
 	d := newTestDaemon(t, nil, stubClock{})
 	result := awaitCommandResult(t, sends)
 	require.False(t, result.OK)
-	require.Equal(t, ports.ErrVersionMismatch, result.Code)
+	require.Equal(t, protocol.ErrVersionMismatch, result.Code)
 }
 func TestHandleConnRoutesCommand(t *testing.T) {
 	d := newTestDaemon(t, nil, stubClock{})
-	request := ports.CommandRequest{Version: ports.ProtocolVersion, Slug: "list-sessions"}
+	request := protocol.CommandRequest{Version: protocol.Version, Slug: "list-sessions"}
 	payload, err := ports.MarshalCommandRequest(request)
 	require.NoError(t, err)
 	frame := ports.Frame{Type: ports.MsgCommand, Payload: payload}
 	tests := []struct {
 		name    string
 		arrange func(*Daemon)
-		request ports.CommandRequest
+		request protocol.CommandRequest
 		code    uint16
 	}{
-		{name: "unknown slug", request: ports.CommandRequest{Slug: "no-such"}, code: ports.ErrUnknownCommand},
+		{name: "unknown slug", request: protocol.CommandRequest{Slug: "no-such"}, code: protocol.ErrUnknownCommand},
-		{name: "non-scriptable command", request: ports.CommandRequest{Slug: "session-picker"}, code: ports.ErrNotScriptable},
+		{name: "non-scriptable command", request: protocol.CommandRequest{Slug: "session-picker"}, code: protocol.ErrNotScriptable},
-		{name: "no sessions", request: ports.CommandRequest{Slug: "split-right"}, code: ports.ErrNoSuchTarget},
+		{name: "no sessions", request: protocol.CommandRequest{Slug: "split-right"}, code: protocol.ErrNoSuchTarget},
 		{name: "ambiguous sessions", arrange: func(d *Daemon) {
 			addControlSession(d, "one", "t_one", "p_one")
 			addControlSession(d, "two", "t_two", "p_two")
-		}, request: ports.CommandRequest{Slug: "split-right"}, code: ports.ErrAmbiguousTarget},
+		}, request: protocol.CommandRequest{Slug: "split-right"}, code: protocol.ErrAmbiguousTarget},
 		{name: "missing explicit session", arrange: func(d *Daemon) {
 			addControlSession(d, "work", "t_work", "p_work")
-		}, request: ports.CommandRequest{Slug: "new-tab", TargetSession: "missing"}, code: ports.ErrNoSuchTarget},
+		}, request: protocol.CommandRequest{Slug: "new-tab", TargetSession: "missing"}, code: protocol.ErrNoSuchTarget},
 		{name: "missing stable IDs", arrange: func(d *Daemon) {
 			addControlSession(d, "work", "t_work", "p_work")
-		}, request: ports.CommandRequest{Slug: "split-right", TargetTab: "t_nope", TargetPane: "p_nope"}, code: ports.ErrNoSuchTarget},
+		}, request: protocol.CommandRequest{Slug: "split-right", TargetTab: "t_nope", TargetPane: "p_nope"}, code: protocol.ErrNoSuchTarget},
 		{name: "duplicate stable IDs are ambiguous", arrange: func(d *Daemon) {
 			addControlSession(d, "one", "t_shared", "p_shared")
 			addControlSession(d, "two", "t_shared", "p_shared")
-		}, request: ports.CommandRequest{Slug: "toast", Args: []string{"hello"}, TargetTab: "t_shared", TargetPane: "p_shared"}, code: ports.ErrAmbiguousTarget},
+		}, request: protocol.CommandRequest{Slug: "toast", Args: []string{"hello"}, TargetTab: "t_shared", TargetPane: "p_shared"}, code: protocol.ErrAmbiguousTarget},
 		{name: "self requires both IDs", arrange: func(d *Daemon) {
 			addControlSession(d, "work", "t_work", "p_work")
-		}, request: ports.CommandRequest{Slug: "split-right", Self: true, TargetSession: "work", TargetTab: "t_work"}, code: ports.ErrNoSuchTarget},
+		}, request: protocol.CommandRequest{Slug: "split-right", Self: true, TargetSession: "work", TargetTab: "t_work"}, code: protocol.ErrNoSuchTarget},
 		{name: "self rejects pane from another tab", arrange: func(d *Daemon) {
 			sess := addControlSession(d, "work", "t_work", "p_work")
 			other := newTabWithStableID("t_other", "p_other", newQuietPTY(), domain.Size{Cols: 80, Rows: 22})
 			other.ctx, other.cancel = context.WithCancel(d.serveCtx)
 			sess.tabs = append(sess.tabs, other)
-		}, request: ports.CommandRequest{Slug: "split-right", Self: true, TargetSession: "work", TargetTab: "t_work", TargetPane: "p_other"}, code: ports.ErrNoSuchTarget},
+		}, request: protocol.CommandRequest{Slug: "split-right", Self: true, TargetSession: "work", TargetTab: "t_work", TargetPane: "p_other"}, code: protocol.ErrNoSuchTarget},
 	}
 	for _, tt := range tests {
 	d := newTestDaemon(t, nil, stubClock{})
 	sess := addControlSession(d, "renamed", "t_work", "p_work")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "toast", Args: []string{"hello"},
 		TargetSession: "old-name", TargetTab: "t_work", TargetPane: "p_work",
 	})
 	selectTestAttachmentTabLocked(sess, 0)
 	sess.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "rename-tab", Args: []string{"targeted"}, TargetSession: "work",
 		TargetTab: "t_second", TargetPane: "p_second",
 	})
 	selectTestAttachmentTabLocked(sess, 0)
 	sess.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "split-right", TargetSession: "work",
 		TargetTab: "t_origin", TargetPane: "p_origin",
 	})
 	selectTestAttachmentTabLocked(sess, 0)
 	sess.mu.Unlock()
-	rename := sendCommand(t, d, ports.CommandRequest{
+	rename := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "rename-tab", Args: []string{"invoking"}, Self: true,
 		TargetSession: "work", TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 	require.Equal(t, "invoking", invoking.name)
 	invoking.mu.Unlock()
-	split := sendCommand(t, d, ports.CommandRequest{
+	split := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "split-right", Self: true,
 		TargetSession: "work", TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 	beforeGeneration := invoking.layoutGeneration
 	invoking.mu.Unlock()
-	grow := sendCommand(t, d, ports.CommandRequest{
+	grow := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "grow-pane-width", Self: true,
 		TargetSession: "work", TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 	require.Len(t, active.panes, 1, "--self resize must not mutate the active tab")
 	active.mu.Unlock()
-	equalize := sendCommand(t, d, ports.CommandRequest{
+	equalize := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "equalize-panes", Self: true,
 		TargetSession: "work", TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 func TestResizeControlOneShotsTargetDetachedSessions(t *testing.T) {
 	targets := []struct {
 		name    string
-		request func() ports.CommandRequest
+		request func() protocol.CommandRequest
 	}{
-		{"named", func() ports.CommandRequest { return ports.CommandRequest{TargetSession: "work"} }},
+		{"named", func() protocol.CommandRequest { return protocol.CommandRequest{TargetSession: "work"} }},
-		{"unique", func() ports.CommandRequest { return ports.CommandRequest{} }},
+		{"unique", func() protocol.CommandRequest { return protocol.CommandRequest{} }},
 	}
 	for _, target := range targets {
 		t.Run(target.name, func(t *testing.T) {
 					d := newTestDaemon(t, factory, stubClock{})
 					t.Cleanup(func() { factory.close(); d.sessWg.Wait() })
 					sess := addControlSession(d, "work", "t_work", "p_work")
-					require.True(t, sendCommand(t, d, ports.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
+					require.True(t, sendCommand(t, d, protocol.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
-					require.True(t, sendCommand(t, d, ports.CommandRequest{Slug: "split-down", TargetSession: "work"}).OK)
+					require.True(t, sendCommand(t, d, protocol.CommandRequest{Slug: "split-down", TargetSession: "work"}).OK)
 					tb := testAttachmentTab(sess)
 					tb.mu.Lock()
 					generation := tb.layoutGeneration
 	d := newTestDaemon(t, factory, stubClock{})
 	t.Cleanup(func() { factory.close(); d.sessWg.Wait() })
 	sess := addControlSession(d, "work", "t_active", "p_active")
-	require.True(t, sendCommand(t, d, ports.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
+	require.True(t, sendCommand(t, d, protocol.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
 	active := sess.tabs[0]
 	locator := newTabWithStableID("t_locator", "p_locator", newQuietPTY(), domain.Size{Cols: 80, Rows: 22})
 	locator.ctx, locator.cancel = context.WithCancel(d.serveCtx)
 	before := active.layoutGeneration
 	active.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "grow-pane-width", TargetSession: "work", TargetTab: "t_locator", TargetPane: "p_locator",
 	})
 	require.True(t, result.OK, result.Text)
 	d := newTestDaemon(t, factory, stubClock{})
 	t.Cleanup(func() { factory.close(); d.sessWg.Wait() })
 	sess := addControlSession(d, "work", "t_work", "p_work")
-	require.True(t, sendCommand(t, d, ports.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
+	require.True(t, sendCommand(t, d, protocol.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
 	tb := testAttachmentTab(sess)
 	tb.mu.Lock()
 	tb.size.Cols = 41
 	tb.bumpLayoutGenerationLocked()
 	tb.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "grow-pane-width", TargetSession: "work"})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "grow-pane-width", TargetSession: "work"})
 	require.False(t, result.OK)
-	require.Equal(t, ports.ErrNoSuchTarget, result.Code)
+	require.Equal(t, protocol.ErrNoSuchTarget, result.Code)
 	require.Equal(t, "pane cannot be resized further", result.Text)
 }
 	selectTestAttachmentTabLocked(sess, 0)
 	sess.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "list-panes", Self: true, JSON: true,
 		TargetSession: "work", TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 	d := newTestDaemon(t, nil, stubClock{})
 	addControlSession(d, "work", "t_work", "p_work")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "rename-session", Args: []string{"invalid name"}, TargetSession: "work",
 	})
 	require.False(t, result.OK)
-	require.Equal(t, ports.ErrInvalidCommandArgs, result.Code)
+	require.Equal(t, protocol.ErrInvalidCommandArgs, result.Code)
 }
 func TestCloseCommandsReportMutationOutcome(t *testing.T) {
 		result := d.runControl(cmd, controlExec{
 			d: d, sess: sess, tab: stale,
 			target: daemonActionTarget{session: sess, tab: stale},
-		}, ports.CommandRequest{Slug: "close-tab"})
+		}, protocol.CommandRequest{Slug: "close-tab"})
 		require.False(t, result.OK)
-		require.Equal(t, ports.ErrInternal, result.Code)
+		require.Equal(t, protocol.ErrInternal, result.Code)
 		require.Len(t, sess.tabs, 1, "a stale close must retain the live tab")
 	})
 		sess.mu.Unlock()
 		sess.snapEligible.Store(true)
-		result := sendCommand(t, d, ports.CommandRequest{Slug: "close-pane", TargetSession: "work"})
+		result := sendCommand(t, d, protocol.CommandRequest{Slug: "close-pane", TargetSession: "work"})
 		require.False(t, result.OK)
-		require.Equal(t, ports.ErrInternal, result.Code)
+		require.Equal(t, protocol.ErrInternal, result.Code)
 		d.mu.Lock()
 		require.Same(t, sess, d.sessions[sess.id], "failed final-pane close must retain the session")
 		d.mu.Unlock()
 		selectTestAttachmentTabLocked(sess, 1)
 		sess.mu.Unlock()
-		result := sendCommand(t, d, ports.CommandRequest{Slug: "close-tab", TargetSession: "work"})
+		result := sendCommand(t, d, protocol.CommandRequest{Slug: "close-tab", TargetSession: "work"})
 		require.True(t, result.OK, result.Text)
 		sess.mu.Lock()
 			t.Cleanup(func() { factory.close(); d.sessWg.Wait() })
 			sess := addControlSession(d, "work", "t_work", "p_work")
-			result := sendCommand(t, d, ports.CommandRequest{Slug: tt.slug, Args: tt.args, TargetSession: "work"})
+			result := sendCommand(t, d, protocol.CommandRequest{Slug: tt.slug, Args: tt.args, TargetSession: "work"})
 			require.True(t, result.OK, result.Text)
 			tt.verify(t, d, sess)
 	source.tabs[0].size = domain.Size{Cols: 118, Rows: 38}
 	source.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
 	require.True(t, result.OK, result.Text)
 	d.mu.Lock()
 	tb.mu.Unlock()
 	require.Empty(t, source.snapshotAttachments())
-	taken := sendCommand(t, d, ports.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
+	taken := sendCommand(t, d, protocol.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
 	require.False(t, taken.OK)
-	require.Equal(t, ports.ErrNameTaken, taken.Code)
+	require.Equal(t, protocol.ErrNameTaken, taken.Code)
 }
 func TestHandleCommandNewSessionPreservesSourceGeometry(t *testing.T) {
 	})
 	require.True(t, source.registerAttachment(client))
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "new-session", Args: []string{"scripted"}, TargetSession: "work"})
 	require.True(t, result.OK, result.Text)
 	d.mu.Lock()
 	d := newTestDaemon(t, nil, stubClock{})
 	sess := addControlSession(d, "work", "t_work", "p_work")
-	bad := sendCommand(t, d, ports.CommandRequest{Slug: "toast", Args: []string{"-l", "loud", "hello"}, TargetSession: "work"})
+	bad := sendCommand(t, d, protocol.CommandRequest{Slug: "toast", Args: []string{"-l", "loud", "hello"}, TargetSession: "work"})
 	require.False(t, bad.OK)
-	require.Equal(t, ports.ErrInvalidCommandArgs, bad.Code)
+	require.Equal(t, protocol.ErrInvalidCommandArgs, bad.Code)
-	good := sendCommand(t, d, ports.CommandRequest{Slug: "toast", Args: []string{"-l", "warn", "hello"}, TargetSession: "work"})
+	good := sendCommand(t, d, protocol.CommandRequest{Slug: "toast", Args: []string{"-l", "warn", "hello"}, TargetSession: "work"})
 	require.True(t, good.OK, good.Text)
 	d.notices.mu.Lock()
 	require.Len(t, d.notices.pending, 1)
 	sess := addControlSession(d, "work", "t_work", "p_work")
 	sess.tabs[0].name = "shell"
-	sessions := sendCommand(t, d, ports.CommandRequest{Slug: "list-sessions"})
+	sessions := sendCommand(t, d, protocol.CommandRequest{Slug: "list-sessions"})
 	require.True(t, sessions.OK, sessions.Text)
 	require.Contains(t, sessions.Output, "NAME\tSTATE\tTABS\tATTACHED\tACTIVE")
 	require.Contains(t, sessions.Output, "work\tephemeral\t1\tfalse\ttrue")
-	tabs := sendCommand(t, d, ports.CommandRequest{Slug: "list-tabs", TargetSession: "work"})
+	tabs := sendCommand(t, d, protocol.CommandRequest{Slug: "list-tabs", TargetSession: "work"})
 	require.True(t, tabs.OK, tabs.Text)
 	require.Contains(t, tabs.Output, "0\tt_work\tshell\t1\ttrue")
-	panes := sendCommand(t, d, ports.CommandRequest{Slug: "list-panes", TargetSession: "work", JSON: true})
+	panes := sendCommand(t, d, protocol.CommandRequest{Slug: "list-panes", TargetSession: "work", JSON: true})
 	require.True(t, panes.OK, panes.Text)
 	var decoded []map[string]any
 	require.NoError(t, json.Unmarshal([]byte(panes.Output), &decoded))
 	build.mruAt.Store(1)
 	d.mu.Lock()
-	d.inactive["old"] = inactiveSession{name: "old", cwd: "/tmp/old", createdAt: 1, incarnation: domain.IncarnationID{3}, state: ports.SessionDown}
+	d.inactive["old"] = inactiveSession{name: "old", cwd: "/tmp/old", createdAt: 1, incarnation: domain.IncarnationID{3}, state: protocol.SessionDown}
 	// Live runtime authority wins if both registries contain the same name.
-	d.inactive["work"] = inactiveSession{name: "work", cwd: "/tmp/work", createdAt: 1, incarnation: domain.IncarnationID{4}, state: ports.SessionDown}
+	d.inactive["work"] = inactiveSession{name: "work", cwd: "/tmp/work", createdAt: 1, incarnation: domain.IncarnationID{4}, state: protocol.SessionDown}
 	d.mu.Unlock()
-	listBefore := sendCommand(t, d, ports.CommandRequest{Slug: "list-sessions"})
+	listBefore := sendCommand(t, d, protocol.CommandRequest{Slug: "list-sessions"})
 	require.True(t, listBefore.OK, listBefore.Text)
-	missingJSON := sendCommand(t, d, ports.CommandRequest{Slug: "remote-catalog"})
+	missingJSON := sendCommand(t, d, protocol.CommandRequest{Slug: "remote-catalog"})
 	require.False(t, missingJSON.OK)
-	require.Equal(t, ports.ErrInvalidCommandArgs, missingJSON.Code)
+	require.Equal(t, protocol.ErrInvalidCommandArgs, missingJSON.Code)
-	withArgs := sendCommand(t, d, ports.CommandRequest{Slug: "remote-catalog", Args: []string{"extra"}, JSON: true})
+	withArgs := sendCommand(t, d, protocol.CommandRequest{Slug: "remote-catalog", Args: []string{"extra"}, JSON: true})
 	require.False(t, withArgs.OK)
-	require.Equal(t, ports.ErrInvalidCommandArgs, withArgs.Code)
+	require.Equal(t, protocol.ErrInvalidCommandArgs, withArgs.Code)
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "remote-catalog", JSON: true})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "remote-catalog", JSON: true})
 	require.True(t, result.OK, result.Text)
 	require.True(t, strings.HasSuffix(result.Output, "\n"), "catalog output must be newline-terminated")
 	var catalog ports.RemoteCatalog
 	require.NoError(t, json.Unmarshal([]byte(result.Output), &catalog))
-	require.Equal(t, ports.ProtocolVersion, catalog.ProtocolVersion)
+	require.Equal(t, protocol.Version, catalog.ProtocolVersion)
 	raw := map[string]json.RawMessage{}
 	require.NoError(t, json.Unmarshal([]byte(result.Output), &raw))
 	require.Equal(t, ports.RemoteCatalogSessionDown, catalog.Sessions[1].State)
-	listAfter := sendCommand(t, d, ports.CommandRequest{Slug: "list-sessions"})
+	listAfter := sendCommand(t, d, protocol.CommandRequest{Slug: "list-sessions"})
 	require.True(t, listAfter.OK, listAfter.Text)
 	require.Equal(t, listBefore.Output, listAfter.Output)
 	require.Contains(t, listAfter.Output, "work\tnamed\t2\ttrue\t")
 		return "fish", nil
 	}
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "remote-catalog", JSON: true})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "remote-catalog", JSON: true})
 	require.True(t, result.OK, result.Text)
 	var catalog ports.RemoteCatalog
 	require.NoError(t, json.Unmarshal([]byte(result.Output), &catalog))
 	}
 	sess.mu.Unlock()
-	result := sendCommand(t, d, ports.CommandRequest{Slug: "remote-catalog", JSON: true})
+	result := sendCommand(t, d, protocol.CommandRequest{Slug: "remote-catalog", JSON: true})
 	require.False(t, result.OK)
 	require.Contains(t, result.Text, "too many tabs")
 }
 	sess.mu.Unlock()
 	original := target.tree.Focus
-	firstFrame := commandFrame(t, ports.CommandRequest{
+	firstFrame := commandFrame(t, protocol.CommandRequest{
 		Slug: "split-right", Self: true, TargetSession: "work",
 		TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 		t.Fatal("first command did not enter its blocked action")
 	}
-	secondFrame := commandFrame(t, ports.CommandRequest{
+	secondFrame := commandFrame(t, protocol.CommandRequest{
 		Slug: "focus-pane-right", Self: true, TargetSession: "work",
 		TargetTab: "t_invoking", TargetPane: "p_invoking",
 	})
 	source.mu.Unlock()
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-pane", Args: []string{"dest", "t_dest"}, TargetSession: "work",
 	})
 	require.True(t, result.OK, result.Text)
 	source.mu.Unlock()
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-pane", Args: []string{"dest", "t_dest"}, Self: true,
 		TargetSession: "work", TargetTab: "t_inactive", TargetPane: "p_inactive",
 	})
 	source.mu.Unlock()
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-tab", Args: []string{"dest"}, TargetSession: "work", Self: false,
 		TargetTab: "t_second", TargetPane: "p_second",
 	})
 	source.mu.Unlock()
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-tab", Args: []string{"dest"}, Self: true,
 		TargetSession: "work", TargetTab: "t_second", TargetPane: "p_second",
 	})
 func TestHandleCommandMoveCommandsRejectInvalidArgsAndTargets(t *testing.T) {
 	tests := []struct {
 		name    string
-		arrange func(*Daemon) ports.CommandRequest
+		arrange func(*Daemon) protocol.CommandRequest
 		code    uint16
 		text    string
 	}{
 		{
 			name: "move-pane missing destination session",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"work", "t_work"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"work", "t_work"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move request is invalid",
 		},
 		{
 			name: "move-pane unknown destination session",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"missing", "t_dest"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"missing", "t_dest"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move target is no longer available",
 		},
 		{
 			name: "move-pane destination tab not in session",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
 				addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_other"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_other"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move target is no longer available",
 		},
 		{
 			name: "move-pane same source tab",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"work", "t_work"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"work", "t_work"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move request is invalid",
 		},
 		{
 			name: "move-tab same session",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-tab", Args: []string{"work"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-tab", Args: []string{"work"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move request is invalid",
 		},
 		{
 			name: "move-tab stopping destination",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
 				destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
 				destination.teardownMu.Lock()
 				destination.teardownActive = true
 				destination.teardownMu.Unlock()
-				return ports.CommandRequest{Slug: "move-tab", Args: []string{"dest"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-tab", Args: []string{"dest"}, TargetSession: "work"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "move target is no longer available",
 		},
 		{
 			name: "move-pane too few args",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"dest"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"dest"}, TargetSession: "work"}
 			},
-			code: ports.ErrInvalidCommandArgs,
+			code: protocol.ErrInvalidCommandArgs,
 		},
 		{
 			name: "move-pane too many args",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_dest", "extra"}, TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_dest", "extra"}, TargetSession: "work"}
 			},
-			code: ports.ErrInvalidCommandArgs,
+			code: protocol.ErrInvalidCommandArgs,
 		},
 		{
 			name: "move-tab missing destination",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "work", "t_work", "p_work")
-				return ports.CommandRequest{Slug: "move-tab", TargetSession: "work"}
+				return protocol.CommandRequest{Slug: "move-tab", TargetSession: "work"}
 			},
-			code: ports.ErrInvalidCommandArgs,
+			code: protocol.ErrInvalidCommandArgs,
 		},
 		{
 			name: "explicit session name without IDs remains authoritative",
-			arrange: func(d *Daemon) ports.CommandRequest {
+			arrange: func(d *Daemon) protocol.CommandRequest {
 				addControlSession(d, "renamed", "t_work", "p_work")
 				addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-				return ports.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_dest"}, TargetSession: "old-name"}
+				return protocol.CommandRequest{Slug: "move-pane", Args: []string{"dest", "t_dest"}, TargetSession: "old-name"}
 			},
-			code: ports.ErrNoSuchTarget,
+			code: protocol.ErrNoSuchTarget,
 			text: "no such session: old-name",
 		},
 	}
 	source := addControlSession(d, "renamed", "t_work", "p_work")
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-pane", Args: []string{"dest", "t_dest"}, Self: true,
 		TargetSession: "old-name", TargetTab: "t_work", TargetPane: "p_work",
 	})
 	source.mu.Unlock()
 	destination := addNamedMoveDestination(d, "dest", "t_dest", "p_dest")
-	result := sendCommand(t, d, ports.CommandRequest{
+	result := sendCommand(t, d, protocol.CommandRequest{
 		Slug: "move-pane", Args: []string{"dest", "t_dest"}, Self: true,
 		TargetSession: "old-name", TargetTab: "t_inactive", TargetPane: "p_inactive",
 	})
 	selectTestAttachmentTabLocked(right, 1)
 	right.mu.Unlock()
-	leftFrame := commandFrame(t, ports.CommandRequest{
+	leftFrame := commandFrame(t, protocol.CommandRequest{
 		Slug: "move-tab", Args: []string{"right"}, TargetSession: "left",
 	})
-	rightFrame := commandFrame(t, ports.CommandRequest{
+	rightFrame := commandFrame(t, protocol.CommandRequest{
 		Slug: "move-tab", Args: []string{"left"}, TargetSession: "right",
 	})
 	leftTransport, leftSends, _ := newConn(t, leftFrame)
 	return sess
 }
-func commandFrame(t *testing.T, request ports.CommandRequest) ports.Frame {
+func commandFrame(t *testing.T, request protocol.CommandRequest) ports.Frame {
 	t.Helper()
 	if request.Version == 0 {
-		request.Version = ports.ProtocolVersion
+		request.Version = protocol.Version
 	}
 	payload, err := ports.MarshalCommandRequest(request)
 	require.NoError(t, err)
 	return ports.Frame{Type: ports.MsgCommand, Payload: payload}
 }
-func sendCommand(t *testing.T, d *Daemon, request ports.CommandRequest) ports.CommandResult {
+func sendCommand(t *testing.T, d *Daemon, request protocol.CommandRequest) protocol.CommandResult {
 	t.Helper()
 	frame := commandFrame(t, request)
 	tr, sends, _ := newConn(t, frame)
 	return awaitCommandResult(t, sends)
 }
-func awaitCommandResult(t *testing.T, sends chan ports.Frame) ports.CommandResult {
+func awaitCommandResult(t *testing.T, sends chan ports.Frame) protocol.CommandResult {
 	t.Helper()
 	reply := awaitFrame(t, sends, ports.MsgCommandResult)
 	result, err := ports.UnmarshalCommandResult(reply.Payload)

M internal/usecase/daemon/copymode_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"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	"github.com/bnema/vev/internal/usecase/ui"
 	// relying on wall-clock debounce delivery.
 	clk := newCoordinatorMockClock(t, 16)
 	d := newTestDaemon(t, newFactory(t, p), clk.clock)
-	tr, sends, releaseConn := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 16, Rows: 5}))
+	tr, sends, releaseConn := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 16, Rows: 5}))
 	advanceRender := func() {
 		deadline := time.NewTimer(2 * time.Second)
 		defer deadline.Stop()
 	releaseConn()
 	closeOnce.Do(func() { close(readDone) })
 	hg.Wait()
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 	d.sessWg.Wait()
 }

M internal/usecase/daemon/daemon.go +59 -59


@@ -374,7 +374,7 @@ type inactiveSession struct {
374		tabRecords []domain.CatalogueTabRecord	374		tabRecords []domain.CatalogueTabRecord
375		purging bool	375		purging bool
376		record domain.CatalogueRecord	376		record domain.CatalogueRecord
377	-	state ports.SessionState	377	+	state protocol.SessionState
378		restoreDone chan struct{}	378		restoreDone chan struct{}
379		}	379		}
380			380

@@ -391,7 +391,7 @@ func (s inactiveSession) restorePending() bool {
391		}	391		}
392			392
393		func (s inactiveSession) broken() bool {	393		func (s inactiveSession) broken() bool {
394	-	return s.state == ports.SessionBroken \|\| s.record.DegradedReason != ""	394	+	return s.state == protocol.SessionBroken \|\| s.record.DegradedReason != ""
395		}	395		}
396			396
397		func (s inactiveSession) visible() bool {	397		func (s inactiveSession) visible() bool {

@@ -399,7 +399,7 @@ func (s inactiveSession) visible() bool {
399		}	399		}
400			400
401		func (s inactiveSession) canResume() bool {	401		func (s inactiveSession) canResume() bool {
402	-	return s.visible() && s.state == ports.SessionDown && !s.broken()	402	+	return s.visible() && s.state == protocol.SessionDown && !s.broken()
403		}	403		}
404			404
405		func (s inactiveSession) sameLifecycle(other inactiveSession) bool {	405		func (s inactiveSession) sameLifecycle(other inactiveSession) bool {

@@ -717,7 +717,7 @@ func New(ptys ports.PTYFactory, clock ports.Clock, log *slog.Logger, opts ...Opt
717		state, done := initialSessionState(r)	717		state, done := initialSessionState(r)
718		d.inactive[r.Name] = inactiveSessionFromRecord(r, state, done)	718		d.inactive[r.Name] = inactiveSessionFromRecord(r, state, done)
719		} else {	719		} else {
720	-	d.inactive[r.Name] = inactiveSessionFromRecord(r, ports.SessionDown, nil)	720	+	d.inactive[r.Name] = inactiveSessionFromRecord(r, protocol.SessionDown, nil)
721		}	721		}
722		if !hasCreatedAt \|\| r.CreatedAt > maxCreatedAt {	722		if !hasCreatedAt \|\| r.CreatedAt > maxCreatedAt {
723		maxCreatedAt = r.CreatedAt	723		maxCreatedAt = r.CreatedAt

@@ -806,7 +806,7 @@ func (d *Daemon) Serve(ctx context.Context, l ports.Listener) error {
806		snapshotDeadline = newSnapshotShutdownDeadline(d.clock)	806		snapshotDeadline = newSnapshotShutdownDeadline(d.clock)
807		defer snapshotDeadline.stop()	807		defer snapshotDeadline.stop()
808		}	808		}
809	-	d.shutdownAllWithSnapshotDeadline(ports.ReasonServerShutdown, snapshotDeadline)	809	+	d.shutdownAllWithSnapshotDeadline(protocol.ReasonServerShutdown, snapshotDeadline)
810		d.waitNotifies()	810		d.waitNotifies()
811		d.hardCancel()	811		d.hardCancel()
812		d.serveCancel()	812		d.serveCancel()

@@ -826,7 +826,7 @@ func (d *Daemon) Serve(ctx context.Context, l ports.Listener) error {
826		d.persistShutdownSnapshotFailure(name, context.DeadlineExceeded)	826		d.persistShutdownSnapshotFailure(name, context.DeadlineExceeded)
827		}	827		}
828		d.WaitDurableWriters()	828		d.WaitDurableWriters()
829	-	d.shutdownAllWithSnapshotDeadline(ports.ReasonServerShutdown, snapshotDeadline)	829	+	d.shutdownAllWithSnapshotDeadline(protocol.ReasonServerShutdown, snapshotDeadline)
830		d.waitSessionWorkersWithSnapshotDeadline(snapshotDeadline)	830		d.waitSessionWorkersWithSnapshotDeadline(snapshotDeadline)
831		d.waitNotifies()	831		d.waitNotifies()
832		if err := d.flushCatalogue(); err != nil {	832		if err := d.flushCatalogue(); err != nil {

@@ -1058,7 +1058,7 @@ func (d *Daemon) handleConn(tr ports.Transport) {
1058		default:	1058		default:
1059		d.log.Warn("hello rejected", "err", "expected hello", "type", first.Type)	1059		d.log.Warn("hello rejected", "err", "expected hello", "type", first.Type)
1060		_ = boundedHandshakeOperation(handshakeCtx, tr, func() error {	1060		_ = boundedHandshakeOperation(handshakeCtx, tr, func() error {
1061	-	return tr.Send(frameError(ports.ErrInternal, "expected hello"))	1061	+	return tr.Send(frameError(protocol.ErrInternal, "expected hello"))
1062		})	1062		})
1063		stopTransport()	1063		stopTransport()
1064		finishHandshake()	1064		finishHandshake()

@@ -1072,17 +1072,17 @@ func (d *Daemon) handleList(tr ports.Transport) {
1072		defer func() { _ = tr.Close() }()	1072		defer func() { _ = tr.Close() }()
1073			1073
1074		d.mu.Lock()	1074		d.mu.Lock()
1075	-	infos := make([]ports.SessionInfo, 0, len(d.sessions)+len(d.inactive))	1075	+	infos := make([]protocol.SessionInfo, 0, len(d.sessions)+len(d.inactive))
1076		liveNames := make(map[string]struct{}, len(d.sessions))	1076		liveNames := make(map[string]struct{}, len(d.sessions))
1077		for _, s := range d.sessions {	1077		for _, s := range d.sessions {
1078		if s == nil {	1078		if s == nil {
1079		continue	1079		continue
1080		}	1080		}
1081		s.mu.Lock()	1081		s.mu.Lock()
1082	-	info := ports.SessionInfo{	1082	+	info := protocol.SessionInfo{
1083		SessionID: string(s.id),	1083		SessionID: string(s.id),
1084		Name: s.name,	1084		Name: s.name,
1085	-	State: ports.SessionUp,	1085	+	State: protocol.SessionUp,
1086		Ephemeral: s.ephemeral,	1086		Ephemeral: s.ephemeral,
1087		Tabs: uint16(len(s.tabs)),	1087		Tabs: uint16(len(s.tabs)),
1088		Attached: len(s.attachments) != 0,	1088		Attached: len(s.attachments) != 0,

@@ -1095,11 +1095,11 @@ func (d *Daemon) handleList(tr ports.Transport) {
1095		if _, live := liveNames[name]; live \|\| !inactive.visible() {	1095		if _, live := liveNames[name]; live \|\| !inactive.visible() {
1096		continue	1096		continue
1097		}	1097		}
1098	-	state := ports.SessionDown	1098	+	state := protocol.SessionDown
1099		if inactive.broken() {	1099		if inactive.broken() {
1100	-	state = ports.SessionBroken	1100	+	state = protocol.SessionBroken
1101		}	1101		}
1102	-	infos = append(infos, ports.SessionInfo{Name: name, State: state})	1102	+	infos = append(infos, protocol.SessionInfo{Name: name, State: state})
1103		}	1103		}
1104		d.mu.Unlock()	1104		d.mu.Unlock()
1105			1105

@@ -1115,11 +1115,11 @@ func (d *Daemon) handleKill(tr ports.Transport, f ports.Frame) {
1115			1115
1116		k, err := ports.UnmarshalKill(f.Payload)	1116		k, err := ports.UnmarshalKill(f.Payload)
1117		if err != nil {	1117		if err != nil {
1118	-	_ = d.boundedControlSend(tr, frameError(ports.ErrInternal, "malformed kill request"))	1118	+	_ = d.boundedControlSend(tr, frameError(protocol.ErrInternal, "malformed kill request"))
1119		return	1119		return
1120		}	1120		}
1121		if k.All {	1121		if k.All {
1122	-	d.shutdownAll(ports.ReasonServerShutdown)	1122	+	d.shutdownAll(protocol.ReasonServerShutdown)
1123		return	1123		return
1124		}	1124		}
1125			1125

@@ -1132,7 +1132,7 @@ func (d *Daemon) handleKill(tr ports.Transport, f ports.Frame) {
1132		// deletion order as live and offline purges.	1132		// deletion order as live and offline purges.
1133		if err := d.retryStoppedPurge(k.Name); err != nil {	1133		if err := d.retryStoppedPurge(k.Name); err != nil {
1134		d.log.Warn("deleting stopped session failed", "err", err, "session", k.Name)	1134		d.log.Warn("deleting stopped session failed", "err", err, "session", k.Name)
1135	-	_ = d.boundedControlSend(tr, frameError(ports.ErrInternal, "deleting stopped session failed"))	1135	+	_ = d.boundedControlSend(tr, frameError(protocol.ErrInternal, "deleting stopped session failed"))
1136		}	1136		}
1137		return	1137		return
1138		}	1138		}

@@ -1140,11 +1140,11 @@ func (d *Daemon) handleKill(tr ports.Transport, f ports.Frame) {
1140		d.mu.Unlock()	1140		d.mu.Unlock()
1141			1141
1142		if target == nil {	1142		if target == nil {
1143	-	_ = d.boundedControlSend(tr, frameError(ports.ErrNoSuchSession, "no such session: "+k.Name))	1143	+	_ = d.boundedControlSend(tr, frameError(protocol.ErrNoSuchSession, "no such session: "+k.Name))
1144		return	1144		return
1145		}	1145		}
1146	-	if err := d.killSession(target, ports.ReasonSessionKilled, true); err != nil {	1146	+	if err := d.killSession(target, protocol.ReasonSessionKilled, true); err != nil {
1147	-	_ = d.boundedControlSend(tr, frameError(ports.ErrInternal, "deleting persisted session failed"))	1147	+	_ = d.boundedControlSend(tr, frameError(protocol.ErrInternal, "deleting persisted session failed"))
1148		}	1148		}
1149		}	1149		}
1150			1150

@@ -1175,19 +1175,19 @@ func (d *Daemon) handleHelloWithContext(handshakeCtx context.Context, timedOut <
1175		}	1175		}
1176		h, err := ports.UnmarshalHello(f.Payload)	1176		h, err := ports.UnmarshalHello(f.Payload)
1177		if err != nil {	1177		if err != nil {
1178	-	if version, ok := ports.PeekHelloVersion(f.Payload); ok && version != ports.ProtocolVersion {	1178	+	if version, ok := ports.PeekHelloVersion(f.Payload); ok && version != protocol.Version {
1179	-	d.log.Warn("hello rejected", "err", "protocol version mismatch", "version", version, "expected", ports.ProtocolVersion)	1179	+	d.log.Warn("hello rejected", "err", "protocol version mismatch", "version", version, "expected", protocol.Version)
1180	-	_ = sendHandshake(frameError(ports.ErrVersionMismatch, "protocol version mismatch"))	1180	+	_ = sendHandshake(frameError(protocol.ErrVersionMismatch, "protocol version mismatch"))
1181		} else {	1181		} else {
1182		d.log.Warn("hello rejected", "err", err)	1182		d.log.Warn("hello rejected", "err", err)
1183	-	_ = sendHandshake(frameError(ports.ErrInternal, "malformed hello"))	1183	+	_ = sendHandshake(frameError(protocol.ErrInternal, "malformed hello"))
1184		}	1184		}
1185		_ = tr.Close()	1185		_ = tr.Close()
1186		return	1186		return
1187		}	1187		}
1188	-	if h.Version != ports.ProtocolVersion {	1188	+	if h.Version != protocol.Version {
1189	-	d.log.Warn("hello rejected", "err", "protocol version mismatch", "version", h.Version, "expected", ports.ProtocolVersion, "intent", h.Intent, "session", h.Name)	1189	+	d.log.Warn("hello rejected", "err", "protocol version mismatch", "version", h.Version, "expected", protocol.Version, "intent", h.Intent, "session", h.Name)
1190	-	_ = sendHandshake(frameError(ports.ErrVersionMismatch, "protocol version mismatch"))	1190	+	_ = sendHandshake(frameError(protocol.ErrVersionMismatch, "protocol version mismatch"))
1191		_ = tr.Close()	1191		_ = tr.Close()
1192		return	1192		return
1193		}	1193		}

@@ -1198,7 +1198,7 @@ func (d *Daemon) handleHelloWithContext(handshakeCtx context.Context, timedOut <
1198		if pe, ok := errors.AsType[*protoErr](rerr); ok {	1198		if pe, ok := errors.AsType[*protoErr](rerr); ok {
1199		_ = sendHandshake(frameError(pe.code, pe.text))	1199		_ = sendHandshake(frameError(pe.code, pe.text))
1200		} else {	1200		} else {
1201	-	_ = sendHandshake(frameError(ports.ErrInternal, rerr.Error()))	1201	+	_ = sendHandshake(frameError(protocol.ErrInternal, rerr.Error()))
1202		}	1202		}
1203		_ = tr.Close()	1203		_ = tr.Close()
1204		return	1204		return

@@ -1310,7 +1310,7 @@ func (e *protoErr) Error() string { return e.text }
1310		// unlocking d.mu before returning, including every error path. It publishes	1310		// unlocking d.mu before returning, including every error path. It publishes
1311		// terminal and role state before releasing d.mu, then defers coordinator	1311		// terminal and role state before releasing d.mu, then defers coordinator
1312		// cleanup so obsolete workers never delay the new handshake.	1312		// cleanup so obsolete workers never delay the new handshake.
1313	-	func (d Daemon) finishAttach(sess session, tr ports.Transport, sz domain.Size, h ports.Hello) (*attachedClient, error) {	1313	+	func (d Daemon) finishAttach(sess session, tr ports.Transport, sz domain.Size, h protocol.Hello) (*attachedClient, error) {
1314		initialTabIndex := -1	1314		initialTabIndex := -1
1315		if h.RemoteTarget != nil {	1315		if h.RemoteTarget != nil {
1316		var ok bool	1316		var ok bool

@@ -1320,7 +1320,7 @@ func (d Daemon) finishAttach(sess session, tr ports.Transport, sz domain.Size,
1320		_ = tr.Close()	1320		_ = tr.Close()
1321		}	1321		}
1322		d.mu.Unlock()	1322		d.mu.Unlock()
1323	-	return nil, &protoErr{ports.ErrNoSuchTarget, "remote tab no longer exists"}	1323	+	return nil, &protoErr{protocol.ErrNoSuchTarget, "remote tab no longer exists"}
1324		}	1324		}
1325		}	1325		}
1326		if h.PreferredTabID != "" {	1326		if h.PreferredTabID != "" {

@@ -1334,7 +1334,7 @@ func (d Daemon) finishAttach(sess session, tr ports.Transport, sz domain.Size,
1334		// A picker handoff deliberately leaves the daemon-owned environment and CWD	1334		// A picker handoff deliberately leaves the daemon-owned environment and CWD
1335		// untouched, even though Hello retains those fields for direct CLI clients.	1335		// untouched, even though Hello retains those fields for direct CLI clients.
1336		sess.mu.Lock()	1336		sess.mu.Lock()
1337	-	if h.EnvironmentPolicy != ports.EnvironmentPolicyDaemonOwned {	1337	+	if h.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
1338		sess.env = copyEnvironment(h.Env)	1338		sess.env = copyEnvironment(h.Env)
1339		}	1339		}
1340		sess.mu.Unlock()	1340		sess.mu.Unlock()

@@ -1439,12 +1439,12 @@ func (d *Daemon) waitForTargetRestore(ctx context.Context, name string) error {
1439		return nil	1439		return nil
1440		}	1440		}
1441		if stopped.broken() {	1441		if stopped.broken() {
1442	-	return &protoErr{ports.ErrInternal, "session durable state is broken: " + name}	1442	+	return &protoErr{protocol.ErrInternal, "session durable state is broken: " + name}
1443		}	1443		}
1444		if stopped.record.Committed == nil {	1444		if stopped.record.Committed == nil {
1445		return nil	1445		return nil
1446		}	1446		}
1447	-	return &protoErr{ports.ErrInternal, "session was not restored into this daemon: " + name}	1447	+	return &protoErr{protocol.ErrInternal, "session was not restored into this daemon: " + name}
1448		}	1448		}
1449			1449
1450		// route resolves a Hello to a session and a freshly attached client, creating	1450		// route resolves a Hello to a session and a freshly attached client, creating

@@ -1453,20 +1453,20 @@ func (d *Daemon) waitForTargetRestore(ctx context.Context, name string) error {
1453		func (d *Daemon) validateExactSessionTargetLocked(target protocol.ExactSessionTarget) error {	1453		func (d *Daemon) validateExactSessionTargetLocked(target protocol.ExactSessionTarget) error {
1454		if sess := d.findByNameLocked(target.SessionName); sess != nil {	1454		if sess := d.findByNameLocked(target.SessionName); sess != nil {
1455		if sess.incarnation != target.LifecycleID {	1455		if sess.incarnation != target.LifecycleID {
1456	-	return &protoErr{ports.ErrNoSuchSession, "session lifecycle has changed: " + target.SessionName}	1456	+	return &protoErr{protocol.ErrNoSuchSession, "session lifecycle has changed: " + target.SessionName}
1457		}	1457		}
1458		return nil	1458		return nil
1459		}	1459		}
1460		stopped, ok := d.inactive[target.SessionName]	1460		stopped, ok := d.inactive[target.SessionName]
1461		if !ok \|\| !stopped.visible() \|\| stopped.incarnation != target.LifecycleID {	1461		if !ok \|\| !stopped.visible() \|\| stopped.incarnation != target.LifecycleID {
1462	-	return &protoErr{ports.ErrNoSuchSession, "no such session lifecycle: " + target.SessionName}	1462	+	return &protoErr{protocol.ErrNoSuchSession, "no such session lifecycle: " + target.SessionName}
1463		}	1463		}
1464		return nil	1464		return nil
1465		}	1465		}
1466			1466
1467		func (d *Daemon) validateExactSessionTarget(ctx context.Context, target protocol.ExactSessionTarget) error {	1467		func (d *Daemon) validateExactSessionTarget(ctx context.Context, target protocol.ExactSessionTarget) error {
1468		if err := target.Validate(); err != nil {	1468		if err := target.Validate(); err != nil {
1469	-	return &protoErr{ports.ErrNoSuchSession, "invalid exact session target"}	1469	+	return &protoErr{protocol.ErrNoSuchSession, "invalid exact session target"}
1470		}	1470		}
1471		if err := d.waitForTargetRestore(ctx, target.SessionName); err != nil {	1471		if err := d.waitForTargetRestore(ctx, target.SessionName); err != nil {
1472		return err	1472		return err

@@ -1477,7 +1477,7 @@ func (d *Daemon) validateExactSessionTarget(ctx context.Context, target protocol
1477		return d.validateExactSessionTargetLocked(target)	1477		return d.validateExactSessionTargetLocked(target)
1478		}	1478		}
1479			1479
1480	-	func (d Daemon) route(h ports.Hello, tr ports.Transport) (session, *attachedClient, error) {	1480	+	func (d Daemon) route(h protocol.Hello, tr ports.Transport) (session, *attachedClient, error) {
1481		ctx := d.serveCtx	1481		ctx := d.serveCtx
1482		if ctx == nil {	1482		if ctx == nil {
1483		ctx = context.Background()	1483		ctx = context.Background()

@@ -1485,7 +1485,7 @@ func (d Daemon) route(h ports.Hello, tr ports.Transport) (session, *attachedCl
1485		return d.routeWithContext(ctx, h, tr)	1485		return d.routeWithContext(ctx, h, tr)
1486		}	1486		}
1487			1487
1488	-	func (d Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.Transport) (session, *attachedClient, error) {	1488	+	func (d Daemon) routeWithContext(ctx context.Context, h protocol.Hello, tr ports.Transport) (session, *attachedClient, error) {
1489		if ctx == nil {	1489		if ctx == nil {
1490		ctx = context.Background()	1490		ctx = context.Background()
1491		}	1491		}

@@ -1494,13 +1494,13 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1494		}	1494		}
1495		sz := h.Size	1495		sz := h.Size
1496		if !sz.Valid() {	1496		if !sz.Valid() {
1497	-	return nil, nil, &protoErr{ports.ErrInternal, "invalid terminal size"}	1497	+	return nil, nil, &protoErr{protocol.ErrInternal, "invalid terminal size"}
1498		}	1498		}
1499	-	if h.Intent == ports.IntentResume && h.ResumeToken == 0 {	1499	+	if h.Intent == protocol.IntentResume && h.ResumeToken == 0 {
1500	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "resume token is required"}	1500	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "resume token is required"}
1501		}	1501		}
1502		if h.ExactTarget != nil && h.ResumeToken == 0 && h.Name != h.ExactTarget.SessionName {	1502		if h.ExactTarget != nil && h.ResumeToken == 0 && h.Name != h.ExactTarget.SessionName {
1503	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "exact session target name mismatch"}	1503	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "exact session target name mismatch"}
1504		}	1504		}
1505		if h.RemoteTarget != nil && h.ResumeToken == 0 {	1505		if h.RemoteTarget != nil && h.ResumeToken == 0 {
1506		return d.routeRemoteTargetWithContext(ctx, h, tr)	1506		return d.routeRemoteTargetWithContext(ctx, h, tr)

@@ -1526,36 +1526,36 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1526		// Live recovery parked then lost a competing resumeParked	1526		// Live recovery parked then lost a competing resumeParked
1527		// race; keep the fail-closed wire response instead of	1527		// race; keep the fail-closed wire response instead of
1528		// leaking the internal sentinel to handleHello as ErrInternal.	1528		// leaking the internal sentinel to handleHello as ErrInternal.
1529	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}	1529	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
1530		}	1530		}
1531		return nil, nil, err	1531		return nil, nil, err
1532		} else if ok {	1532		} else if ok {
1533		return sess, ac, nil	1533		return sess, ac, nil
1534		}	1534		}
1535	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}	1535	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
1536		}	1536		}
1537		if sess, ac, ok, err := d.resumeParked(h, tr, sz); err == nil {	1537		if sess, ac, ok, err := d.resumeParked(h, tr, sz); err == nil {
1538		if ok {	1538		if ok {
1539		return sess, ac, nil	1539		return sess, ac, nil
1540		}	1540		}
1541	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}	1541	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
1542		} else if errors.Is(err, errResumeTokenLifecycleRace) {	1542		} else if errors.Is(err, errResumeTokenLifecycleRace) {
1543		// The parked entry was replaced while this handshake waited for	1543		// The parked entry was replaced while this handshake waited for
1544		// its send lock. Fail closed on the original credential rather	1544		// its send lock. Fail closed on the original credential rather
1545		// than falling through to ordinary attach/create routing.	1545		// than falling through to ordinary attach/create routing.
1546	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}	1546	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
1547		} else {	1547		} else {
1548		return nil, nil, err	1548		return nil, nil, err
1549		}	1549		}
1550		}	1550		}
1551	-	if h.Intent == ports.IntentResume \|\| h.Intent == ports.IntentAttach {	1551	+	if h.Intent == protocol.IntentResume \|\| h.Intent == protocol.IntentAttach {
1552		if err := d.waitForTargetRestore(ctx, h.Name); err != nil {	1552		if err := d.waitForTargetRestore(ctx, h.Name); err != nil {
1553		return nil, nil, err	1553		return nil, nil, err
1554		}	1554		}
1555		}	1555		}
1556	-	if h.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned && h.RemoteTarget == nil &&	1556	+	if h.EnvironmentPolicy == protocol.EnvironmentPolicyDaemonOwned && h.RemoteTarget == nil &&
1557	-	(h.Intent == ports.IntentNew \|\| h.Intent == ports.IntentEphemeral) {	1557	+	(h.Intent == protocol.IntentNew \|\| h.Intent == protocol.IntentEphemeral) {
1558	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "daemon-owned environment requires an exact remote target"}	1558	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "daemon-owned environment requires an exact remote target"}
1559		}	1559		}
1560		d.mu.Lock()	1560		d.mu.Lock()
1561		// Shutdown/create interlock: once shutdown has begun (last session removed,	1561		// Shutdown/create interlock: once shutdown has begun (last session removed,

@@ -1564,7 +1564,7 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1564		// anything inserted now would leak its PTY and hang Serve.	1564		// anything inserted now would leak its PTY and hang Serve.
1565		if d.closing {	1565		if d.closing {
1566		d.mu.Unlock()	1566		d.mu.Unlock()
1567	-	return nil, nil, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}	1567	+	return nil, nil, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
1568		}	1568		}
1569		// The first exact-target check happens before restore I/O. Recheck while	1569		// The first exact-target check happens before restore I/O. Recheck while
1570		// holding d.mu so a same-name lifecycle replacement cannot slip between	1570		// holding d.mu so a same-name lifecycle replacement cannot slip between

@@ -1576,7 +1576,7 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1576		}	1576		}
1577		}	1577		}
1578		switch h.Intent {	1578		switch h.Intent {
1579	-	case ports.IntentEphemeral:	1579	+	case protocol.IntentEphemeral:
1580		name := d.allocEphemeralNameLocked()	1580		name := d.allocEphemeralNameLocked()
1581		sess, err := d.createSessionLockedWithMode(name, true, h.Cwd, h.Geometry(), h.Env)	1581		sess, err := d.createSessionLockedWithMode(name, true, h.Cwd, h.Geometry(), h.Env)
1582		if err != nil {	1582		if err != nil {

@@ -1586,18 +1586,18 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1586		ac, err := d.finishRouteAttach(sess, tr, sz, h, true, true)	1586		ac, err := d.finishRouteAttach(sess, tr, sz, h, true, true)
1587		return sess, ac, err	1587		return sess, ac, err
1588			1588
1589	-	case ports.IntentNew:	1589	+	case protocol.IntentNew:
1590		if h.Name == "" {	1590		if h.Name == "" {
1591		d.mu.Unlock()	1591		d.mu.Unlock()
1592	-	return nil, nil, &protoErr{ports.ErrInvalidSessionName, "empty session name"}	1592	+	return nil, nil, &protoErr{protocol.ErrInvalidSessionName, "empty session name"}
1593		}	1593		}
1594		if err := domain.ValidateSessionName(h.Name); err != nil {	1594		if err := domain.ValidateSessionName(h.Name); err != nil {
1595		d.mu.Unlock()	1595		d.mu.Unlock()
1596	-	return nil, nil, &protoErr{ports.ErrInvalidSessionName, err.Error()}	1596	+	return nil, nil, &protoErr{protocol.ErrInvalidSessionName, err.Error()}
1597		}	1597		}
1598		if d.nameLiveOrStoppedLocked(h.Name) {	1598		if d.nameLiveOrStoppedLocked(h.Name) {
1599		d.mu.Unlock()	1599		d.mu.Unlock()
1600	-	return nil, nil, &protoErr{ports.ErrNameTaken, "session name already in use: " + h.Name}	1600	+	return nil, nil, &protoErr{protocol.ErrNameTaken, "session name already in use: " + h.Name}
1601		}	1601		}
1602		sess, err := d.createSessionLockedWithMode(h.Name, false, h.Cwd, h.Geometry(), h.Env)	1602		sess, err := d.createSessionLockedWithMode(h.Name, false, h.Cwd, h.Geometry(), h.Env)
1603		if err != nil {	1603		if err != nil {

@@ -1607,18 +1607,18 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1607		ac, err := d.finishRouteAttach(sess, tr, sz, h, true, true)	1607		ac, err := d.finishRouteAttach(sess, tr, sz, h, true, true)
1608		return sess, ac, err	1608		return sess, ac, err
1609			1609
1610	-	case ports.IntentAttach:	1610	+	case protocol.IntentAttach:
1611		sess := d.findByNameLocked(h.Name)	1611		sess := d.findByNameLocked(h.Name)
1612		created := false	1612		created := false
1613		if sess == nil {	1613		if sess == nil {
1614		stopped, ok := d.inactive[h.Name]	1614		stopped, ok := d.inactive[h.Name]
1615		if !ok \|\| !stopped.canResume() {	1615		if !ok \|\| !stopped.canResume() {
1616		d.mu.Unlock()	1616		d.mu.Unlock()
1617	-	return nil, nil, &protoErr{ports.ErrNoSuchSession, "no such resumable session: " + h.Name}	1617	+	return nil, nil, &protoErr{protocol.ErrNoSuchSession, "no such resumable session: " + h.Name}
1618		}	1618		}
1619		cwd := d.dirOrHome(stopped.cwd)	1619		cwd := d.dirOrHome(stopped.cwd)
1620		env := h.Env	1620		env := h.Env
1621	-	if h.EnvironmentPolicy == ports.EnvironmentPolicyDaemonOwned {	1621	+	if h.EnvironmentPolicy == protocol.EnvironmentPolicyDaemonOwned {
1622		env = copyEnvironment(d.baseEnv)	1622		env = copyEnvironment(d.baseEnv)
1623		}	1623		}
1624		var err error	1624		var err error

@@ -1634,6 +1634,6 @@ func (d *Daemon) routeWithContext(ctx context.Context, h ports.Hello, tr ports.T
1634			1634
1635		default:	1635		default:
1636		d.mu.Unlock()	1636		d.mu.Unlock()
1637	-	return nil, nil, &protoErr{ports.ErrInternal, "unknown intent"}	1637	+	return nil, nil, &protoErr{protocol.ErrInternal, "unknown intent"}
1638		}	1638		}
1639		}	1639		}

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

 	"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"
 )
 }
 func mustHello(intent uint8, name string, sz domain.Size) ports.Frame {
-	return ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(ports.Hello{
+	return ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color",
+		Version: protocol.Version, Intent: intent, Name: name, Size: sz, TermEnv: "xterm-256color",
 	})}
 }
 func frameInput(data []byte) ports.Frame {
-	return ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: data})}
+	return ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: data})}
 }
 func screenLineText(s *vt.Screen, y int) string {
 	return len(d.sessions)
 }
-func listSessions(t *testing.T, d *Daemon) ports.Sessions {
+func listSessions(t *testing.T, d *Daemon) protocol.Sessions {
 	t.Helper()
-	tr, sends, _ := newConn(t, ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(ports.List{})})
+	tr, sends, _ := newConn(t, ports.Frame{Type: ports.MsgList, Payload: ports.MarshalList(protocol.List{})})
 	d.handleList(tr)
 	f := awaitFrame(t, sends, ports.MsgSessions)
 	sessions, err := ports.UnmarshalSessions(f.Payload)
 			d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 			transport := &closeTrackingTransport{}
-			sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), transport)
+			sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), transport)
 			require.NoError(t, err)
 			token := ac.resumeToken
 			d.clientGone(sess, ac, transport, false)
 			d.mu.Unlock()
 			require.NotNil(t, parked)
-			invalid := helloResumeCapable(ports.IntentResume, "work", token)
+			invalid := helloResumeCapable(protocol.IntentResume, "work", token)
 			invalid.Size = tt.size
 			_, _, err = d.route(invalid, &closeTrackingTransport{})
 			var protocolErr *protoErr
 			require.ErrorAs(t, err, &protocolErr)
-			require.Equal(t, ports.ErrInternal, protocolErr.code)
+			require.Equal(t, protocol.ErrInternal, protocolErr.code)
 			d.mu.Lock()
 			require.Same(t, parked, d.parked[token], "invalid resume must not consume the parked attachment")
 	tr := newWelcomeBlockingTransport(t)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(tr.tr, mustHello(ports.IntentNew, "welcome-gate", domain.Size{Cols: 80, Rows: 24}))
+		d.handleHello(tr.tr, mustHello(protocol.IntentNew, "welcome-gate", domain.Size{Cols: 80, Rows: 24}))
 		close(done)
 	}()

M internal/usecase/daemon/durable_recovery_test.go +33 -32

 	"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"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 	snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
 )
 		healthyEntry := d.inactive[healthy.Name]
 		brokenEntry := d.inactive[broken.Name]
 		d.mu.Unlock()
-		require.Equal(t, ports.SessionDown, healthyEntry.state)
+		require.Equal(t, protocol.SessionDown, healthyEntry.state)
-		require.Equal(t, ports.SessionBroken, brokenEntry.state)
+		require.Equal(t, protocol.SessionBroken, brokenEntry.state)
 		for name, done := range map[string]<-chan struct{}{healthy.Name: healthyEntry.restoreDone, broken.Name: brokenEntry.restoreDone} {
 			select {
 			case <-done:
 	require.Empty(t, fresh.DegradedReason)
 	require.Empty(t, fresh.TabNames)
 	require.Equal(t, []domain.IncarnationID{incompatible.IncarnationID}, repository.deleted)
-	require.Equal(t, ports.SessionDown, d.inactive[incompatible.Name].state)
+	require.Equal(t, protocol.SessionDown, d.inactive[incompatible.Name].state)
 	require.Equal(t, fresh, d.inactive[incompatible.Name].record)
 	restoredSibling, ok, err := catalogue.Record(healthy.Name)
 	require.NoError(t, err)
 	require.True(t, ok)
 	require.Equal(t, healthy, restoredSibling)
-	require.Equal(t, ports.SessionDown, d.inactive[healthy.Name].state)
+	require.Equal(t, protocol.SessionDown, d.inactive[healthy.Name].state)
 	require.Equal(t, 1, repository.loads[healthy.Name])
 }
 	d.mu.Lock()
 	entry := d.inactive[record.Name]
 	d.mu.Unlock()
-	require.Equal(t, ports.SessionDown, entry.state)
+	require.Equal(t, protocol.SessionDown, entry.state)
 	require.Equal(t, fresh, entry.record)
 	require.Equal(t, restoreDone, entry.restoreDone)
 	select {
 	d.mu.Lock()
 	entry = d.inactive[record.Name]
 	d.mu.Unlock()
-	require.Equal(t, ports.SessionDown, entry.state)
+	require.Equal(t, protocol.SessionDown, entry.state)
 	require.Equal(t, fresh, entry.record)
 	select {
 	case <-entry.restoreDone:
 			require.Equal(t, record.IncarnationID, persisted.IncarnationID)
 			require.Equal(t, record.Committed, persisted.Committed)
 			require.Equal(t, "checkpoint validation failed", persisted.DegradedReason)
-			require.Equal(t, ports.SessionBroken, d.inactive[record.Name].state)
+			require.Equal(t, protocol.SessionBroken, d.inactive[record.Name].state)
 			require.Empty(t, repository.deleted)
 		})
 	}
 	require.Len(t, d.inactive, count)
 	for _, record := range records {
-		require.Equal(t, ports.SessionDown, d.inactive[record.Name].state)
+		require.Equal(t, protocol.SessionDown, d.inactive[record.Name].state)
 		require.Equal(t, 1, repository.loads[record.Name])
 	}
 }
 	// discovery API and therefore performs exactly one direct catalogue lookup.
 	d.restoreCatalogue(context.Background(), mustDurableRecords(t, catalogue))
-	require.Equal(t, ports.SessionDown, d.inactive[record.Name].state)
+	require.Equal(t, protocol.SessionDown, d.inactive[record.Name].state)
 	require.Equal(t, 1, repository.loads[record.Name])
 }
 	d.restoreCatalogue(context.Background(), mustDurableRecords(t, catalogue))
-	require.Equal(t, ports.SessionBroken, d.inactive[record.Name].state)
+	require.Equal(t, protocol.SessionBroken, d.inactive[record.Name].state)
 	got, _, _ := catalogue.Record(record.Name)
 	require.Equal(t, "checkpoint validation failed", got.DegradedReason)
 }
 					name: record.Name, cwd: record.Cwd, createdAt: record.CreatedAt,
 					incarnation: record.IncarnationID, lastUsedSeq: record.LastUsedSeq,
 					tabNames: append([]string(nil), record.TabNames...), record: record,
-					state: ports.SessionDown, restoreDone: make(chan struct{}),
+					state: protocol.SessionDown, restoreDone: make(chan struct{}),
 				}
 			}
 			beforeStopped, hadStopped := d.inactive[tc.sessName]
 	_, err := (controlExec{d: d, recoveryName: degraded.Name}).SessionRecovery("discard")
 	require.NoError(t, err)
-	require.Equal(t, ports.SessionDown, d.inactive[degraded.Name].state)
+	require.Equal(t, protocol.SessionDown, d.inactive[degraded.Name].state)
 	require.Equal(t, fresh, d.inactive[degraded.Name].record)
 }
 	d, _ := newDurableRecoveryDaemon(t, []domain.CatalogueRecord{fresh, restoring, degraded}, &durableRecoveryRepository{})
 	listed := listSessions(t, d)
-	require.Equal(t, []ports.SessionInfo{
+	require.Equal(t, []protocol.SessionInfo{
-		{Name: fresh.Name, State: ports.SessionDown},
+		{Name: fresh.Name, State: protocol.SessionDown},
-		{Name: restoring.Name, State: ports.SessionDown},
+		{Name: restoring.Name, State: protocol.SessionDown},
-		{Name: degraded.Name, State: ports.SessionBroken},
+		{Name: degraded.Name, State: protocol.SessionBroken},
 	}, listed.Sessions)
 }
 	d.mu.Lock()
 	entry := d.inactive[record.Name]
 	entry.purging = true
-	entry.state = ports.SessionDown
+	entry.state = protocol.SessionDown
 	d.inactive[record.Name] = entry
 	d.mu.Unlock()
 	result := make(chan error, 1)
 	go func() {
-		_, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name, Size: domain.Size{Cols: 80, Rows: 24}}, nil)
+		_, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name, Size: domain.Size{Cols: 80, Rows: 24}}, nil)
 		result <- err
 	}()
 	}
 	require.Zero(t, factory.calls.Load())
-	d.setStoppedRecovery(record, ports.SessionBroken)
+	d.setStoppedRecovery(record, protocol.SessionBroken)
 	d.mu.Lock()
 	closeRuntimeRestoreDoneLocked(d.inactive[record.Name].restoreDone)
 	d.mu.Unlock()
 	var protocolError *protoErr
 	require.ErrorAs(t, <-result, &protocolError)
-	require.Equal(t, ports.ErrInternal, protocolError.code)
+	require.Equal(t, protocol.ErrInternal, protocolError.code)
 	require.Zero(t, factory.calls.Load())
 }
 	attached := make(chan error, 1)
 	go func() {
-		_, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name}, nil)
+		_, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name}, nil)
 		attached <- err
 	}()
 	cancelRestore()
 	var protocolError *protoErr
 	require.ErrorAs(t, <-attached, &protocolError)
-	require.Equal(t, ports.ErrInternal, protocolError.code)
+	require.Equal(t, protocol.ErrInternal, protocolError.code)
 	<-restored
 	entry := d.inactive[record.Name]
-	require.Equal(t, ports.SessionBroken, entry.state)
+	require.Equal(t, protocol.SessionBroken, entry.state)
 	require.Equal(t, "restore interrupted", entry.record.DegradedReason)
 	select {
 	case <-entry.restoreDone:
 	case err := <-result:
 		var protocolError *protoErr
 		require.ErrorAs(t, err, &protocolError)
-		require.Equal(t, ports.ErrInternal, protocolError.code)
+		require.Equal(t, protocol.ErrInternal, protocolError.code)
 	case <-time.After(time.Second):
 		t.Fatal("waiter spun on a closed restore channel")
 	}
 	record := durableRecoveryRecord(0)
 	tests := []struct {
 		name    string
-		state   ports.SessionState
+		state   protocol.SessionState
 		message string
 	}{
-		{name: "healthy record without runtime", state: ports.SessionDown, message: "session was not restored into this daemon: " + record.Name},
+		{name: "healthy record without runtime", state: protocol.SessionDown, message: "session was not restored into this daemon: " + record.Name},
-		{name: "broken durable state", state: ports.SessionBroken, message: "session durable state is broken: " + record.Name},
+		{name: "broken durable state", state: protocol.SessionBroken, message: "session durable state is broken: " + record.Name},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var protocolError *protoErr
 			require.ErrorAs(t, d.waitForTargetRestore(context.Background(), record.Name), &protocolError)
-			require.Equal(t, ports.ErrInternal, protocolError.code)
+			require.Equal(t, protocol.ErrInternal, protocolError.code)
 			require.Equal(t, tt.message, protocolError.Error())
 		})
 	}
 	d.serveCtx, d.serveCancel = context.WithCancel(context.Background())
 	defer d.serveCancel()
-	_, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name}, nil)
+	_, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name}, nil)
 	var protocolError *protoErr
 	require.ErrorAs(t, err, &protocolError)
-	require.Equal(t, ports.ErrInternal, protocolError.code)
+	require.Equal(t, protocol.ErrInternal, protocolError.code)
 	require.Zero(t, factory.calls.Load())
 }
 	d.mu.Lock()
 	entry := d.inactive[record.Name]
 	d.mu.Unlock()
-	require.Equal(t, ports.SessionBroken, entry.state)
+	require.Equal(t, protocol.SessionBroken, entry.state)
 	select {
 	case <-entry.restoreDone:
 	default:
 	d.restoreCatalogue(context.Background(), mustDurableRecords(t, catalogue))
-	require.Equal(t, ports.SessionBroken, d.inactive[record.Name].state)
+	require.Equal(t, protocol.SessionBroken, d.inactive[record.Name].state)
 	require.Zero(t, repository.loads[record.Name])
 }

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

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

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

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

M internal/usecase/daemon/floating_open_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"
 )
 type contextAwareFloatingPTY struct {
 			name:           "visible session",
 			desiredVisible: true,
 			teardown: func(d *Daemon, sess *session, _ *tab) {
-				require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))
+				require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
 			},
 		},
 	}
 	}
 	killed := make(chan error, 1)
-	go func() { killed <- d.killSession(sess, ports.ReasonSessionKilled, false) }()
+	go func() { killed <- d.killSession(sess, protocol.ReasonSessionKilled, false) }()
 	select {
 	case err := <-killed:
 		require.NoError(t, err)

M internal/usecase/daemon/floating_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"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	case <-time.After(time.Second):
 		t.Fatal("floating reader did not start")
 	}
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
 	select {
 	case <-waitGroupDone(&d.sessWg):
 	case <-time.After(time.Second):

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

 	vt "github.com/bnema/vev-vt"
 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/stretchr/testify/require"
 )
 	pty := &blockingRecordingGeometryPTY{done: make(chan struct{})}
 	t.Cleanup(func() { _ = pty.Close() })
 	d := newTestDaemon(t, &recordingPTYFactory{pty: pty}, stubClock{})
-	firstHello := helloResumeCapable(ports.IntentNew, "pixels", 0)
+	firstHello := helloResumeCapable(protocol.IntentNew, "pixels", 0)
 	firstHello.PixelWidth, firstHello.PixelHeight = 800, 480
 	firstTransport := &closeTrackingTransport{}
 	sess, ac, err := d.route(firstHello, firstTransport)
 	require.NoError(t, err)
 	d.clientGone(sess, ac, firstTransport, false)
-	resumeHello := helloResumeCapable(ports.IntentResume, "pixels", ac.resumeToken)
+	resumeHello := helloResumeCapable(protocol.IntentResume, "pixels", ac.resumeToken)
 	resumeHello.PixelWidth, resumeHello.PixelHeight = 1000, 600
 	resumed, same, ok, err := d.resumeParked(resumeHello, &closeTrackingTransport{}, resumeHello.Size)
 	require.NoError(t, err)

M internal/usecase/daemon/graphics_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"
 )
 	ac.output.graphicsOutput = newGraphicsOutputState()
 	ac.output.graphicsUnsupportedWarned.Store(true)
 	d.mu.Lock()
-	d.reconfigureAttachmentOutput(sess, ac, ports.Hello{KittyDirectGraphics: false})
+	d.reconfigureAttachmentOutput(sess, ac, protocol.Hello{KittyDirectGraphics: false})
 	d.mu.Unlock()
 	require.False(t, ac.terminalCapabilities.SupportsKittyGraphics())
 	require.Nil(t, ac.output.graphicsOutput)
 	oldState.mayHaveEmitted = true
 	ac.output.graphicsOutput = oldState
 	ac.output.graphicsUnsupportedWarned.Store(true)
-	d.reconfigureAttachmentOutput(sess, ac, ports.Hello{KittyDirectGraphics: true})
+	d.reconfigureAttachmentOutput(sess, ac, protocol.Hello{KittyDirectGraphics: true})
 	d.mu.Unlock()
 	require.True(t, ac.terminalCapabilities.SupportsKittyGraphics())

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

 	"sync"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 var errHandshakeTimeout = errors.New("handshake timed out")
 	if d != nil && d.clock != nil {
 		clock = d.clock
 	}
-	timer := clock.NewTimer(ports.HandshakeTimeout)
+	timer := clock.NewTimer(protocol.HandshakeTimeout)
 	if timer == nil {
-		timer = systemClock{}.NewTimer(ports.HandshakeTimeout)
+		timer = systemClock{}.NewTimer(protocol.HandshakeTimeout)
 	}
 	stop := make(chan struct{})
 	done := make(chan struct{})
 		_ = tr.Close()
 	}
 	if ac.routeCreatedSession {
-		_ = d.killSessionIfEmpty(sess, ports.ReasonSessionKilled, ac.routeSessionPurge)
+		_ = d.killSessionIfEmpty(sess, protocol.ReasonSessionKilled, ac.routeSessionPurge)
 	}
 }

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type handshakeBlockingTransport struct {
 	handshakeDone := make(chan struct{})
 	go func() {
 		d.handleHelloWithContext(ctx, make(chan struct{}), func() {}, func() {}, tr,
-			mustHello(ports.IntentNew, "paint-cancel", domain.Size{Cols: 80, Rows: 24}))
+			mustHello(protocol.IntentNew, "paint-cancel", domain.Size{Cols: 80, Rows: 24}))
 		close(handshakeDone)
 	}()
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "handshake receive did not stop after timeout")
 	requireClosedHandshakeTransport(t, tr)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTransport := newHandshakeBlockingTransport(false)
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "resume-timeout", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "resume-timeout", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
 	resumeTransport := newHandshakeBlockingTransport(true)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(resumeTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(ports.IntentResume, sess.name, token))})
+		d.handleHello(resumeTransport, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(helloResumeCapable(protocol.IntentResume, sess.name, token))})
 		close(done)
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	<-resumeTransport.welcome
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "failed resume handshake did not finish")
 	tr := newHandshakeBlockingTransport(true)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(tr, mustHello(ports.IntentNew, "timeout-send", domain.Size{Cols: 80, Rows: 24}))
+		d.handleHello(tr, mustHello(protocol.IntentNew, "timeout-send", domain.Size{Cols: 80, Rows: 24}))
 		close(done)
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	<-tr.welcome
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "handshake send did not stop after timeout")
 	tr := newHandshakeBlockingTransport(false)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(tr, mustHello(ports.IntentAttach, "restoring", domain.Size{Cols: 80, Rows: 24}))
+		d.handleHello(tr, mustHello(protocol.IntentAttach, "restoring", domain.Size{Cols: 80, Rows: 24}))
 		close(done)
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "route restore wait did not stop after handshake timeout")
 	requireClosedHandshakeTransport(t, tr)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	d.mu.Lock()
-	d.inactive["restored"] = inactiveSession{name: "restored", cwd: "/tmp", state: ports.SessionDown}
+	d.inactive["restored"] = inactiveSession{name: "restored", cwd: "/tmp", state: protocol.SessionDown}
 	d.mu.Unlock()
 	clock := &signalClock{timers: make(chan *signalTimer, 4)}
 	tr := newHandshakeBlockingTransport(true)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(tr, mustHello(ports.IntentAttach, "restored", domain.Size{Cols: 80, Rows: 24}))
+		d.handleHello(tr, mustHello(protocol.IntentAttach, "restored", domain.Size{Cols: 80, Rows: 24}))
 		close(done)
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	<-tr.welcome
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "timed-out restored attachment cleanup did not finish")
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTransport := &closeTrackingTransport{}
-	sess, old, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "shared", Size: domain.Size{Cols: 80, Rows: 24}}, oldTransport)
+	sess, old, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "shared", Size: domain.Size{Cols: 80, Rows: 24}}, oldTransport)
 	require.NoError(t, err)
 	clock := &signalClock{timers: make(chan *signalTimer, 1)}
 	tr := newHandshakeBlockingTransport(true)
 	done := make(chan struct{})
 	go func() {
-		d.handleHello(tr, mustHello(ports.IntentAttach, "shared", domain.Size{Cols: 80, Rows: 24}))
+		d.handleHello(tr, mustHello(protocol.IntentAttach, "shared", domain.Size{Cols: 80, Rows: 24}))
 		close(done)
 	}()
 	timer := <-clock.timers
-	require.Equal(t, ports.HandshakeTimeout, timer.duration)
+	require.Equal(t, protocol.HandshakeTimeout, timer.duration)
 	<-tr.welcome
 	timer.ch <- time.Time{}
 	awaitTestCompletion(t, done, "timed-out attachment cleanup did not finish")
 	require.Len(t, d.sessions, 1)
 	require.Empty(t, d.parked)
 	d.mu.Unlock()
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 }
 func TestSuccessfulRouteOutlivesStoppedHandshakeContext(t *testing.T) {
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	ctx, cancel := context.WithCancel(context.Background())
-	sess, ac, err := d.routeWithContext(ctx, ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "lifetime", Size: domain.Size{Cols: 80, Rows: 24}}, &closeTrackingTransport{})
+	sess, ac, err := d.routeWithContext(ctx, protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "lifetime", Size: domain.Size{Cols: 80, Rows: 24}}, &closeTrackingTransport{})
 	require.NoError(t, err)
 	cancel()
 	select {
 	default:
 	}
 	require.NotNil(t, ac)
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 }

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


@@ -6,7 +6,7 @@ import (
6		"github.com/stretchr/testify/require"	6		"github.com/stretchr/testify/require"
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		)	10		)
11			11
12		func TestInactiveSessionPredicates(t *testing.T) {	12		func TestInactiveSessionPredicates(t *testing.T) {

@@ -22,12 +22,12 @@ func TestInactiveSessionPredicates(t *testing.T) {
22		canResume bool	22		canResume bool
23		restorePending bool	23		restorePending bool
24		}{	24		}{
25	-	{name: "healthy down", entry: inactiveSession{state: ports.SessionDown}, visible: true, canResume: true},	25	+	{name: "healthy down", entry: inactiveSession{state: protocol.SessionDown}, visible: true, canResume: true},
26	-	{name: "restore pending remains resumable after wait", entry: inactiveSession{state: ports.SessionDown, restoreDone: pending}, visible: true, canResume: true, restorePending: true},	26	+	{name: "restore pending remains resumable after wait", entry: inactiveSession{state: protocol.SessionDown, restoreDone: pending}, visible: true, canResume: true, restorePending: true},
27	-	{name: "settled restore", entry: inactiveSession{state: ports.SessionDown, restoreDone: settled}, visible: true, canResume: true},	27	+	{name: "settled restore", entry: inactiveSession{state: protocol.SessionDown, restoreDone: settled}, visible: true, canResume: true},
28	-	{name: "broken", entry: inactiveSession{state: ports.SessionBroken}, visible: true, broken: true},	28	+	{name: "broken", entry: inactiveSession{state: protocol.SessionBroken}, visible: true, broken: true},
29	-	{name: "degraded", entry: inactiveSession{state: ports.SessionDown, record: domain.CatalogueRecord{DegradedReason: "checkpoint unavailable"}}, visible: true, broken: true},	29	+	{name: "degraded", entry: inactiveSession{state: protocol.SessionDown, record: domain.CatalogueRecord{DegradedReason: "checkpoint unavailable"}}, visible: true, broken: true},
30	-	{name: "purging", entry: inactiveSession{state: ports.SessionDown, purging: true}},	30	+	{name: "purging", entry: inactiveSession{state: protocol.SessionDown, purging: true}},
31		}	31		}
32			32
33		for _, test := range tests {	33		for _, test := range tests {

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


@@ -884,7 +884,7 @@ func TestAltDDetachesCurrentClient(t *testing.T) {
884		f := awaitFrame(t, sends, ports.MsgDetached)	884		f := awaitFrame(t, sends, ports.MsgDetached)
885		det, err := ports.UnmarshalDetached(f.Payload)	885		det, err := ports.UnmarshalDetached(f.Payload)
886		require.NoError(t, err)	886		require.NoError(t, err)
887	-	require.Equal(t, ports.ReasonDetach, det.Reason)	887	+	require.Equal(t, protocol.ReasonDetach, det.Reason)
888		}	888		}
889			889
890		func TestRNSOpensPromptAndEnterPromotesEphemeralSession(t *testing.T) {	890		func TestRNSOpensPromptAndEnterPromotesEphemeralSession(t *testing.T) {

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


@@ -8,7 +8,7 @@ import (
8		"github.com/stretchr/testify/require"	8		"github.com/stretchr/testify/require"
9			9
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 newMoveGateRaceFixture(t testing.T) (Daemon, session, tab, pane, session, *tab, func()) {	14		func newMoveGateRaceFixture(t testing.T) (Daemon, session, tab, pane, session, *tab, func()) {

@@ -93,7 +93,7 @@ func TestMovePaneGateReservationRaceKillWinsWithoutDeadlock(t *testing.T) {
93		waitMoveRace(t, moveReserved, "move reservation")	93		waitMoveRace(t, moveReserved, "move reservation")
94			94
95		killDone := make(chan error, 1)	95		killDone := make(chan error, 1)
96	-	go func() { killDone <- d.killSession(source, ports.ReasonSessionKilled, false) }()	96	+	go func() { killDone <- d.killSession(source, protocol.ReasonSessionKilled, false) }()
97		waitMoveRace(t, killFrozen, "kill gate freeze")	97		waitMoveRace(t, killFrozen, "kill gate freeze")
98		close(releaseMoveAdmission)	98		close(releaseMoveAdmission)
99		moveErr := waitMoveRace(t, moveDone, "move abort after kill gate acquisition")	99		moveErr := waitMoveRace(t, moveDone, "move abort after kill gate acquisition")

@@ -277,7 +277,7 @@ func TestMovePaneGateReservationRaceMoveWinsWithoutDeadlock(t *testing.T) {
277		waitMoveRace(t, moveGateFrozen, "move gate freeze")	277		waitMoveRace(t, moveGateFrozen, "move gate freeze")
278			278
279		killDone := make(chan error, 1)	279		killDone := make(chan error, 1)
280	-	go func() { killDone <- d.killSession(source, ports.ReasonSessionKilled, false) }()	280	+	go func() { killDone <- d.killSession(source, protocol.ReasonSessionKilled, false) }()
281		waitMoveRace(t, killSnapshotted, "kill participant snapshot")	281		waitMoveRace(t, killSnapshotted, "kill participant snapshot")
282		close(releaseMove)	282		close(releaseMove)
283			283

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


@@ -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/stretchr/testify/require"	8		"github.com/stretchr/testify/require"
9		)	9		)
10			10

@@ -230,7 +230,7 @@ func TestDaemonShutdownDrainsMoveBeforePaneLifetimeCancellation(t *testing.T) {
230		require.NotNil(t, paneLifetime)	230		require.NotNil(t, paneLifetime)
231			231
232		shutdown := make(chan bool, 1)	232		shutdown := make(chan bool, 1)
233	-	go func() { shutdown <- d.shutdownAll(ports.ReasonServerShutdown) }()	233	+	go func() { shutdown <- d.shutdownAll(protocol.ReasonServerShutdown) }()
234		awaitDaemonMoveClosing(t, d)	234		awaitDaemonMoveClosing(t, d)
235		select {	235		select {
236		case <-paneLifetime.Done():	236		case <-paneLifetime.Done():

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


@@ -6,7 +6,7 @@ import (
6		"os"	6		"os"
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		)	10		)
11			11
12		// movePostcommitPlan is captured while the move's architecture and owner	12		// movePostcommitPlan is captured while the move's architecture and owner

@@ -148,7 +148,7 @@ func (p movePostcommitPlan) execute(d *Daemon) {
148		if err := d.cleanupAttachmentOutput(attachment.ac); err != nil {	148		if err := d.cleanupAttachmentOutput(attachment.ac); err != nil {
149		d.log.Warn("move attachment output cleanup failed", "err", err, "operation", p.operation, "source_session", p.sourceName)	149		d.log.Warn("move attachment output cleanup failed", "err", err, "operation", p.operation, "source_session", p.sourceName)
150		}	150		}
151	-	d.notifyDetachedSnapshotAsync(attachment, ports.ReasonSessionKilled)	151	+	d.notifyDetachedSnapshotAsync(attachment, protocol.ReasonSessionKilled)
152		}	152		}
153		for _, retirement := range p.retiredParked {	153		for _, retirement := range p.retiredParked {
154		if retirement.parked == nil \|\| retirement.parked.ac == nil {	154		if retirement.parked == nil \|\| retirement.parked.ac == nil {

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


@@ -4,7 +4,7 @@ import (
4		"errors"	4		"errors"
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/layout"	8		"github.com/bnema/vev/internal/usecase/layout"
9		)	9		)
10			10

@@ -70,7 +70,7 @@ func moveRejectionDescriptorByReason(reason moveRejectionReason) moveRejectionDe
70		PaletteCode: domain.NoticeInternal,	70		PaletteCode: domain.NoticeInternal,
71		PaletteSeverity: domain.NoticeError,	71		PaletteSeverity: domain.NoticeError,
72		PaletteText: "Move failed.",	72		PaletteText: "Move failed.",
73	-	CommandCode: ports.ErrNoSuchTarget,	73	+	CommandCode: protocol.ErrNoSuchTarget,
74		CommandText: "move request is invalid",	74		CommandText: "move request is invalid",
75		}	75		}
76		switch reason {	76		switch reason {

@@ -129,7 +129,7 @@ func isMoveCommandError(err error) bool {
129		return ok	129		return ok
130		}	130		}
131			131
132	-	func moveCommandFailure(err error) ports.CommandResult {	132	+	func moveCommandFailure(err error) protocol.CommandResult {
133		descriptor, ok := moveRejectionDescriptorFor(err)	133		descriptor, ok := moveRejectionDescriptorFor(err)
134		if !ok {	134		if !ok {
135		descriptor = moveRejectionDescriptorByReason(moveRejectionInvalid)	135		descriptor = moveRejectionDescriptorByReason(moveRejectionInvalid)

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


@@ -7,7 +7,7 @@ import (
7		"github.com/stretchr/testify/require"	7		"github.com/stretchr/testify/require"
8			8
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		)	12		)
13			13

@@ -89,7 +89,7 @@ func TestMoveRejectionPresentationParity(t *testing.T) {
89		require.False(t, result.OK)	89		require.False(t, result.OK)
90		require.Equal(t, descriptor.CommandCode, result.Code)	90		require.Equal(t, descriptor.CommandCode, result.Code)
91		require.Equal(t, descriptor.CommandText, result.Text)	91		require.Equal(t, descriptor.CommandText, result.Text)
92	-	require.Equal(t, ports.ErrNoSuchTarget, result.Code)	92	+	require.Equal(t, protocol.ErrNoSuchTarget, result.Code)
93		require.Equal(t, tt.commandText, result.Text)	93		require.Equal(t, tt.commandText, result.Text)
94		})	94		})
95		}	95		}

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


@@ -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		"github.com/bnema/vev/internal/usecase/layout"	10		"github.com/bnema/vev/internal/usecase/layout"
11		"github.com/bnema/vev/internal/usecase/picker"	11		"github.com/bnema/vev/internal/usecase/picker"
12		"github.com/stretchr/testify/require"	12		"github.com/stretchr/testify/require"

@@ -51,7 +51,7 @@ func TestNavigationHandoffsDropReplacedInitiatorWithoutMutation(t *testing.T) {
51		run: func(d Daemon, _ session, target session, _ attachedClient, effect *attachmentEffect) error {	51		run: func(d Daemon, _ session, target session, _ attachedClient, effect *attachmentEffect) error {
52		d.mu.Lock()	52		d.mu.Lock()
53		delete(d.sessions, target.id)	53		delete(d.sessions, target.id)
54	-	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 9, incarnation: domain.IncarnationID{2}, state: ports.SessionDown}	54	+	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 9, incarnation: domain.IncarnationID{2}, state: protocol.SessionDown}
55		d.mu.Unlock()	55		d.mu.Unlock()
56		expectedCreatedAt := int64(9)	56		expectedCreatedAt := int64(9)
57		return d.switchToTargetForAttachment(effect, picker.Target{Name: "stopped", Stopped: true, ExpectedCreatedAt: &expectedCreatedAt}, sessionHandoffGuard{}, "stopped-session")	57		return d.switchToTargetForAttachment(effect, picker.Target{Name: "stopped", Stopped: true, ExpectedCreatedAt: &expectedCreatedAt}, sessionHandoffGuard{}, "stopped-session")

@@ -149,7 +149,7 @@ func TestNavigationHandoffsDropReplacedInitiatorWithoutMutation(t *testing.T) {
149		func TestStoppedSessionHandoffDoesNotResumeAfterInitiatorReplacement(t *testing.T) {	149		func TestStoppedSessionHandoffDoesNotResumeAfterInitiatorReplacement(t *testing.T) {
150		d, source, old, _ := newManualSessionWithPTYs(t, nil)	150		d, source, old, _ := newManualSessionWithPTYs(t, nil)
151		d.mu.Lock()	151		d.mu.Lock()
152	-	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 7, incarnation: domain.IncarnationID{3}, state: ports.SessionDown}	152	+	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 7, incarnation: domain.IncarnationID{3}, state: protocol.SessionDown}
153		d.mu.Unlock()	153		d.mu.Unlock()
154			154
155		rc := d.attachCoordinator(source, nil, old, true)	155		rc := d.attachCoordinator(source, nil, old, true)

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


@@ -9,7 +9,7 @@ import (
9		"github.com/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10			10
11		"github.com/bnema/vev/internal/domain"	11		"github.com/bnema/vev/internal/domain"
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol"
13		"github.com/bnema/vev/internal/usecase/layout"	13		"github.com/bnema/vev/internal/usecase/layout"
14		)	14		)
15			15

@@ -51,7 +51,7 @@ func TestKillSessionIgnoresNilPanePTYs(t *testing.T) {
51		d.sessions[sess.id] = sess	51		d.sessions[sess.id] = sess
52			52
53		require.NotPanics(t, func() {	53		require.NotPanics(t, func() {
54	-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))	54	+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
55		})	55		})
56		require.NotContains(t, d.sessions, sess.id)	56		require.NotContains(t, d.sessions, sess.id)
57		}	57		}

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
+	"github.com/bnema/vev/internal/protocol"
 )
 // TestKillSessionServerShutdownSaturatedAppendsNotice proves that when the
 	require.Len(t, d.notices.history(), 2, "each drained notice is recorded individually")
 	tr, _ := newCapturingTransport(t)
-	sess, ac, err := d.route(ports.Hello{
+	sess, ac, err := d.route(protocol.Hello{
-		Version: ports.ProtocolVersion,
+		Version: protocol.Version,
-		Intent:  ports.IntentEphemeral,
+		Intent:  protocol.IntentEphemeral,
 		Size:    domain.Size{Cols: 80, Rows: 24},
 	}, tr)
 	require.NoError(t, err)

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

 	"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 TestReportAttachmentErrorPreservesLocalOrNilScope(t *testing.T) {
 func TestClientNoticeMapsFixedActionsAndDismissesOnlyConnectionToast(t *testing.T) {
 	d, sess, ac, _ := newNoticeFixture(t, &noticeClock{})
-	d.handleClientNotice(sess, ac, ports.ClientNotice{Action: ports.ClientNoticeClipboardFallback})
+	d.handleClientNotice(sess, ac, protocol.ClientNotice{Action: protocol.ClientNoticeClipboardFallback})
-	d.handleClientNotice(sess, ac, ports.ClientNotice{Action: ports.ClientNoticeClipboardTooLarge})
+	d.handleClientNotice(sess, ac, protocol.ClientNotice{Action: protocol.ClientNoticeClipboardTooLarge})
-	d.handleClientNotice(sess, ac, ports.ClientNotice{Action: ports.ClientNoticeLinkDegraded})
+	d.handleClientNotice(sess, ac, protocol.ClientNotice{Action: protocol.ClientNoticeLinkDegraded})
 	toasts, _ := visibleToasts(ac)
 	require.Len(t, toasts, 3)
 		{Code: domain.NoticeClipboard, Severity: domain.NoticeError, Message: "image paste failed; sent Ctrl+V", SessionID: sess.id, Count: 1},
 	}, stripNoticeTimes(toasts))
-	d.handleClientNotice(sess, ac, ports.ClientNotice{Action: ports.ClientNoticeLinkConnected})
+	d.handleClientNotice(sess, ac, protocol.ClientNotice{Action: protocol.ClientNoticeLinkConnected})
 	toasts, _ = visibleToasts(ac)
 	require.Len(t, toasts, 2)
 	for _, toast := range toasts {
 	require.True(t, ok, "attached client transport must be a MockTransport")
 	frames := []ports.Frame{
 		{Type: ports.MsgClientNotice, Payload: []byte{0xff}},
-		{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})},
+		{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
 	}
 	tr.EXPECT().Recv().RunAndReturn(func() (ports.Frame, error) {
 		frame := frames[0]

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


@@ -72,9 +72,9 @@ func TestDatagramAttachPipelinesRendererBeforeAck(t *testing.T) {
72		defer releasePTY()	72		defer releasePTY()
73		d, sess, _, _ := newManualSessionWithPTYs(t, p)	73		d, sess, _, _ := newManualSessionWithPTYs(t, p)
74		tr := newDatagramTestTransport()	74		tr := newDatagramTestTransport()
75	-	routed, ac, err := d.route(ports.Hello{	75	+	routed, ac, err := d.route(protocol.Hello{
76	-	Version: ports.ProtocolVersion,	76	+	Version: protocol.Version,
77	-	Intent: ports.IntentAttach,	77	+	Intent: protocol.IntentAttach,
78		Name: sess.name,	78		Name: sess.name,
79		Size: domain.Size{Cols: 80, Rows: 24},	79		Size: domain.Size{Cols: 80, Rows: 24},
80		MaxOutputInFlight: 8,	80		MaxOutputInFlight: 8,

@@ -136,9 +136,9 @@ func TestDatagramMultipleUnackedScrollPaintsMatchLatestFrame(t *testing.T) {
136		defer releasePTY()	136		defer releasePTY()
137		d, sess, _, _ := newManualSessionWithPTYs(t, p)	137		d, sess, _, _ := newManualSessionWithPTYs(t, p)
138		tr := newDatagramTestTransport()	138		tr := newDatagramTestTransport()
139	-	_, ac, err := d.route(ports.Hello{	139	+	_, ac, err := d.route(protocol.Hello{
140	-	Version: ports.ProtocolVersion,	140	+	Version: protocol.Version,
141	-	Intent: ports.IntentAttach,	141	+	Intent: protocol.IntentAttach,
142		Name: sess.name,	142		Name: sess.name,
143		Size: domain.Size{Cols: 80, Rows: 24},	143		Size: domain.Size{Cols: 80, Rows: 24},
144		MaxOutputInFlight: 8,	144		MaxOutputInFlight: 8,

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


@@ -229,10 +229,10 @@ func TestPaletteEntryPublishesEligibleNamedSessionResults(t *testing.T) {
229		d, current, ac, _ := newManualSessionWithPTYs(t, p)	229		d, current, ac, _ := newManualSessionWithPTYs(t, p)
230		d.sessions["active"] = &session{sessionCore: sessionCore{id: "active", name: "active", createdAt: 10}}	230		d.sessions["active"] = &session{sessionCore: sessionCore{id: "active", name: "active", createdAt: 10}}
231		d.sessions["ephemeral"] = &session{sessionCore: sessionCore{id: "ephemeral", name: "ephemeral", ephemeral: true, createdAt: 11}}	231		d.sessions["ephemeral"] = &session{sessionCore: sessionCore{id: "ephemeral", name: "ephemeral", ephemeral: true, createdAt: 11}}
232	-	d.inactive["stopped"] = inactiveSession{name: "stopped", createdAt: 12, incarnation: domain.IncarnationID{3}, state: ports.SessionDown}	232	+	d.inactive["stopped"] = inactiveSession{name: "stopped", createdAt: 12, incarnation: domain.IncarnationID{3}, state: protocol.SessionDown}
233	-	d.inactive["purging"] = inactiveSession{name: "purging", createdAt: 13, incarnation: domain.IncarnationID{4}, state: ports.SessionDown, purging: true}	233	+	d.inactive["purging"] = inactiveSession{name: "purging", createdAt: 13, incarnation: domain.IncarnationID{4}, state: protocol.SessionDown, purging: true}
234	-	d.inactive["broken"] = inactiveSession{name: "broken", createdAt: 14, incarnation: domain.IncarnationID{5}, state: ports.SessionBroken}	234	+	d.inactive["broken"] = inactiveSession{name: "broken", createdAt: 14, incarnation: domain.IncarnationID{5}, state: protocol.SessionBroken}
235	-	d.inactive["degraded"] = inactiveSession{name: "degraded", createdAt: 15, incarnation: domain.IncarnationID{6}, state: ports.SessionDown, record: domain.CatalogueRecord{DegradedReason: "checkpoint unavailable"}}	235	+	d.inactive["degraded"] = inactiveSession{name: "degraded", createdAt: 15, incarnation: domain.IncarnationID{6}, state: protocol.SessionDown, record: domain.CatalogueRecord{DegradedReason: "checkpoint unavailable"}}
236		ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1, Entries: []protocol.RecentRouteEntry{	236		ac.setRouteSnapshot(protocol.RecentRouteSnapshot{Generation: 1, Entries: []protocol.RecentRouteEntry{
237		testRouteEntry(1, 1, "purging", 4, protocol.RouteKindLocal),	237		testRouteEntry(1, 1, "purging", 4, protocol.RouteKindLocal),
238		testRouteEntry(2, 1, "broken", 5, protocol.RouteKindLocal),	238		testRouteEntry(2, 1, "broken", 5, protocol.RouteKindLocal),

@@ -322,7 +322,7 @@ func TestPaletteStoppedSessionResumeFailureKeepsPaletteAndSourceAttachment(t *te
322		p, release := newBlockingPTY(t)	322		p, release := newBlockingPTY(t)
323		defer release()	323		defer release()
324		d, current, ac, sends := newManualSessionWithPTYs(t, p)	324		d, current, ac, sends := newManualSessionWithPTYs(t, p)
325	-	stopped := inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 42, lastUsedSeq: 7, tabNames: []string{"shell", "logs"}, state: ports.SessionDown}	325	+	stopped := inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 42, lastUsedSeq: 7, tabNames: []string{"shell", "logs"}, state: protocol.SessionDown}
326		d.inactive[stopped.name] = stopped	326		d.inactive[stopped.name] = stopped
327		ptys := portsmocks.NewMockPTYFactory(t)	327		ptys := portsmocks.NewMockPTYFactory(t)
328		ptys.EXPECT().Open(mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, errors.New("open failed")).Once()	328		ptys.EXPECT().Open(mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, errors.New("open failed")).Once()

@@ -351,7 +351,7 @@ func TestPaletteSelectedStoppedSessionResumesAndSwitches(t *testing.T) {
351		defer release2()	351		defer release2()
352		d, current, ac, sends := newManualSessionWithPTYs(t, p1)	352		d, current, ac, sends := newManualSessionWithPTYs(t, p1)
353		d.ptys = newFactory(t, p2)	353		d.ptys = newFactory(t, p2)
354	-	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 42, state: ports.SessionDown}	354	+	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 42, state: protocol.SessionDown}
355			355
356		d.handleInput(current, ac, []byte("\x1b "))	356		d.handleInput(current, ac, []byte("\x1b "))
357		awaitFrame(t, sends, ports.MsgOutput)	357		awaitFrame(t, sends, ports.MsgOutput)

@@ -598,9 +598,9 @@ func TestPaletteRemoteCatalogSelectionSendsExactAttachTarget(t *testing.T) {
598		Endpoint: "user@arch", DisplayOrigin: "arch", LifecycleID: remoteLifecycle,	598		Endpoint: "user@arch", DisplayOrigin: "arch", LifecycleID: remoteLifecycle,
599		SessionName: "work", LiveTabID: "tab-work",	599		SessionName: "work", LiveTabID: "tab-work",
600		}	600		}
601	-	require.Equal(t, ports.AttachTarget{	601	+	require.Equal(t, protocol.AttachTarget{
602	-	Endpoint: "user@arch", Session: "work", Intent: ports.IntentAttach,	602	+	Endpoint: "user@arch", Session: "work", Intent: protocol.IntentAttach,
603	-	RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	603	+	RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
604		}, target)	604		}, target)
605		require.False(t, ac.overlays.paletteActive())	605		require.False(t, ac.overlays.paletteActive())
606		d.remoteCatalog.mu.Lock()	606		d.remoteCatalog.mu.Lock()

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


@@ -417,7 +417,7 @@ func (d Daemon) switchParkedRoute(effect attachmentEffect, request protocol.Pa
417			417
418		func (d *Daemon) waitForParkedTargetRestore(parent context.Context, name string) error {	418		func (d *Daemon) waitForParkedTargetRestore(parent context.Context, name string) error {
419		ctx, cancel := context.WithCancel(parent)	419		ctx, cancel := context.WithCancel(parent)
420	-	timer := d.clock.NewTimer(ports.HandshakeTimeout)	420	+	timer := d.clock.NewTimer(protocol.HandshakeTimeout)
421		stop := make(chan struct{})	421		stop := make(chan struct{})
422		go func() {	422		go func() {
423		select {	423		select {

@@ -501,7 +501,7 @@ func (d Daemon) transitionParkedRouteTarget(effect attachmentEffect, target do
501		},	501		},
502		})	502		})
503		if err != nil && created != nil {	503		if err != nil && created != nil {
504	-	_ = d.killSession(created, ports.ReasonSessionKilled, true)	504	+	_ = d.killSession(created, protocol.ReasonSessionKilled, true)
505		}	505		}
506		if err != nil {	506		if err != nil {
507		return attachmentTransitionResult{}, created, err	507		return attachmentTransitionResult{}, created, err

M internal/usecase/daemon/parked_route_test.go +1 -1


@@ -168,7 +168,7 @@ func TestParkedRouteRestoresExactStoppedTargetWithDaemonEnvironment(t *testing.T
168		lifecycle := domain.SessionLifecycleID{8}	168		lifecycle := domain.SessionLifecycleID{8}
169		d.mu.Lock()	169		d.mu.Lock()
170		d.inactive["stopped"] = inactiveSession{	170		d.inactive["stopped"] = inactiveSession{
171	-	name: "stopped", cwd: "/remote/work", incarnation: lifecycle, state: ports.SessionDown,	171	+	name: "stopped", cwd: "/remote/work", incarnation: lifecycle, state: protocol.SessionDown,
172		tabNames: []string{"alpha", "beta"},	172		tabNames: []string{"alpha", "beta"},
173		tabRecords: []domain.CatalogueTabRecord{	173		tabRecords: []domain.CatalogueTabRecord{
174		{StableID: "tab-a", Name: "alpha"},	174		{StableID: "tab-a", Name: "alpha"},

M internal/usecase/daemon/performance_benchmark_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/layout"
 	snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
 )
 	sess.mu.Lock()
 	sess.ephemeral = true
 	sess.mu.Unlock()
-	killErr := f.killSession(sess, ports.ReasonServerShutdown, false)
+	killErr := f.killSession(sess, protocol.ReasonServerShutdown, false)
 	d.stopSnapshotEncodeWorker()
 	d.serveCancel()
 	d.hardCancel()

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


@@ -923,11 +923,11 @@ func (d Daemon) sendLocalAttachTargetForAttachment(effect attachmentEffect, ta
923		// Explicit tab rows already take the direct transition path above, while	923		// Explicit tab rows already take the direct transition path above, while
924		// stopped sessions have no active target session and retain the fallback.	924		// stopped sessions have no active target session and retain the fallback.
925		samePeerEligible := guard.allowSamePeer && targetSess != nil && target.TabIndex <= 0	925		samePeerEligible := guard.allowSamePeer && targetSess != nil && target.TabIndex <= 0
926	-	payload := ports.MarshalAttachTarget(ports.AttachTarget{	926	+	payload := ports.MarshalAttachTarget(protocol.AttachTarget{
927		Session: sessionName,	927		Session: sessionName,
928	-	Intent: ports.IntentAttach,	928	+	Intent: protocol.IntentAttach,
929		ExactTarget: exactTarget,	929		ExactTarget: exactTarget,
930	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	930	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
931		SamePeer: samePeerEligible,	931		SamePeer: samePeerEligible,
932		})	932		})
933		if payload == nil \|\| exactTarget == nil {	933		if payload == nil \|\| exactTarget == nil {

@@ -982,12 +982,12 @@ func (d Daemon) sendRemoteAttachTargetForAttachment(effect attachmentEffect, t
982		if err := remoteTarget.Validate(); err != nil \|\| key.Validate() != nil \|\| target.Session != key.ID() \|\| key.Host != remoteTarget.Endpoint \|\| key.Name != remoteTarget.SessionName \|\| key.LifecycleID != remoteTarget.LifecycleID \|\| !d.remoteCatalogTargetReady(remoteTarget) {	982		if err := remoteTarget.Validate(); err != nil \|\| key.Validate() != nil \|\| target.Session != key.ID() \|\| key.Host != remoteTarget.Endpoint \|\| key.Name != remoteTarget.SessionName \|\| key.LifecycleID != remoteTarget.LifecycleID \|\| !d.remoteCatalogTargetReady(remoteTarget) {
983		return failUnavailable()	983		return failUnavailable()
984		}	984		}
985	-	handoff := ports.AttachTarget{	985	+	handoff := protocol.AttachTarget{
986		Endpoint: remoteTarget.Endpoint,	986		Endpoint: remoteTarget.Endpoint,
987		Session: remoteTarget.SessionName,	987		Session: remoteTarget.SessionName,
988	-	Intent: ports.IntentAttach,	988	+	Intent: protocol.IntentAttach,
989		RemoteTarget: &remoteTarget,	989		RemoteTarget: &remoteTarget,
990	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	990	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
991		}	991		}
992		payload := ports.MarshalAttachTarget(handoff)	992		payload := ports.MarshalAttachTarget(handoff)
993		if payload == nil {	993		if payload == nil {

@@ -1252,7 +1252,7 @@ func (d Daemon) switchToActiveTargetLocked(from session, ac *attachedClient, t
1252		// and stopped record untouched.	1252		// and stopped record untouched.
1253		func (d Daemon) resumeStoppedAndSwitchLocked(from session, ac attachedClient, target picker.Target, stopped inactiveSession, sourceEffect attachmentEffect, guard sessionHandoffGuard, action string) (*session, attachmentTransitionResult, bool, error) {	1253		func (d Daemon) resumeStoppedAndSwitchLocked(from session, ac attachedClient, target picker.Target, stopped inactiveSession, sourceEffect attachmentEffect, guard sessionHandoffGuard, action string) (*session, attachmentTransitionResult, bool, error) {
1254		if stopped.broken() {	1254		if stopped.broken() {
1255	-	return nil, attachmentTransitionResult{}, false, &protoErr{ports.ErrInternal, "session durable state is broken: " + target.Name}	1255	+	return nil, attachmentTransitionResult{}, false, &protoErr{protocol.ErrInternal, "session durable state is broken: " + target.Name}
1256		}	1256		}
1257		if !stopped.canResume() {	1257		if !stopped.canResume() {
1258		return nil, attachmentTransitionResult{}, false, errAttachmentTransition	1258		return nil, attachmentTransitionResult{}, false, errAttachmentTransition

@@ -1283,7 +1283,7 @@ func (d Daemon) resumeStoppedAndSwitchLocked(from session, ac *attachedClient,
1283		if err != nil {	1283		if err != nil {
1284		if targetSess != nil {	1284		if targetSess != nil {
1285		d.mu.Unlock()	1285		d.mu.Unlock()
1286	-	_ = d.killSession(targetSess, ports.ReasonSessionKilled, true)	1286	+	_ = d.killSession(targetSess, protocol.ReasonSessionKilled, true)
1287		d.mu.Lock()	1287		d.mu.Lock()
1288		}	1288		}
1289		return targetSess, attachmentTransitionResult{}, false, err	1289		return targetSess, attachmentTransitionResult{}, false, err

@@ -1390,7 +1390,7 @@ func (d Daemon) killPickerTargetForAttachment(target picker.Target, effect att
1390		if targetSess == nil {	1390		if targetSess == nil {
1391		return nil	1391		return nil
1392		}	1392		}
1393	-	return d.killSessionForAttachment(targetSess, ports.ReasonSessionKilled, true, effect, "picker-delete")	1393	+	return d.killSessionForAttachment(targetSess, protocol.ReasonSessionKilled, true, effect, "picker-delete")
1394		}	1394		}
1395			1395
1396		func (d *Daemon) killPickerTarget(target picker.Target) error {	1396		func (d *Daemon) killPickerTarget(target picker.Target) error {

@@ -1405,7 +1405,7 @@ func (d *Daemon) killPickerTarget(target picker.Target) error {
1405		targetSess := d.sessions[target.Session]	1405		targetSess := d.sessions[target.Session]
1406		d.mu.Unlock()	1406		d.mu.Unlock()
1407		if targetSess != nil {	1407		if targetSess != nil {
1408	-	return d.killSession(targetSess, ports.ReasonSessionKilled, true)	1408	+	return d.killSession(targetSess, protocol.ReasonSessionKilled, true)
1409		}	1409		}
1410		return nil	1410		return nil
1411		}	1411		}

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


@@ -734,7 +734,7 @@ func TestRestoreCancellationTransitionsBeforePickerCompletion(t *testing.T) {
734		d.mu.Lock()	734		d.mu.Lock()
735		entry := d.inactive[record.Name]	735		entry := d.inactive[record.Name]
736		d.mu.Unlock()	736		d.mu.Unlock()
737	-	require.Equal(t, ports.SessionBroken, entry.state)	737	+	require.Equal(t, protocol.SessionBroken, entry.state)
738		require.Equal(t, "restore interrupted", entry.record.DegradedReason)	738		require.Equal(t, "restore interrupted", entry.record.DegradedReason)
739		select {	739		select {
740		case <-entry.restoreDone:	740		case <-entry.restoreDone:

@@ -747,10 +747,10 @@ func TestPickerRejectsCatalogueTargetsWithoutFreshRuntime(t *testing.T) {
747		tests := []struct {	747		tests := []struct {
748		name string	748		name string
749		broken bool	749		broken bool
750	-	runtimeState ports.SessionState	750	+	runtimeState protocol.SessionState
751		}{	751		}{
752	-	{name: "broken", broken: true, runtimeState: ports.SessionBroken},	752	+	{name: "broken", broken: true, runtimeState: protocol.SessionBroken},
753	-	{name: "healthy without restored runtime", runtimeState: ports.SessionDown},	753	+	{name: "healthy without restored runtime", runtimeState: protocol.SessionDown},
754		}	754		}
755			755
756		for _, tt := range tests {	756		for _, tt := range tests {

@@ -783,7 +783,7 @@ func TestPickerRejectsCatalogueTargetsWithoutFreshRuntime(t *testing.T) {
783		require.Equal(t, domain.NoticeSessionUnavailable, userError.Code)	783		require.Equal(t, domain.NoticeSessionUnavailable, userError.Code)
784		var protocolError *protoErr	784		var protocolError *protoErr
785		require.ErrorAs(t, err, &protocolError)	785		require.ErrorAs(t, err, &protocolError)
786	-	require.Equal(t, ports.ErrInternal, protocolError.code)	786	+	require.Equal(t, protocol.ErrInternal, protocolError.code)
787		require.Zero(t, factory.calls.Load(), "unsafe target must not open a PTY")	787		require.Zero(t, factory.calls.Load(), "unsafe target must not open a PTY")
788		require.Same(t, from, ac.currentSession())	788		require.Same(t, from, ac.currentSession())
789			789

@@ -809,7 +809,7 @@ func TestPickerResumesStoppedSessionWithPersistedTabNames(t *testing.T) {
809		defer release3()	809		defer release3()
810		d, from, ac, sends := newManualSessionWithPTYs(t, p1)	810		d, from, ac, sends := newManualSessionWithPTYs(t, p1)
811		d.ptys = newFactorySeq(t, p2, p3)	811		d.ptys = newFactorySeq(t, p2, p3)
812	-	d.inactive["work"] = inactiveSession{name: "work", cwd: "/tmp/work", createdAt: 7, tabNames: []string{"shell", "logs"}, record: domain.CatalogueRecord{Name: "work"}, state: ports.SessionDown}	812	+	d.inactive["work"] = inactiveSession{name: "work", cwd: "/tmp/work", createdAt: 7, tabNames: []string{"shell", "logs"}, record: domain.CatalogueRecord{Name: "work"}, state: protocol.SessionDown}
813			813
814		d.resumeStoppedAndSwitch(from, ac, picker.Target{Name: "work", Stopped: true})	814		d.resumeStoppedAndSwitch(from, ac, picker.Target{Name: "work", Stopped: true})
815		awaitFrame(t, sends, ports.MsgOutput)	815		awaitFrame(t, sends, ports.MsgOutput)

@@ -1406,11 +1406,11 @@ func TestResumeStoppedAndSwitchInheritsTerminalEnv(t *testing.T) {
1406		return got.Size != normalSize && got.Size.Valid()	1406		return got.Size != normalSize && got.Size.Valid()
1407		})).Return(floating, nil).Once()	1407		})).Return(floating, nil).Once()
1408		d := newTestDaemon(t, f, stubClock{})	1408		d := newTestDaemon(t, f, stubClock{})
1409	-	d.inactive["old"] = inactiveSession{name: "old", cwd: t.TempDir(), createdAt: 1, state: ports.SessionDown}	1409	+	d.inactive["old"] = inactiveSession{name: "old", cwd: t.TempDir(), createdAt: 1, state: protocol.SessionDown}
1410		tr := portsmocks.NewMockTransport(t)	1410		tr := portsmocks.NewMockTransport(t)
1411		tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()	1411		tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
1412		tr.EXPECT().Close().Return(nil).Maybe()	1412		tr.EXPECT().Close().Return(nil).Maybe()
1413	-	sess, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)	1413	+	sess, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)
1414		require.NoError(t, err)	1414		require.NoError(t, err)
1415		d.resumeStoppedAndSwitch(sess, ac, picker.Target{Name: "old", Stopped: true})	1415		d.resumeStoppedAndSwitch(sess, ac, picker.Target{Name: "old", Stopped: true})
1416		got := ac.currentSession()	1416		got := ac.currentSession()

@@ -1428,7 +1428,7 @@ func TestResumeStoppedAndSwitchInheritsTerminalEnv(t *testing.T) {
1428		defer tb.mu.Unlock()	1428		defer tb.mu.Unlock()
1429		return tb.floating.pane != nil && tb.floating.pane.pty == floating	1429		return tb.floating.pane != nil && tb.floating.pane.pty == floating
1430		}, time.Second, 5*time.Millisecond)	1430		}, time.Second, 5*time.Millisecond)
1431	-	_ = d.killSession(got, ports.ReasonSessionKilled, false)	1431	+	_ = d.killSession(got, protocol.ReasonSessionKilled, false)
1432		release1()	1432		release1()
1433		release2()	1433		release2()
1434		d.sessWg.Wait()	1434		d.sessWg.Wait()

@@ -1448,7 +1448,7 @@ func TestPickerEnterOnStoppedSessionRestoreFailureSurfacesNoticeAndStaysPut(t *t
1448		p, release := newBlockingPTY(t)	1448		p, release := newBlockingPTY(t)
1449		defer release()	1449		defer release()
1450		d, from, ac, sends := newManualSessionWithPTYs(t, p)	1450		d, from, ac, sends := newManualSessionWithPTYs(t, p)
1451	-	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp/stopped", createdAt: 7, state: ports.SessionDown}	1451	+	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp/stopped", createdAt: 7, state: protocol.SessionDown}
1452		cause := errors.New("open failed")	1452		cause := errors.New("open failed")
1453		ptys := portsmocks.NewMockPTYFactory(t)	1453		ptys := portsmocks.NewMockPTYFactory(t)
1454		ptys.EXPECT().Open(mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, cause).Once()	1454		ptys.EXPECT().Open(mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, cause).Once()

M internal/usecase/daemon/remote_attach.go +19 -19


@@ -13,24 +13,24 @@ import (
13		// It is deliberately separate from legacy name routing: a lifecycle mismatch,	13		// It is deliberately separate from legacy name routing: a lifecycle mismatch,
14		// missing tab, broken record, or stopped-record race is a no-such-target error,	14		// missing tab, broken record, or stopped-record race is a no-such-target error,
15		// never an invitation to attach a same-name replacement.	15		// never an invitation to attach a same-name replacement.
16	-	func (d Daemon) routeRemoteTargetWithContext(ctx context.Context, h ports.Hello, tr ports.Transport) (session, *attachedClient, error) {	16	+	func (d Daemon) routeRemoteTargetWithContext(ctx context.Context, h protocol.Hello, tr ports.Transport) (session, *attachedClient, error) {
17		if h.RemoteTarget == nil {	17		if h.RemoteTarget == nil {
18		return nil, nil, errors.New("daemon: missing remote target")	18		return nil, nil, errors.New("daemon: missing remote target")
19		}	19		}
20		target := *h.RemoteTarget	20		target := *h.RemoteTarget
21		if err := target.Validate(); err != nil {	21		if err := target.Validate(); err != nil {
22	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "invalid remote target"}	22	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "invalid remote target"}
23		}	23		}
24	-	if h.EnvironmentPolicy != ports.EnvironmentPolicyDaemonOwned {	24	+	if h.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
25	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote target requires daemon-owned environment"}	25	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote target requires daemon-owned environment"}
26		}	26		}
27	-	if h.Intent != ports.IntentAttach && h.Intent != ports.IntentResume {	27	+	if h.Intent != protocol.IntentAttach && h.Intent != protocol.IntentResume {
28	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote target requires attach or resume"}	28	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote target requires attach or resume"}
29		}	29		}
30		if err := d.waitForTargetRestore(ctx, target.SessionName); err != nil {	30		if err := d.waitForTargetRestore(ctx, target.SessionName); err != nil {
31		var protocolErr *protoErr	31		var protocolErr *protoErr
32	-	if errors.As(err, &protocolErr) && protocolErr.code == ports.ErrInternal {	32	+	if errors.As(err, &protocolErr) && protocolErr.code == protocol.ErrInternal {
33	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote session is unavailable"}	33	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote session is unavailable"}
34		}	34		}
35		return nil, nil, remoteTargetError(err)	35		return nil, nil, remoteTargetError(err)
36		}	36		}

@@ -38,20 +38,20 @@ func (d *Daemon) routeRemoteTargetWithContext(ctx context.Context, h ports.Hello
38		d.mu.Lock()	38		d.mu.Lock()
39		if d.closing {	39		if d.closing {
40		d.mu.Unlock()	40		d.mu.Unlock()
41	-	return nil, nil, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}	41	+	return nil, nil, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
42		}	42		}
43		if live := d.findByNameLocked(target.SessionName); live != nil {	43		if live := d.findByNameLocked(target.SessionName); live != nil {
44		if live.incarnation != target.LifecycleID {	44		if live.incarnation != target.LifecycleID {
45		d.mu.Unlock()	45		d.mu.Unlock()
46	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote session lifecycle has changed"}	46	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote session lifecycle has changed"}
47		}	47		}
48		if target.Stopped && target.LiveTabID != "" {	48		if target.Stopped && target.LiveTabID != "" {
49		d.mu.Unlock()	49		d.mu.Unlock()
50	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "stopped target has a live tab selector"}	50	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "stopped target has a live tab selector"}
51		}	51		}
52		if _, ok := remoteTargetTabIndexLocked(live, target); !ok {	52		if _, ok := remoteTargetTabIndexLocked(live, target); !ok {
53		d.mu.Unlock()	53		d.mu.Unlock()
54	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote tab no longer exists"}	54	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote tab no longer exists"}
55		}	55		}
56		ac, err := d.finishRouteAttach(live, tr, h.Size, h, false, false)	56		ac, err := d.finishRouteAttach(live, tr, h.Size, h, false, false)
57		return live, ac, err	57		return live, ac, err

@@ -59,20 +59,20 @@ func (d *Daemon) routeRemoteTargetWithContext(ctx context.Context, h ports.Hello
59			59
60		if !target.Stopped {	60		if !target.Stopped {
61		d.mu.Unlock()	61		d.mu.Unlock()
62	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "live remote target has no active runtime"}	62	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "live remote target has no active runtime"}
63		}	63		}
64		inactive, ok := d.inactive[target.SessionName]	64		inactive, ok := d.inactive[target.SessionName]
65		if !ok \|\| inactive.incarnation != target.LifecycleID {	65		if !ok \|\| inactive.incarnation != target.LifecycleID {
66		d.mu.Unlock()	66		d.mu.Unlock()
67	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote session lifecycle no longer exists"}	67	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote session lifecycle no longer exists"}
68		}	68		}
69		if !inactive.canResume() {	69		if !inactive.canResume() {
70		d.mu.Unlock()	70		d.mu.Unlock()
71	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote session is unavailable"}	71	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote session is unavailable"}
72		}	72		}
73		if _, ok := remoteTargetTabIndexInactive(inactive, target); !ok {	73		if _, ok := remoteTargetTabIndexInactive(inactive, target); !ok {
74		d.mu.Unlock()	74		d.mu.Unlock()
75	-	return nil, nil, &protoErr{ports.ErrNoSuchTarget, "remote stopped tab no longer exists"}	75	+	return nil, nil, &protoErr{protocol.ErrNoSuchTarget, "remote stopped tab no longer exists"}
76		}	76		}
77			77
78		// Picker handoffs use the daemon's own environment and persisted CWD. The	78		// Picker handoffs use the daemon's own environment and persisted CWD. The

@@ -156,10 +156,10 @@ func (d Daemon) sendCommittedRouteIdentityForAttachment(effect attachmentEffec
156		return effect.sendControl(ports.Frame{Type: ports.MsgCommittedRouteIdentity, Payload: payload})	156		return effect.sendControl(ports.Frame{Type: ports.MsgCommittedRouteIdentity, Payload: payload})
157		}	157		}
158			158
159	-	func (d Daemon) finishRouteAttach(sess session, tr ports.Transport, sz domain.Size, h ports.Hello, routeCreated, purge bool) (*attachedClient, error) {	159	+	func (d Daemon) finishRouteAttach(sess session, tr ports.Transport, sz domain.Size, h protocol.Hello, routeCreated, purge bool) (*attachedClient, error) {
160		ac, err := d.finishAttach(sess, tr, sz, h)	160		ac, err := d.finishAttach(sess, tr, sz, h)
161		if err != nil && routeCreated {	161		if err != nil && routeCreated {
162	-	if cleanupErr := d.killSessionIfEmpty(sess, ports.ReasonSessionKilled, purge); cleanupErr != nil {	162	+	if cleanupErr := d.killSessionIfEmpty(sess, protocol.ReasonSessionKilled, purge); cleanupErr != nil {
163		err = errors.Join(err, cleanupErr)	163		err = errors.Join(err, cleanupErr)
164		}	164		}
165		return nil, err	165		return nil, err

@@ -196,7 +196,7 @@ func remoteTargetError(err error) error {
196		if errors.Is(err, context.Canceled) \|\| errors.Is(err, context.DeadlineExceeded) {	196		if errors.Is(err, context.Canceled) \|\| errors.Is(err, context.DeadlineExceeded) {
197		return err	197		return err
198		}	198		}
199	-	return &protoErr{ports.ErrNoSuchTarget, "remote target is unavailable"}	199	+	return &protoErr{protocol.ErrNoSuchTarget, "remote target is unavailable"}
200		}	200		}
201			201
202		func stoppedTabMetadata(stopped inactiveSession) []domain.TabSelectorTab {	202		func stoppedTabMetadata(stopped inactiveSession) []domain.TabSelectorTab {

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


@@ -33,7 +33,7 @@ func TestLocalPickerOfferCarriesExactLifecycle(t *testing.T) {
33		got, err := ports.UnmarshalAttachTarget(frame.Payload)	33		got, err := ports.UnmarshalAttachTarget(frame.Payload)
34		require.NoError(t, err)	34		require.NoError(t, err)
35		require.Empty(t, got.Endpoint)	35		require.Empty(t, got.Endpoint)
36	-	require.Equal(t, ports.IntentAttach, got.Intent)	36	+	require.Equal(t, protocol.IntentAttach, got.Intent)
37		require.True(t, got.SamePeer)	37		require.True(t, got.SamePeer)
38		require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: target.name}, got.ExactTarget)	38		require.Equal(t, &protocol.ExactSessionTarget{LifecycleID: target.incarnation, SessionName: target.name}, got.ExactTarget)
39		require.Same(t, source, ac.currentAttachmentSession(), "the source remains attached until the client confirms the switch")	39		require.Same(t, source, ac.currentAttachmentSession(), "the source remains attached until the client confirms the switch")

@@ -44,7 +44,7 @@ func TestStoppedLocalPickerHandoffWaitsForClientClose(t *testing.T) {
44		source, ac, sends := addRemoteRefreshPickerOwner(t, d, "source")	44		source, ac, sends := addRemoteRefreshPickerOwner(t, d, "source")
45		lifecycle := remoteLifecycleForTest()	45		lifecycle := remoteLifecycleForTest()
46		d.inactive["stopped"] = inactiveSession{	46		d.inactive["stopped"] = inactiveSession{
47	-	name: "stopped", state: ports.SessionDown, incarnation: lifecycle,	47	+	name: "stopped", state: protocol.SessionDown, incarnation: lifecycle,
48		}	48		}
49		graphics := newGraphicsOutputState()	49		graphics := newGraphicsOutputState()
50		graphics.assets["asset"] = graphicsOutputAsset{id: graphics.namespaceBase}	50		graphics.assets["asset"] = graphicsOutputAsset{id: graphics.namespaceBase}

@@ -97,7 +97,7 @@ func TestRemotePickerRichHandoffCarriesLifecycleTabAndPolicy(t *testing.T) {
97		require.NoError(t, err)	97		require.NoError(t, err)
98		require.NotNil(t, got.RemoteTarget)	98		require.NotNil(t, got.RemoteTarget)
99		require.Equal(t, remoteTarget, *got.RemoteTarget)	99		require.Equal(t, remoteTarget, *got.RemoteTarget)
100	-	require.Equal(t, ports.EnvironmentPolicyDaemonOwned, got.EnvironmentPolicy)	100	+	require.Equal(t, protocol.EnvironmentPolicyDaemonOwned, got.EnvironmentPolicy)
101		}	101		}
102			102
103		func TestRemotePickerRichHandoffRejectsMismatchedRouteKey(t *testing.T) {	103		func TestRemotePickerRichHandoffRejectsMismatchedRouteKey(t *testing.T) {

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


@@ -458,7 +458,7 @@ func requireNoRemoteLockViolations(t testing.T, catalog channelRemoteCatalog,
458			458
459		func remoteCatalogForTest(sessions ...ports.RemoteCatalogSession) ports.RemoteCatalog {	459		func remoteCatalogForTest(sessions ...ports.RemoteCatalogSession) ports.RemoteCatalog {
460		return ports.RemoteCatalog{	460		return ports.RemoteCatalog{
461	-	ProtocolVersion: ports.ProtocolVersion,	461	+	ProtocolVersion: protocol.Version,
462		SchemaVersion: ports.RemoteCatalogSchemaVersion,	462		SchemaVersion: ports.RemoteCatalogSchemaVersion,
463		Sessions: append([]ports.RemoteCatalogSession{}, sessions...),	463		Sessions: append([]ports.RemoteCatalogSession{}, sessions...),
464		}	464		}

@@ -648,7 +648,7 @@ func TestRemoteRefreshValidationSentinelsRemainMalformed(t *testing.T) {
648		hosts := &remoteRefreshHostStore{hosts: []string{"arch"}}	648		hosts := &remoteRefreshHostStore{hosts: []string{"arch"}}
649		d, _, _ := newRemoteRefreshDaemon(t, hosts, time.Unix(400, 0))	649		d, _, _ := newRemoteRefreshDaemon(t, hosts, time.Unix(400, 0))
650		d.remoteCatalog.refresh = 1	650		d.remoteCatalog.refresh = 1
651	-	catalog := ports.RemoteCatalog{ProtocolVersion: ports.ProtocolVersion, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{test.session}}	651	+	catalog := ports.RemoteCatalog{ProtocolVersion: protocol.Version, SchemaVersion: ports.RemoteCatalogSchemaVersion, Sessions: []ports.RemoteCatalogSession{test.session}}
652		require.False(t, d.applyRemoteRefreshResult(1, "arch", catalog, nil))	652		require.False(t, d.applyRemoteRefreshResult(1, "arch", catalog, nil))
653		d.remoteCatalog.mu.Lock()	653		d.remoteCatalog.mu.Lock()
654		require.Equal(t, remoteHostMalformed, d.remoteCatalog.status["arch"])	654		require.Equal(t, remoteHostMalformed, d.remoteCatalog.status["arch"])

@@ -666,7 +666,7 @@ func TestRemoteRefreshVersionMismatchPreservesStaleRows(t *testing.T) {
666		d.remoteCatalog.refresh = 3	666		d.remoteCatalog.refresh = 3
667		d.remoteCatalog.mu.Unlock()	667		d.remoteCatalog.mu.Unlock()
668			668
669	-	require.False(t, d.applyRemoteRefreshResult(3, "arch", ports.RemoteCatalog{}, &ports.RemoteCatalogVersionMismatchError{Got: 19, Want: ports.ProtocolVersion}))	669	+	require.False(t, d.applyRemoteRefreshResult(3, "arch", ports.RemoteCatalog{}, &ports.RemoteCatalogVersionMismatchError{Got: 19, Want: protocol.Version}))
670		d.remoteCatalog.mu.Lock()	670		d.remoteCatalog.mu.Lock()
671		require.Equal(t, old, d.remoteCatalog.cache["arch"])	671		require.Equal(t, old, d.remoteCatalog.cache["arch"])
672		require.Equal(t, remoteHostVersionMismatch, d.remoteCatalog.status["arch"])	672		require.Equal(t, remoteHostVersionMismatch, d.remoteCatalog.status["arch"])

@@ -699,7 +699,7 @@ func TestRemotePickerHandoffSendsTargetAndLeavesNoShadowSession(t *testing.T) {
699		require.Equal(t, ports.MsgAttachTarget, frame.Type)	699		require.Equal(t, ports.MsgAttachTarget, frame.Type)
700		got, err := ports.UnmarshalAttachTarget(frame.Payload)	700		got, err := ports.UnmarshalAttachTarget(frame.Payload)
701		require.NoError(t, err)	701		require.NoError(t, err)
702	-	require.Equal(t, ports.AttachTarget{Endpoint: "arch", Session: "work", Intent: ports.IntentAttach, RemoteTarget: &remoteTarget, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}, got)	702	+	require.Equal(t, protocol.AttachTarget{Endpoint: "arch", Session: "work", Intent: protocol.IntentAttach, RemoteTarget: &remoteTarget, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}, got)
703		require.Nil(t, ac.currentAttachmentSession())	703		require.Nil(t, ac.currentAttachmentSession())
704		d.mu.Lock()	704		d.mu.Lock()
705		require.NotContains(t, d.sessions, key.ID(), "remote picker handoff must not create a local session shadow")	705		require.NotContains(t, d.sessions, key.ID(), "remote picker handoff must not create a local session shadow")

@@ -759,16 +759,16 @@ func TestRemotePickerSelectsStoppedRemoteTabAndRestoresIt(t *testing.T) {
759		remote := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})	759		remote := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})
760		remote.mu.Lock()	760		remote.mu.Lock()
761		remote.inactive["work"] = inactiveSession{	761		remote.inactive["work"] = inactiveSession{
762	-	name: "work", cwd: "/remote/work", incarnation: lifecycle, state: ports.SessionDown,	762	+	name: "work", cwd: "/remote/work", incarnation: lifecycle, state: protocol.SessionDown,
763		tabNames: []string{"alpha", "beta"},	763		tabNames: []string{"alpha", "beta"},
764		tabRecords: []domain.CatalogueTabRecord{{StableID: "tab-a", Name: "alpha"}, {StableID: "tab-b", Name: "beta"}},	764		tabRecords: []domain.CatalogueTabRecord{{StableID: "tab-a", Name: "alpha"}, {StableID: "tab-b", Name: "beta"}},
765		}	765		}
766		remote.mu.Unlock()	766		remote.mu.Unlock()
767		transport, _ := newCapturingTransport(t)	767		transport, _ := newCapturingTransport(t)
768	-	restored, attachment, err := remote.routeWithContext(context.Background(), ports.Hello{	768	+	restored, attachment, err := remote.routeWithContext(context.Background(), protocol.Hello{
769	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: handoff.Session,	769	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: handoff.Session,
770		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: handoff.RemoteTarget,	770		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: handoff.RemoteTarget,
771	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	771	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
772		}, transport)	772		}, transport)
773		require.NoError(t, err)	773		require.NoError(t, err)
774		t.Cleanup(func() { remote.clientGone(restored, attachment, transport, false) })	774		t.Cleanup(func() { remote.clientGone(restored, attachment, transport, false) })

@@ -825,13 +825,13 @@ func TestRemotePickerResurrectsStoppedRemoteSessionWithoutTabMetadata(t *testing
825			825
826		remote := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})	826		remote := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})
827		remote.mu.Lock()	827		remote.mu.Lock()
828	-	remote.inactive["work"] = inactiveSession{name: "work", cwd: "/remote/work", incarnation: lifecycle, state: ports.SessionDown}	828	+	remote.inactive["work"] = inactiveSession{name: "work", cwd: "/remote/work", incarnation: lifecycle, state: protocol.SessionDown}
829		remote.mu.Unlock()	829		remote.mu.Unlock()
830		transport, _ := newCapturingTransport(t)	830		transport, _ := newCapturingTransport(t)
831	-	restored, attachment, err := remote.routeWithContext(context.Background(), ports.Hello{	831	+	restored, attachment, err := remote.routeWithContext(context.Background(), protocol.Hello{
832	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: handoff.Session,	832	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: handoff.Session,
833		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: handoff.RemoteTarget,	833		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: handoff.RemoteTarget,
834	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	834	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
835		}, transport)	835		}, transport)
836		require.NoError(t, err)	836		require.NoError(t, err)
837		t.Cleanup(func() { remote.clientGone(restored, attachment, transport, false) })	837		t.Cleanup(func() { remote.clientGone(restored, attachment, transport, false) })

@@ -962,7 +962,7 @@ func TestRemoteRefreshUpdatesAllOpenPickersPreservingSelection(t *testing.T) {
962		d.remoteCatalog.mu.Unlock()	962		d.remoteCatalog.mu.Unlock()
963			963
964		require.True(t, d.applyRemoteRefreshResult(4, "arch", ports.RemoteCatalog{	964		require.True(t, d.applyRemoteRefreshResult(4, "arch", ports.RemoteCatalog{
965	-	ProtocolVersion: ports.ProtocolVersion,	965	+	ProtocolVersion: protocol.Version,
966		SchemaVersion: ports.RemoteCatalogSchemaVersion,	966		SchemaVersion: ports.RemoteCatalogSchemaVersion,
967		Sessions: []ports.RemoteCatalogSession{{	967		Sessions: []ports.RemoteCatalogSession{{
968		LifecycleID: remoteLifecycleForTest(), Name: "work", State: "up",	968		LifecycleID: remoteLifecycleForTest(), Name: "work", State: "up",

@@ -1117,7 +1117,7 @@ func TestParkedPickerResumePreservesGeneration(t *testing.T) {
1117		d.clientGone(sess, ac, ac.transport(), false)	1117		d.clientGone(sess, ac, ac.transport(), false)
1118		token := ac.resumeToken	1118		token := ac.resumeToken
1119		tr := &closeTrackingTransport{}	1119		tr := &closeTrackingTransport{}
1120	-	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, sess.name, token), tr, domain.Size{Cols: 80, Rows: 24})	1120	+	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, sess.name, token), tr, domain.Size{Cols: 80, Rows: 24})
1121		require.NoError(t, err)	1121		require.NoError(t, err)
1122		require.True(t, ok)	1122		require.True(t, ok)
1123		require.Same(t, sess, resumedSess)	1123		require.Same(t, sess, resumedSess)

M internal/usecase/daemon/remote_route_test.go +27 -26

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 func TestMixedAttachmentCapabilitiesKeepGraphicsAttachmentLocal(t *testing.T) {
 	sess := addControlSession(d, "work", "tab-1", "pane-1")
 	sess.ephemeral = false
 	kittyTransport, _ := newCapturingTransport(t)
-	_, kitty, err := d.route(ports.Hello{
+	_, kitty, err := d.route(protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
 		ClientID: [16]byte{1}, KittyDirectGraphics: true,
 	}, kittyTransport)
 	require.NoError(t, err)
 	pane.mu.Unlock()
 	textTransport, _ := newCapturingTransport(t)
-	_, text, err := d.route(ports.Hello{
+	_, text, err := d.route(protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
 		ClientID: [16]byte{2},
 	}, textTransport)
 	require.NoError(t, err)
 	sess := addControlSession(d, "work", "tab-1", "pane-1")
 	sess.ephemeral = false
 	tr, _ := newCapturingTransport(t)
-	_, ac, err := d.routeWithContext(context.Background(), ports.Hello{
+	_, ac, err := d.routeWithContext(context.Background(), protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
 		Env: []string{"TERM=xterm-kitty", "KITTY_WINDOW_ID=1"}, Remote: true,
 	}, tr)
 	require.NoError(t, err)
 	d := newTestDaemon(t, nil, stubClock{})
 	sess := addControlSession(d, "work", "tab-1", "pane-1")
 	sess.ephemeral = false
-	local := ports.Hello{
+	local := protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
 		ClientID: [16]byte{1, 2, 3, 4}, Env: []string{"TERM=xterm-kitty", "KITTY_WINDOW_ID=1"}, KittyDirectGraphics: true,
 	}
 	oldTransport, _ := newCapturingTransport(t)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
-	remote := helloResumeCapable(ports.IntentResume, "work", token)
+	remote := helloResumeCapable(protocol.IntentResume, "work", token)
 	remote.Remote = true
 	remote.KittyDirectGraphics = true
 	replacement, _ := newCapturingTransport(t)
 	sess.incarnation = remoteLifecycleForTest()
 	tr, _ := newCapturingTransport(t)
 	target := domain.RemoteSessionTarget{Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation, SessionName: "work", LiveTabID: "tab-1"}
-	hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}
+	hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}
 	_, ac, err := d.routeWithContext(context.Background(), hello, tr)
 	require.NoError(t, err)
 	require.NotNil(t, ac)
 	sess, err := createSessionForTest(d, "work", false, "/tmp/work", defaultSize, terminalEnv{}, d.baseEnv)
 	require.NoError(t, err)
 	target := domain.RemoteSessionTarget{LifecycleID: sess.incarnation, SessionName: "work", LiveTabID: "missing-tab"}
-	hello := ports.Hello{
+	hello := protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
-		RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}
 	// The caller must hold d.mu on entry; finishRouteAttach releases it on
 	// both success and error paths before returning.
 	_, err = d.finishRouteAttach(sess, &closeTrackingTransport{}, defaultSize, hello, true, true)
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	d.mu.Lock()
 	_, retained := d.sessions[sess.id]
 	d.mu.Unlock()
 	missing := domain.RemoteSessionTarget{LifecycleID: sess.incarnation, SessionName: "work", LiveTabID: "missing-tab"}
 	d.mu.Lock()
-	_, err = d.finishRouteAttach(sess, &closeTrackingTransport{}, defaultSize, ports.Hello{
+	_, err = d.finishRouteAttach(sess, &closeTrackingTransport{}, defaultSize, protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
-		RemoteTarget: &missing, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		RemoteTarget: &missing, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}, true, true)
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	require.Same(t, sess, winner().currentAttachmentSession())
 	d.mu.Lock()
 	require.Same(t, sess, d.sessions[sess.id])
 	require.NoError(t, err)
 	initialTransport, _ := newCapturingTransport(t)
 	target := domain.RemoteSessionTarget{Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: sess.incarnation, SessionName: "work", LiveTabID: domain.TabStableID(sess.tabs[0].stableID)}
-	_, initial, err := d.routeWithContext(context.Background(), ports.Hello{
+	_, initial, err := d.routeWithContext(context.Background(), protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: defaultSize,
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: defaultSize,
-		RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}, initialTransport)
 	require.NoError(t, err)
 	initial.routeCreatedSession = true
 			SessionName: sess.name, LiveTabID: domain.TabStableID(sess.tabs[0].stableID),
 		}
 		var err error
-		_, winner, err = d.routeWithContext(context.Background(), ports.Hello{
+		_, winner, err = d.routeWithContext(context.Background(), protocol.Hello{
-			Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: sess.name, Size: defaultSize,
+			Version: protocol.Version, Intent: protocol.IntentAttach, Name: sess.name, Size: defaultSize,
-			RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+			RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}, winnerTransport)
 		require.NoError(t, err)
 	}
 	var old domain.SessionLifecycleID
 	old[0] = 8
 	target := domain.RemoteSessionTarget{Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: old, SessionName: "work", LiveTabID: "tab-new"}
-	hello := ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned}
+	hello := protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned}
 	_, _, err := d.routeWithContext(context.Background(), hello, tr)
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 }

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
+	"github.com/bnema/vev/internal/protocol"
 	recoveryusecase "github.com/bnema/vev/internal/usecase/recovery"
 )
 		name   string
 		intent uint8
 	}{
-		{name: "new", intent: ports.IntentNew},
+		{name: "new", intent: protocol.IntentNew},
-		{name: "ephemeral", intent: ports.IntentEphemeral},
+		{name: "ephemeral", intent: protocol.IntentEphemeral},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			d := newTestDaemon(t, nil, stubClock{})
-			hello := ports.Hello{
+			hello := protocol.Hello{
-				Version: ports.ProtocolVersion, Intent: tt.intent, Name: "work",
+				Version: protocol.Version, Intent: tt.intent, Name: "work",
 				Size: domain.Size{Cols: 80, Rows: 24}, Cwd: "/untrusted/cwd",
-				Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+				Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			}
 			_, _, err := d.route(hello, &closeTrackingTransport{})
 			var protocolErr *protoErr
 			require.ErrorAs(t, err, &protocolErr)
-			require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+			require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 			d.mu.Lock()
 			sessions := len(d.sessions)
 			d.mu.Unlock()
 	d := newTestDaemon(t, newFactory(t, newQuietPTY()), stubClock{})
 	d.baseEnv = []string{"DAEMON=owned"}
 	d.mu.Lock()
-	d.inactive["work"] = inactiveSession{name: "work", cwd: "/remote/work", tabNames: []string{"main"}, state: ports.SessionDown}
+	d.inactive["work"] = inactiveSession{name: "work", cwd: "/remote/work", tabNames: []string{"main"}, state: protocol.SessionDown}
 	d.mu.Unlock()
-	hello := ports.Hello{
+	hello := protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
 		Size: domain.Size{Cols: 80, Rows: 24}, Cwd: "/untrusted/cwd",
-		Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		Env: []string{"UNTRUSTED=client"}, EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}
 	sess, ac, err := d.routeWithContext(context.Background(), hello, &closeTrackingTransport{})
 	require.NoError(t, err)
 	sess.mu.Lock()
 	require.Equal(t, []string{"DAEMON=owned"}, sess.env)
 	sess.mu.Unlock()
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 }
 func TestRouteRemoteTargetRejectsLiveIntentForInactiveSession(t *testing.T) {
 	lifecycle := remoteLifecycleForTest()
 	d.mu.Lock()
 	d.inactive["work"] = inactiveSession{
-		name: "work", incarnation: lifecycle, state: ports.SessionDown,
+		name: "work", incarnation: lifecycle, state: protocol.SessionDown,
 		tabNames:   []string{"main"},
 		tabRecords: []domain.CatalogueTabRecord{{StableID: "tab-1", Name: "main"}},
 	}
 		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: lifecycle,
 		SessionName: "work", LiveTabID: "tab-1",
 	}
-	_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+	_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
 		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}, &closeTrackingTransport{})
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	require.Empty(t, d.sessions)
 		name  string
 		entry inactiveSession
 	}{
-		{name: "broken", entry: inactiveSession{name: "work", incarnation: lifecycle, state: ports.SessionBroken}},
+		{name: "broken", entry: inactiveSession{name: "work", incarnation: lifecycle, state: protocol.SessionBroken}},
-		{name: "degraded", entry: inactiveSession{name: "work", incarnation: lifecycle, state: ports.SessionDown, record: domain.CatalogueRecord{Name: "work", DegradedReason: "checkpoint unavailable"}}},
+		{name: "degraded", entry: inactiveSession{name: "work", incarnation: lifecycle, state: protocol.SessionDown, record: domain.CatalogueRecord{Name: "work", DegradedReason: "checkpoint unavailable"}}},
-		{name: "purging", entry: inactiveSession{name: "work", incarnation: lifecycle, state: ports.SessionDown, purging: true}},
+		{name: "purging", entry: inactiveSession{name: "work", incarnation: lifecycle, state: protocol.SessionDown, purging: true}},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			d := newTestDaemon(t, nil, stubClock{})
 				Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: lifecycle,
 				SessionName: "work", Stopped: true,
 			}
-			_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+			_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-				Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",
+				Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
 				Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-				EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			}, &closeTrackingTransport{})
 			var protocolErr *protoErr
 			require.ErrorAs(t, err, &protocolErr)
-			require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+			require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 		})
 	}
 }
 func TestRouteRemoteTargetMapsConcurrentInactiveResumeToNoSuchTarget(t *testing.T) {
 	d := newTestDaemon(t, nil, stubClock{})
 	lifecycle := remoteLifecycleForTest()
-	d.inactive["work"] = inactiveSession{name: "work", incarnation: lifecycle, state: ports.SessionDown}
+	d.inactive["work"] = inactiveSession{name: "work", incarnation: lifecycle, state: protocol.SessionDown}
 	d.creating["work"] = struct{}{}
 	target := domain.RemoteSessionTarget{
 		Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: lifecycle,
 		SessionName: "work", Stopped: true,
 	}
-	_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+	_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
 		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 	}, &closeTrackingTransport{})
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 }
 func TestRouteRemoteTargetPreservesInactiveResumeFailures(t *testing.T) {
 		}
 	}
 	route := func(d *Daemon, target domain.RemoteSessionTarget) error {
-		_, _, err := d.routeWithContext(context.Background(), ports.Hello{
+		_, _, err := d.routeWithContext(context.Background(), protocol.Hello{
-			Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: target.SessionName,
+			Version: protocol.Version, Intent: protocol.IntentAttach, Name: target.SessionName,
 			Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-			EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+			EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		}, &closeTrackingTransport{})
 		return err
 	}
 		record.Committed = nil
 		record.TabNames = nil
 		record.TabRecords = nil
-		d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+		d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 		err := route(d, newTarget(record))
 		require.ErrorIs(t, err, cause)
 		d.catalogue = recordErrorCatalogue{durableRecoveryCatalogue: catalogue, err: cause}
 		d.persistEnabled = true
 		d.recovery = recoveryusecase.NewCoordinator(d.catalogue, noOpSnapshotRepository{}, nil)
-		d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+		d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 		err := route(d, newTarget(record))
 		require.ErrorIs(t, err, cause)
 			d.catalogue = catalogue
 			d.persistEnabled = true
 			d.recovery = recoveryusecase.NewCoordinator(catalogue, noOpSnapshotRepository{}, nil)
-			d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+			d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 			target := domain.RemoteSessionTarget{
 				Endpoint: "arch", DisplayOrigin: "arch", LifecycleID: record.IncarnationID,
 				SessionName: record.Name, Stopped: true, StoppedTab: test.selector,
 			}
 			transport, _ := newCapturingTransport(t)
-			sess, attachment, err := d.routeWithContext(context.Background(), ports.Hello{
+			sess, attachment, err := d.routeWithContext(context.Background(), protocol.Hello{
-				Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: record.Name,
+				Version: protocol.Version, Intent: protocol.IntentAttach, Name: record.Name,
 				Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-				EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+				EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 			}, transport)
 			require.NoError(t, err)
 			t.Cleanup(func() { d.clientGone(sess, attachment, transport, false) })
 	lifecycle := remoteLifecycleForTest()
 	d.mu.Lock()
 	d.inactive["work"] = inactiveSession{
-		name: "work", cwd: "/remote/work", incarnation: lifecycle, state: ports.SessionDown,
+		name: "work", cwd: "/remote/work", incarnation: lifecycle, state: protocol.SessionDown,
 		tabNames: []string{"alpha", "beta"},
 		tabRecords: []domain.CatalogueTabRecord{
 			{StableID: "tab-a", Name: "alpha"},
 		StoppedTab: domain.NewStableTabSelector("tab-b"),
 	}
 	tr, _ := newCapturingTransport(t)
-	hello := ports.Hello{
+	hello := protocol.Hello{
-		Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",
+		Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
 		Size: domain.Size{Cols: 80, Rows: 24}, RemoteTarget: &target,
-		EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,
+		EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
 		Env:               []string{"VEV_REMOTE_PICKER_SENTINEL=untrusted"},
 	}
 	sess, ac, err := d.routeWithContext(context.Background(), hello, tr)

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


@@ -46,7 +46,7 @@ func newCoordinatorMockClock(t testing.T, capacity int) coordinatorMockClock {
46		}	46		}
47		clk.clock.EXPECT().Now().Return(time.Time{}).Maybe()	47		clk.clock.EXPECT().Now().Return(time.Time{}).Maybe()
48		clk.clock.EXPECT().NewTimer(mock.MatchedBy(func(d time.Duration) bool {	48		clk.clock.EXPECT().NewTimer(mock.MatchedBy(func(d time.Duration) bool {
49	-	return d == ports.HandshakeTimeout \|\|	49	+	return d == protocol.HandshakeTimeout \|\|
50		d == urgentRenderDeadline \|\|	50		d == urgentRenderDeadline \|\|
51		(d >= minOutputRenderDeadline && d <= maxOutputRenderDeadline) \|\|	51		(d >= minOutputRenderDeadline && d <= maxOutputRenderDeadline) \|\|
52		d == maxSyncUpdateDuration \|\|	52		d == maxSyncUpdateDuration \|\|

@@ -66,7 +66,7 @@ func newCoordinatorMockClock(t testing.T, capacity int) coordinatorMockClock {
66		timer.mock.EXPECT().Stop().Run(func() {	66		timer.mock.EXPECT().Stop().Run(func() {
67		timer.stopOnce.Do(func() { close(timer.stopped) })	67		timer.stopOnce.Do(func() { close(timer.stopped) })
68		}).Maybe().Return(true)	68		}).Maybe().Return(true)
69	-	if d == ports.HandshakeTimeout {	69	+	if d == protocol.HandshakeTimeout {
70		clk.handshakeTimers <- timer	70		clk.handshakeTimers <- timer
71		} else {	71		} else {
72		clk.timers <- timer	72		clk.timers <- timer

M internal/usecase/daemon/render_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"
 	scopy "github.com/bnema/vev/internal/usecase/copy"
 	"github.com/bnema/vev/internal/usecase/layout"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 	f := awaitFrame(t, sends, ports.MsgDetached)
 	det, err := ports.UnmarshalDetached(f.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ReasonSessionKilled, det.Reason)
+	require.Equal(t, protocol.ReasonSessionKilled, det.Reason)
 }
 func TestPTYEOFClosesActiveNonFinalTabAndRepaintsRemaining(t *testing.T) {
 	f := awaitFrame(t, sends, ports.MsgDetached)
 	det, err := ports.UnmarshalDetached(f.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ReasonSessionKilled, det.Reason)
+	require.Equal(t, protocol.ReasonSessionKilled, det.Reason)
 	d.sessWg.Wait()
 }
 	require.Empty(t, sess.snapshotAttachmentsLocked())
 	sess.mu.Unlock()
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 	cancel()
 	d.waitNotifies()
 }

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


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

@@ -56,12 +56,12 @@ func TestResizeControlHeadlessAndErrors(t *testing.T) {
56		t.Cleanup(func() { factory.close(); d.sessWg.Wait() })	56		t.Cleanup(func() { factory.close(); d.sessWg.Wait() })
57		sess := addControlSession(d, "work", "t_work", "p_work")	57		sess := addControlSession(d, "work", "t_work", "p_work")
58			58
59	-	tooEarly := sendCommand(t, d, ports.CommandRequest{Slug: "grow-pane-width", TargetSession: "work"})	59	+	tooEarly := sendCommand(t, d, protocol.CommandRequest{Slug: "grow-pane-width", TargetSession: "work"})
60		require.False(t, tooEarly.OK)	60		require.False(t, tooEarly.OK)
61	-	require.Equal(t, ports.ErrNoSuchTarget, tooEarly.Code)	61	+	require.Equal(t, protocol.ErrNoSuchTarget, tooEarly.Code)
62		require.Equal(t, "pane is not in a split", tooEarly.Text)	62		require.Equal(t, "pane is not in a split", tooEarly.Text)
63			63
64	-	require.True(t, sendCommand(t, d, ports.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)	64	+	require.True(t, sendCommand(t, d, protocol.CommandRequest{Slug: "split-right", TargetSession: "work"}).OK)
65		tb := testAttachmentTab(sess)	65		tb := testAttachmentTab(sess)
66		tb.mu.Lock()	66		tb.mu.Lock()
67		beforeFocus := tb.tree.Focus	67		beforeFocus := tb.tree.Focus

@@ -87,7 +87,7 @@ func TestResizeControlHeadlessAndErrors(t *testing.T) {
87		require.Equal(t, beforeGeneration+1, tb.layoutGeneration)	87		require.Equal(t, beforeGeneration+1, tb.layoutGeneration)
88		tb.mu.Unlock()	88		tb.mu.Unlock()
89			89
90	-	equalized := sendCommand(t, d, ports.CommandRequest{Slug: "equalize-panes", TargetSession: "work"})	90	+	equalized := sendCommand(t, d, protocol.CommandRequest{Slug: "equalize-panes", TargetSession: "work"})
91		require.True(t, equalized.OK, equalized.Text)	91		require.True(t, equalized.OK, equalized.Text)
92		require.Empty(t, equalized.Output)	92		require.Empty(t, equalized.Output)
93		}	93		}

M internal/usecase/daemon/resume.go +17 -16

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 var errResumeTokenLifecycleRace = errors.New("resume token lifecycle race")
 // waitParkingInFlight waits for an identified same-client parking publication
 // to finish. Returns true when a matching in-flight entry was observed.
 // Unknown and mismatched credentials return false without waiting.
-func (d *Daemon) waitParkingInFlight(h ports.Hello) bool {
+func (d *Daemon) waitParkingInFlight(h protocol.Hello) bool {
 	if h.ResumeToken == 0 {
 		return false
 	}
 // to the named session's active attachment because transport teardown has not
 // parked it yet. Only the exact live owner (same session, token, and client ID)
 // is accepted; arbitrary unknown tokens stay fail-closed.
-func (d *Daemon) resumeLiveAttachment(h ports.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
+func (d *Daemon) resumeLiveAttachment(h protocol.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
 	d.mu.Lock()
 	if d.closing {
 		d.mu.Unlock()
-		return nil, nil, false, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}
+		return nil, nil, false, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
 	}
 	// Teardown may have parked the credential already.
 	if d.parked[h.ResumeToken] != nil {
 	}
 	if credentialMatch && h.RemoteTarget != nil && !d.remoteTargetMatchesSessionLocked(sess, *h.RemoteTarget) {
 		d.mu.Unlock()
-		return nil, nil, false, &protoErr{ports.ErrNoSuchTarget, "remote target no longer matches resumed session"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchTarget, "remote target no longer matches resumed session"}
 	}
 	d.mu.Unlock()
 	if clientMismatch {
 		reason := "client id mismatch"
 		d.log.Warn("resume rejected", "session", sess.nameSnapshot(), "err", reason)
-		return nil, nil, false, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
 	}
 	if !credentialMatch {
 		// Detach may have won and not published parked yet; wait out that gap
 		closing := d.closing
 		d.mu.Unlock()
 		if closing {
-			return nil, nil, false, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}
+			return nil, nil, false, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
 		}
-		return nil, nil, false, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
 	}
 	_ = ac.closeCapturedTransport(oldSnap.transport)
 	d.log.Info("live resume credential parked for reconnect", "session", sess.nameSnapshot())
 // registry lock, preserving the global sendMu > Daemon.mu ordering. The parked
 // entry is revalidated after both locks are held because it may expire between
 // the initial lookup and lock acquisition.
-func (d *Daemon) resumeParked(h ports.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
+func (d *Daemon) resumeParked(h protocol.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
 	d.mu.Lock()
 	parked := d.parked[h.ResumeToken]
 	d.mu.Unlock()
 	if d.closing {
 		d.mu.Unlock()
 		ac.sendMu.Unlock()
-		return nil, nil, false, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}
+		return nil, nil, false, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
 	}
 	if d.parked[h.ResumeToken] != parked || parked.claimed {
 		if d.sessions[parked.sess.id] == parked.sess {
 		}
 		d.mu.Unlock()
 		ac.sendMu.Unlock()
-		return nil, nil, false, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
 	}
 	sess, resumed, ok, err := d.resumeParkedLocked(h, tr, sz)
 	d.mu.Unlock()
 // resumeParkedLocked completes a validated resume. Caller holds both ac.sendMu
 // and d.mu in that order.
-func (d *Daemon) resumeParkedLocked(h ports.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
+func (d *Daemon) resumeParkedLocked(h protocol.Hello, tr ports.Transport, sz domain.Size) (*session, *attachedClient, bool, error) {
 	parked := d.parked[h.ResumeToken]
 	if parked == nil || h.ResumeToken == 0 {
 		return nil, nil, false, nil
 	if !registered {
 		d.removeParkedLocked(h.ResumeToken, parked)
 		d.log.Warn("resume rejected", "session", sess.nameSnapshot(), "registered", false)
-		return nil, nil, false, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
 	}
 	ac := parked.ac
 	if parked.claimed {
 	if ac.clientID != h.ClientID {
 		reason := "client id mismatch"
 		d.log.Warn("resume rejected", "session", sess.nameSnapshot(), "err", reason)
-		return nil, nil, false, &protoErr{ports.ErrNoSuchSession, "resume token is no longer valid"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchSession, "resume token is no longer valid"}
 	}
 	if h.RemoteTarget != nil && !d.remoteTargetMatchesSessionLocked(sess, *h.RemoteTarget) {
-		return nil, nil, false, &protoErr{ports.ErrNoSuchTarget, "remote target no longer matches resumed session"}
+		return nil, nil, false, &protoErr{protocol.ErrNoSuchTarget, "remote target no longer matches resumed session"}
 	}
 	// Claim the attachment while retaining the old credential until Welcome is
 	// accepted. A failed handshake can therefore restore this exact parked
 	// The resumed session's snapshot is the sole source for future PTY children.
 	// Existing PTYs retain the environment they were started with.
 	sess.mu.Lock()
-	if h.EnvironmentPolicy != ports.EnvironmentPolicyDaemonOwned {
+	if h.EnvironmentPolicy != protocol.EnvironmentPolicyDaemonOwned {
 		sess.env = copyEnvironment(h.Env)
 	}
 	sess.mu.Unlock()
 	ac.sendMu.Lock()
 	d.mu.Lock()
 	if err != nil {
-		return sess, ac, false, &protoErr{ports.ErrInternal, "resume attachment transition failed"}
+		return sess, ac, false, &protoErr{protocol.ErrInternal, "resume attachment transition failed"}
 	}
 	d.deferAttachmentTransitionCleanups(transition)
 	d.touchMRU(sess)

M internal/usecase/daemon/resume_test.go +118 -117

 	"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/layout"
 )
 	return t.count
 }
-func helloResumeCapable(intent uint8, name string, token uint64) ports.Hello {
+func helloResumeCapable(intent uint8, name string, token uint64) protocol.Hello {
-	return ports.Hello{
+	return protocol.Hello{
-		Version:     ports.ProtocolVersion,
+		Version:     protocol.Version,
 		Intent:      intent,
 		ClientID:    [16]byte{1, 2, 3, 4},
 		ResumeToken: token,
 func TestTokenlessResumeIsRejectedBeforeNameRouting(t *testing.T) {
 	d := newTestDaemon(t, nil, stubClock{})
 	tr, _ := newCapturingTransport(t)
-	_, _, err := d.route(helloResumeCapable(ports.IntentResume, "work", 0), tr)
+	_, _, err := d.route(helloResumeCapable(protocol.IntentResume, "work", 0), tr)
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchSession, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, protocolErr.code)
 	d.mu.Lock()
 	sessionCount := len(d.sessions)
 	d.mu.Unlock()
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	target := domain.RemoteSessionTarget{
 		LifecycleID: sess.incarnation, SessionName: sess.name, LiveTabID: "missing-tab",
 	}
-	resume := helloResumeCapable(ports.IntentResume, "work", token)
+	resume := helloResumeCapable(protocol.IntentResume, "work", token)
 	resume.RemoteTarget = &target
-	resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	resume.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 	_, _, err = d.route(resume, &closeTrackingTransport{})
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	require.Same(t, oldTransport, ac.transport())
 	d.mu.Lock()
 	_, parked := d.parked[token]
 	d.mu.Unlock()
 	require.False(t, parked, "mismatched target must not park the live attachment")
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 }
 func TestParkedResumeRejectsMismatchedRemoteTargetBeforeClaim(t *testing.T) {
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
 	target := domain.RemoteSessionTarget{
 		LifecycleID: sess.incarnation, SessionName: sess.name, LiveTabID: "missing-tab",
 	}
-	resume := helloResumeCapable(ports.IntentResume, "work", token)
+	resume := helloResumeCapable(protocol.IntentResume, "work", token)
 	resume.RemoteTarget = &target
-	resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	resume.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 	_, _, err = d.route(resume, &closeTrackingTransport{})
 	var protocolErr *protoErr
 	require.ErrorAs(t, err, &protocolErr)
-	require.Equal(t, ports.ErrNoSuchTarget, protocolErr.code)
+	require.Equal(t, protocol.ErrNoSuchTarget, protocolErr.code)
 	d.mu.Lock()
 	parked := d.parked[token]
 	claimed := parked != nil && parked.claimed
 	require.NotNil(t, parked)
 	require.False(t, claimed, "mismatched target must not claim the parked attachment")
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 }
 func TestFailedResumeRearmsParkExpiryAfterClaimTimerFires(t *testing.T) {
 	d := newTestDaemon(t, newFactory(t, pty), clock)
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
 	d.mu.Unlock()
 	require.NotNil(t, parked)
-	resumed, resumedAC, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)
+	resumed, resumedAC, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{}, defaultSize)
 	require.NoError(t, err)
 	require.True(t, ok)
 	require.Same(t, sess, resumed)
 	d.mu.Unlock()
 	require.False(t, retained, "rearmed credential must still expire")
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
 	d.sessWg.Wait()
 }
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "bounded-send-resume", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "bounded-send-resume", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
 	go func() {
 		transport, sendErr := d.boundedSendWithTimeout(time.Second, expected.transport, func() error {
 			defer close(orphanDone)
-			return ac.sendExpectedTransport(expected, frameDetached(ports.ReasonDetach))
+			return ac.sendExpectedTransport(expected, frameDetached(protocol.ReasonDetach))
 		})
 		result <- boundedResult{transport: transport, err: sendErr}
 	}()
 	newTransport := &closeTrackingTransport{}
 	d.mu.Lock()
 	resumedSess, resumedAC, ok, err := d.resumeParkedLocked(
-		helloResumeCapable(ports.IntentResume, sess.name, token),
+		helloResumeCapable(protocol.IntentResume, sess.name, token),
 		newTransport,
 		domain.Size{Cols: 80, Rows: 24},
 	)
 	d.notifyDetachedSnapshotAsync(detachedAttachmentSnapshot{
 		ac:        ac,
 		transport: ac.transportSnapshot(),
-	}, ports.ReasonDetach)
+	}, protocol.ReasonDetach)
 	timer := <-clock.timers
 	timer.ch <- time.Time{}
 	d.waitNotifies()
 	clock := newCoordinatorMockClock(t, 4)
 	d := newTestDaemon(t, newFactorySeq(t, pty), clock.clock)
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "resume-welcome-gate", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "resume-welcome-gate", 0), oldTransport)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, oldTransport, false)
 	tr := newWelcomeBlockingTransport(t)
 	done := make(chan struct{})
-	resumeHello := helloResumeCapable(ports.IntentResume, sess.name, token)
+	resumeHello := helloResumeCapable(protocol.IntentResume, sess.name, token)
 	go func() {
 		d.handleHello(tr.tr, ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(resumeHello)})
 		close(done)
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
 	tr := &closeTrackingTransport{}
-	initial := helloResumeCapable(ports.IntentEphemeral, "", 0)
+	initial := helloResumeCapable(protocol.IntentEphemeral, "", 0)
 	initial.Size = domain.Size{Cols: 120, Rows: 40}
 	sess, ac, err := d.route(initial, tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token, "ephemeral sessions receive resume tokens")
-	peerHello := helloResumeCapable(ports.IntentAttach, sess.name, 0)
+	peerHello := helloResumeCapable(protocol.IntentAttach, sess.name, 0)
 	peerHello.ClientID = [16]byte{9}
 	peerHello.Size = domain.Size{Cols: 100, Rows: 30}
 	peer := &closeTrackingTransport{}
 	d.mu.Unlock()
 	require.True(t, parked, "ephemeral resume-capable link loss is parked")
-	resumeHello := helloResumeCapable(ports.IntentResume, sess.name, token)
+	resumeHello := helloResumeCapable(protocol.IntentResume, sess.name, token)
 	resumeHello.Size = domain.Size{Cols: 80, Rows: 24}
 	newTr := &closeTrackingTransport{}
 	resumedSess, resumedAC, err := d.route(resumeHello, newTr)
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	}
 	result := make(chan routeResult, 1)
 	go func() {
-		routedSess, routedAC, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), resumeTr)
+		routedSess, routedAC, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), resumeTr)
 		result <- routeResult{sess: routedSess, ac: routedAC, err: routeErr}
 	}()
 	awaitTestCompletion(t, reachedLookup, "resumeParked did not pause after the parked lookup")
 	require.Nil(t, got.ac)
 	var pe *protoErr
 	require.ErrorAs(t, got.err, &pe)
-	require.Equal(t, ports.ErrNoSuchSession, pe.code)
+	require.Equal(t, protocol.ErrNoSuchSession, pe.code)
 	require.Contains(t, pe.Error(), "resume token is no longer valid")
 	require.Empty(t, sess.snapshotAttachments(), "lifecycle-race resume must not take over the named session")
 	require.Empty(t, resumeTr.Sends(), "failed resume must not complete a Welcome handshake")
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	}
 	result := make(chan routeResult, 1)
 	go func() {
-		routedSess, routedAC, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), resumeTr)
+		routedSess, routedAC, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), resumeTr)
 		result <- routeResult{sess: routedSess, ac: routedAC, err: routeErr}
 	}()
 	awaitTestCompletion(t, reachedLookup, "live resume did not pause inside resumeParked after parking")
 	require.False(t, errors.Is(got.err, errResumeTokenLifecycleRace), "raw lifecycle sentinel must not reach route callers")
 	var pe *protoErr
 	require.ErrorAs(t, got.err, &pe)
-	require.Equal(t, ports.ErrNoSuchSession, pe.code)
+	require.Equal(t, protocol.ErrNoSuchSession, pe.code)
 	require.Contains(t, pe.Error(), "resume token is no longer valid")
 	require.Empty(t, sess.snapshotAttachments(), "losing live resume must not take over the named session")
 	require.Empty(t, resumeTr.Sends(), "failed live resume must not complete a Welcome handshake")
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	require.Same(t, sess, parkingInGap.sess)
 	require.False(t, parkedInGap, "fixture: park must not have published yet")
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
 	require.Error(t, err)
 	var unknownErr *protoErr
 	require.ErrorAs(t, err, &unknownErr)
-	require.Equal(t, ports.ErrNoSuchSession, unknownErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, unknownErr.code)
 	require.Contains(t, unknownErr.Error(), "resume token is no longer valid")
-	wrongClient := helloResumeCapable(ports.IntentResume, "work", token)
+	wrongClient := helloResumeCapable(protocol.IntentResume, "work", token)
 	wrongClient.ClientID = [16]byte{9, 9, 9, 9}
 	_, _, err = d.route(wrongClient, &closeTrackingTransport{})
 	require.Error(t, err)
 	var mismatchErr *protoErr
 	require.ErrorAs(t, err, &mismatchErr)
-	require.Equal(t, ports.ErrNoSuchSession, mismatchErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, mismatchErr.code)
 	require.Contains(t, mismatchErr.Error(), "resume token is no longer valid")
 	newTr := &closeTrackingTransport{}
 	d.afterParkingWaitArmed = func() { close(waiterArmed) }
 	result := make(chan routeResult, 1)
 	go func() {
-		routedSess, routedAC, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), newTr)
+		routedSess, routedAC, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), newTr)
 		result <- routeResult{sess: routedSess, ac: routedAC, err: routeErr}
 	}()
 	awaitTestCompletion(t, waiterArmed, "resume waiter did not arm on parking marker before park")
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	firstTr := &closeTrackingTransport{}
 	firstResult := make(chan routeResult, 1)
 	go func() {
-		routedSess, routedAC, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), firstTr)
+		routedSess, routedAC, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), firstTr)
 		firstResult <- routeResult{sess: routedSess, ac: routedAC, err: routeErr}
 	}()
 	awaitTestCompletion(t, reachedGap, "first live resume did not pause after detach before park")
 	require.Same(t, ac, parkingInGap.ac)
 	require.False(t, parkedInGap, "fixture: park must not have published yet")
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
 	require.Error(t, err)
 	var unknownErr *protoErr
 	require.ErrorAs(t, err, &unknownErr)
-	require.Equal(t, ports.ErrNoSuchSession, unknownErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, unknownErr.code)
 	secondTr := &closeTrackingTransport{}
 	secondWaiting := make(chan struct{})
 	}
 	secondResult := make(chan routeResult, 1)
 	go func() {
-		routedSess, routedAC, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), secondTr)
+		routedSess, routedAC, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), secondTr)
 		secondResult <- routeResult{sess: routedSess, ac: routedAC, err: routeErr}
 	}()
 	awaitTestCompletion(t, secondWaiting, "second live resume did not arm parking wait")
 	var loserErr *protoErr
 	require.ErrorAs(t, loser.err, &loserErr)
-	require.Equal(t, ports.ErrNoSuchSession, loserErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, loserErr.code)
 	require.Contains(t, loserErr.Error(), "resume token is no longer valid")
 	require.True(t, loserTr.Closed() || len(loserTr.Sends()) == 0, "losing resume must not complete Welcome")
 	d := newTestDaemon(t, newFactorySeq(t, workPTY, otherPTY), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	otherTr := &closeTrackingTransport{}
-	otherSess, otherAC, err := d.route(helloResumeCapable(ports.IntentNew, "other", 0), otherTr)
+	otherSess, otherAC, err := d.route(helloResumeCapable(protocol.IntentNew, "other", 0), otherTr)
 	require.NoError(t, err)
 	otherToken := d.markParkingInFlight(otherSess, otherAC)
 	require.NotZero(t, otherToken)
 	d.afterParkingWaitArmed = func() { close(waiterArmed) }
 	waiterDone := make(chan bool, 1)
 	go func() {
-		waiterDone <- d.waitParkingInFlight(helloResumeCapable(ports.IntentResume, "work", token))
+		waiterDone <- d.waitParkingInFlight(helloResumeCapable(protocol.IntentResume, "work", token))
 	}()
 	awaitTestCompletion(t, waiterArmed, "parking waiter did not arm on the orphaned marker")
 	require.NotNil(t, otherAfter, "explicit winner must not clear another attachment's marker")
 	require.Same(t, otherAC, otherAfter.ac)
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", 0xdecafbad), &closeTrackingTransport{})
 	require.Error(t, err)
 	var unknownErr *protoErr
 	require.ErrorAs(t, err, &unknownErr)
-	require.Equal(t, ports.ErrNoSuchSession, unknownErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, unknownErr.code)
 	require.Contains(t, unknownErr.Error(), "resume token is no longer valid")
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{})
 	require.Error(t, err)
 	var retiredErr *protoErr
 	require.ErrorAs(t, err, &retiredErr)
-	require.Equal(t, ports.ErrNoSuchSession, retiredErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, retiredErr.code)
 	require.Contains(t, retiredErr.Error(), "resume token is no longer valid")
 	// A later parked lifecycle for another attachment must survive a clear
 			name: "session_removal",
 			win: func(t *testing.T, d *Daemon, sess *session, ac *attachedClient, oldTr *closeTrackingTransport, token uint64) {
 				t.Helper()
-				require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+				require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 				d.mu.Lock()
 				registered := d.sessions[sess.id] == sess
 				d.mu.Unlock()
 			d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 			oldTr := &closeTrackingTransport{}
-			sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+			sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 			require.NoError(t, err)
 			token := ac.resumeToken
 			require.NotZero(t, token)
 			}
 			result := make(chan routeResult, 1)
 			go func() {
-				_, _, routeErr := d.route(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{})
+				_, _, routeErr := d.route(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{})
 				result <- routeResult{err: routeErr}
 			}()
 			awaitTestCompletion(t, validated, "live resume did not pause after credential validation before mark")
 			require.Error(t, got.err)
 			var pe *protoErr
 			require.ErrorAs(t, got.err, &pe)
-			require.Equal(t, ports.ErrNoSuchSession, pe.code)
+			require.Equal(t, protocol.ErrNoSuchSession, pe.code)
 			require.Contains(t, pe.Error(), "resume token is no longer valid")
 			d.mu.Lock()
 		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 		oldTr := &closeTrackingTransport{}
-		sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+		sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 		require.NoError(t, err)
 		token := ac.resumeToken
 		require.NotZero(t, token)
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	awaitTestCompletion(t, passedPrecheck, "stale clientGone did not reach the post-precheck seam")
 	newTr := &closeTrackingTransport{}
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, "work", token), newTr)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, "work", token), newTr)
 	require.NoError(t, err)
 	require.Same(t, sess, resumedSess)
 	require.Same(t, ac, resumedAC)
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 		d.mu.Unlock()
 	}
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{})
 	require.Error(t, err)
 	var pe *protoErr
 	require.ErrorAs(t, err, &pe)
-	require.Equal(t, ports.ErrServerShutdown, pe.code)
+	require.Equal(t, protocol.ErrServerShutdown, pe.code)
 	require.Empty(t, sess.snapshotAttachments(), "failed live park must leave the session without an owner")
 	require.Nil(t, ac.transport(), "failed live park must revoke the captured old transport")
 	require.True(t, oldTr.Closed(), "failed live park must close the captured old transport")
 	defer release()
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	oldToken := ac.resumeToken
 	d.clientGone(sess, ac, ac.transport(), false)
-	tr2, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr2, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, "work", oldToken), tr2)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, "work", oldToken), tr2)
 	require.NoError(t, err)
 	require.Same(t, sess, resumedSess)
 	require.Same(t, ac, resumedAC)
 	defer release()
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, ac.transport(), false)
-	wrongClient := helloResumeCapable(ports.IntentResume, "work", token)
+	wrongClient := helloResumeCapable(protocol.IntentResume, "work", token)
 	wrongClient.ClientID = [16]byte{9, 9, 9, 9}
 	_, _, ok, err := d.resumeParked(wrongClient, &closeTrackingTransport{}, domain.Size{Cols: 80, Rows: 24})
 	d.mu.Lock()
 	require.Equal(t, token, ac.resumeToken)
 	require.True(t, ac.parked)
-	tr2, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr2, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, "work", token), tr2)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, "work", token), tr2)
 	require.NoError(t, err)
 	require.Same(t, sess, resumedSess)
 	require.Same(t, ac, resumedAC)
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.True(t, sess.detachIfCurrent(ac))
 	generation := ac.lifecycle.generationValue()
 	newTr := &closeTrackingTransport{}
-	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", token), newTr, domain.Size{Cols: 80, Rows: 24})
+	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", token), newTr, domain.Size{Cols: 80, Rows: 24})
 	require.NoError(t, err)
 	require.True(t, ok)
 	require.Same(t, sess, resumedSess)
 	defer release()
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	ac.output.next = maxUnackedOutputStates
 	token := ac.resumeToken
 	require.True(t, d.parkAttachment(sess, ac))
 	newTr := &closeTrackingTransport{}
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, "work", token), newTr)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, "work", token), newTr)
 	require.NoError(t, err)
 	require.Same(t, ac, resumedAC)
 	d.paint(resumedSess, resumedAC, true, nil)
 	defer release()
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	tb := sess.tabs[0]
 	ac.sendMu.Unlock()
 	newTransport := &closeTrackingTransport{}
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, sess.name, token), newTransport)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, sess.name, token), newTransport)
 	require.NoError(t, err)
 	require.Same(t, sess, resumedSess)
 	require.Same(t, ac, resumedAC)
 	pty, release := newBlockingPTY(t)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	d.clientGone(sess, ac, ac.transport(), true)
 	d.mu.Lock()
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), clk)
 	WithResumeParkGrace(20 * time.Minute)(d)
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	pty, release := newBlockingPTY(t)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), clk)
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, ac.transport(), false)
 	pty2, release2 := newBlockingPTY(t)
 	defer release2()
 	d2 := newTestDaemon(t, newFactory(t, pty2), stubClock{})
-	tr2, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr2, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess2, ac2, err := d2.route(helloResumeCapable(ports.IntentNew, "other", 0), tr2)
+	sess2, ac2, err := d2.route(helloResumeCapable(protocol.IntentNew, "other", 0), tr2)
 	require.NoError(t, err)
 	d2.clientGone(sess2, ac2, ac2.transport(), false)
-	d2.shutdownAll(ports.ReasonServerShutdown)
+	d2.shutdownAll(protocol.ReasonServerShutdown)
 	d2.mu.Lock()
 	parked := len(d2.parked)
 	d2.mu.Unlock()
 	pty, release := newBlockingPTY(t)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	d.clientGone(sess, ac, ac.transport(), false)
 	d.mu.Unlock()
 	require.NotNil(t, parked)
-	tr2, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr2, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	resumedSess, resumedAC, err := d.route(helloResumeCapable(ports.IntentResume, "work", token), tr2)
+	resumedSess, resumedAC, err := d.route(helloResumeCapable(protocol.IntentResume, "work", token), tr2)
 	require.NoError(t, err)
 	require.Same(t, sess, resumedSess)
 	require.Same(t, ac, resumedAC)
 			pty, release := newBlockingPTY(t)
 			defer release()
 			d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-			tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+			tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-			sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+			sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 			require.NoError(t, err)
 			d.clientGone(sess, ac, ac.transport(), false)
 	d := newTestDaemon(t, newFactory(t, pty), clk)
 	tr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentEphemeral, "", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentEphemeral, "", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	pty, release := newBlockingPTY(t)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	d.clientGone(sess, ac, ac.transport(), false)
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 	d.mu.Lock()
 	_, parked := d.parked[token]
 	d.mu.Unlock()
-	_, _, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{}, domain.Size{Cols: 80, Rows: 24})
+	_, _, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{}, domain.Size{Cols: 80, Rows: 24})
 	require.False(t, parked, "killSession purges parked token")
 	require.NoError(t, err)
 	require.False(t, ok, "killed session cannot be resumed")
 	d := newTestDaemon(t, newFactorySeq(t, workPTY, otherPTY), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	token := ac.resumeToken
 	require.NotZero(t, token)
 	otherTr := &closeTrackingTransport{}
-	otherSess, otherAC, err := d.route(helloResumeCapable(ports.IntentNew, "other", 0), otherTr)
+	otherSess, otherAC, err := d.route(helloResumeCapable(protocol.IntentNew, "other", 0), otherTr)
 	require.NoError(t, err)
 	otherToken := d.markParkingInFlight(otherSess, otherAC)
 	require.NotZero(t, otherToken)
 	d.afterParkingWaitArmed = func() { close(waiterArmed) }
 	waiterDone := make(chan bool, 1)
 	go func() {
-		waiterDone <- d.waitParkingInFlight(helloResumeCapable(ports.IntentResume, "work", token))
+		waiterDone <- d.waitParkingInFlight(helloResumeCapable(protocol.IntentResume, "work", token))
 	}()
 	awaitTestCompletion(t, waiterArmed, "parking waiter did not arm before session kill")
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 	waited := awaitTestValue(t, waiterDone, "parking waiter stayed blocked after session kill")
 	require.True(t, waited, "waiter must observe the session marker before it is purged")
 	require.True(t, otherRegistered, "other session must survive work kill when PTYs are isolated")
 	require.False(t, closing, "daemon must not shut down while the other session remains")
-	_, _, err = d.route(helloResumeCapable(ports.IntentResume, "work", token), &closeTrackingTransport{})
+	_, _, err = d.route(helloResumeCapable(protocol.IntentResume, "work", token), &closeTrackingTransport{})
 	require.Error(t, err)
 	var killedErr *protoErr
 	require.ErrorAs(t, err, &killedErr)
-	require.Equal(t, ports.ErrNoSuchSession, killedErr.code)
+	require.Equal(t, protocol.ErrNoSuchSession, killedErr.code)
 	require.Contains(t, killedErr.Error(), "resume token is no longer valid")
 }
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	oldTr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTr)
 	require.NoError(t, err)
 	freshTr := &closeTrackingTransport{}
 	ac.replaceTransport(freshTr)
 	defer release()
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), tr)
 	require.NoError(t, err)
 	d.handleSequencedInput(sess, ac, 42, []byte("x"))
 		},
 	).Maybe()
 	d := newTestDaemon(t, factory, stubClock{})
-	tr, _, _ := newConn(t, mustHello(ports.IntentAttach, "unused", domain.Size{}))
+	tr, _, _ := newConn(t, mustHello(protocol.IntentAttach, "unused", domain.Size{}))
-	hello := helloResumeCapable(ports.IntentNew, "work", 0)
+	hello := helloResumeCapable(protocol.IntentNew, "work", 0)
 	hello.Env = []string{"SECRET=before", "SHELL=/bin/sh", "TERM=old", "VEV=old"}
 	sess, ac, err := d.route(hello, tr)
 	require.NoError(t, err)
 	require.True(t, sess.detachIfCurrent(ac))
 	require.True(t, d.parkAttachment(sess, ac))
-	resumeHello := helloResumeCapable(ports.IntentResume, "work", token)
+	resumeHello := helloResumeCapable(protocol.IntentResume, "work", token)
 	resumeHello.Env = []string{"SECRET=after", "PAIR=a=b", "SHELL=/usr/bin/fish", "TERM=old", "COLORTERM=old", "TERM_PROGRAM=old", "VEV=old"}
 	resumeHello.TrueColor = true
 	_, _, ok, err := d.resumeParked(resumeHello, &closeTrackingTransport{}, domain.Size{Cols: 80, Rows: 24})
 	d := newTestDaemon(t, newFactory(t, pty), stubClock{})
 	d.baseEnv = []string{"DAEMON=owned"}
 	oldTransport := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
 	require.NoError(t, err)
 	sess.mu.Lock()
 	sess.env = copyEnvironment(d.baseEnv)
 	require.True(t, sess.detachIfCurrent(ac))
 	require.True(t, d.parkAttachment(sess, ac))
-	resume := helloResumeCapable(ports.IntentResume, "work", token)
+	resume := helloResumeCapable(protocol.IntentResume, "work", token)
-	resume.EnvironmentPolicy = ports.EnvironmentPolicyDaemonOwned
+	resume.EnvironmentPolicy = protocol.EnvironmentPolicyDaemonOwned
 	resume.Env = []string{"UNTRUSTED=client"}
 	_, _, ok, err := d.resumeParked(resume, &closeTrackingTransport{}, defaultSize)
 	require.NoError(t, err)
 	require.Equal(t, []string{"DAEMON=owned"}, sess.env)
 	sess.mu.Unlock()
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 }
 func TestResumeRenegotiatesOutputWindowOnReusedStream(t *testing.T) {
 	pty, release := newBlockingPTY(t)
 	defer release()
 	d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
-	firstHello := helloResumeCapable(ports.IntentNew, "work", 0)
+	firstHello := helloResumeCapable(protocol.IntentNew, "work", 0)
 	firstHello.MaxOutputInFlight = 8
 	sess, ac, err := d.route(firstHello, &closeTrackingTransport{})
 	require.NoError(t, err)
 	require.True(t, sess.detachIfCurrent(ac))
 	require.True(t, d.parkAttachment(sess, ac))
-	resumeOne := helloResumeCapable(ports.IntentResume, "work", token)
+	resumeOne := helloResumeCapable(protocol.IntentResume, "work", token)
 	resumeOne.MaxOutputInFlight = 1
 	_, resumed, err := d.route(resumeOne, &closeTrackingTransport{})
 	require.NoError(t, err)
 	token = resumed.resumeToken
 	require.True(t, sess.detachIfCurrent(resumed))
 	require.True(t, d.parkAttachment(sess, resumed))
-	resumeEight := helloResumeCapable(ports.IntentResume, "work", token)
+	resumeEight := helloResumeCapable(protocol.IntentResume, "work", token)
 	resumeEight.MaxOutputInFlight = 8
 	_, resumed, err = d.route(resumeEight, &closeTrackingTransport{})
 	require.NoError(t, err)

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


@@ -6,7 +6,7 @@ import (
6		"github.com/stretchr/testify/require"	6		"github.com/stretchr/testify/require"
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		)	10		)
11			11
12		// A wake can have passed coordinator scheduling before a link loss parks its	12		// A wake can have passed coordinator scheduling before a link loss parks its

@@ -19,7 +19,7 @@ func TestParkedResumeRejectsDispatchedWakeFromPriorAttachment(t *testing.T) {
19		d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})	19		d := newTestDaemon(t, newFactorySeq(t, pty), stubClock{})
20			20
21		oldTransport := &closeTrackingTransport{}	21		oldTransport := &closeTrackingTransport{}
22	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	22	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
23		require.NoError(t, err)	23		require.NoError(t, err)
24		token := ac.resumeToken	24		token := ac.resumeToken
25		rc := sess.renderCoordinator()	25		rc := sess.renderCoordinator()

@@ -45,7 +45,7 @@ func TestParkedResumeRejectsDispatchedWakeFromPriorAttachment(t *testing.T) {
45			45
46		d.clientGone(sess, ac, oldTransport, false)	46		d.clientGone(sess, ac, oldTransport, false)
47		newTransport := &closeTrackingTransport{}	47		newTransport := &closeTrackingTransport{}
48	-	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(ports.IntentResume, sess.name, token), newTransport, domain.Size{Cols: 80, Rows: 24})	48	+	resumedSess, resumedAC, ok, err := d.resumeParked(helloResumeCapable(protocol.IntentResume, sess.name, token), newTransport, domain.Size{Cols: 80, Rows: 24})
49		require.NoError(t, err)	49		require.NoError(t, err)
50		require.True(t, ok)	50		require.True(t, ok)
51		require.Same(t, sess, resumedSess)	51		require.Same(t, sess, resumedSess)

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


@@ -30,10 +30,10 @@ func TestRouteAppliesPreferredTabPerAttachment(t *testing.T) {
30		sess.mu.Unlock()	30		sess.mu.Unlock()
31		tr := &closeTrackingTransport{}	31		tr := &closeTrackingTransport{}
32		target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}	32		target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
33	-	hello := ports.Hello{	33	+	hello := protocol.Hello{
34	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: sess.name,	34	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: sess.name,
35		Size: defaultSize, ExactTarget: &target, PreferredTabID: test.preferred,	35		Size: defaultSize, ExactTarget: &target, PreferredTabID: test.preferred,
36	-	EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	36	+	EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
37		}	37		}
38			38
39		_, ac, err := d.routeWithContext(context.Background(), hello, tr)	39		_, ac, err := d.routeWithContext(context.Background(), hello, tr)

@@ -50,7 +50,7 @@ func TestResumeAppliesPreferredTabToParkedAttachment(t *testing.T) {
50		defer release()	50		defer release()
51		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	51		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
52		oldTransport := &closeTrackingTransport{}	52		oldTransport := &closeTrackingTransport{}
53	-	sess, ac, err := d.route(helloResumeCapable(ports.IntentNew, "work", 0), oldTransport)	53	+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentNew, "work", 0), oldTransport)
54		require.NoError(t, err)	54		require.NoError(t, err)
55		second := newTabWithStableID("tab-2", "pane-2", newQuietPTY(), domain.Size{Cols: 80, Rows: 22})	55		second := newTabWithStableID("tab-2", "pane-2", newQuietPTY(), domain.Size{Cols: 80, Rows: 22})
56		sess.mu.Lock()	56		sess.mu.Lock()

@@ -60,7 +60,7 @@ func TestResumeAppliesPreferredTabToParkedAttachment(t *testing.T) {
60		token := ac.resumeToken	60		token := ac.resumeToken
61		d.clientGone(sess, ac, oldTransport, false)	61		d.clientGone(sess, ac, oldTransport, false)
62			62
63	-	hello := helloResumeCapable(ports.IntentResume, "work", token)	63	+	hello := helloResumeCapable(protocol.IntentResume, "work", token)
64		hello.PreferredTabID = "tab-2"	64		hello.PreferredTabID = "tab-2"
65		newTransport := &closeTrackingTransport{}	65		newTransport := &closeTrackingTransport{}
66		resumedSession, resumed, err := d.route(hello, newTransport)	66		resumedSession, resumed, err := d.route(hello, newTransport)

@@ -80,9 +80,9 @@ func TestPaintPublishesChangedAttachmentRoutePosition(t *testing.T) {
80		sess.mu.Unlock()	80		sess.mu.Unlock()
81		tr := &closeTrackingTransport{}	81		tr := &closeTrackingTransport{}
82		target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}	82		target := protocol.ExactSessionTarget{LifecycleID: sess.incarnation, SessionName: sess.name}
83	-	hello := ports.Hello{	83	+	hello := protocol.Hello{
84	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: sess.name,	84	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: sess.name,
85	-	Size: defaultSize, ExactTarget: &target, EnvironmentPolicy: ports.EnvironmentPolicyClientOwned,	85	+	Size: defaultSize, ExactTarget: &target, EnvironmentPolicy: protocol.EnvironmentPolicyClientOwned,
86		}	86		}
87		_, ac, err := d.routeWithContext(context.Background(), hello, tr)	87		_, ac, err := d.routeWithContext(context.Background(), hello, tr)
88		require.NoError(t, err)	88		require.NoError(t, err)

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	"github.com/bnema/vev/internal/usecase/layout"
 )
 			return nil, domain.UserErr(domain.NoticeSessionSpawn, "couldn't read session catalogue", err)
 		}
 		if d.closing {
-			return nil, &protoErr{ports.ErrServerShutdown, "daemon is shutting down"}
+			return nil, &protoErr{protocol.ErrServerShutdown, "daemon is shutting down"}
 		}
 		stopped, resuming = d.inactive[name]
 		if !inactiveResumeFenceAllows(stopped, resuming, expectedInactive, authoritative, authoritativeExists, validateInactive) {
 		ready:             true,
 	})
 	if err != nil {
-		_ = d.killSession(newSess, ports.ReasonSessionKilled, true)
+		_ = d.killSession(newSess, protocol.ReasonSessionKilled, true)
 		return err
 	}
 	})
 	if err != nil {
 		if created != nil {
-			_ = d.killSession(created, ports.ReasonSessionKilled, true)
+			_ = d.killSession(created, protocol.ReasonSessionKilled, true)
 		}
 		return err
 	}
 		expectedTransport: ac.transportSnapshot(), ready: true,
 	})
 	if err != nil {
-		_ = d.killSession(newSess, ports.ReasonSessionKilled, true)
+		_ = d.killSession(newSess, protocol.ReasonSessionKilled, true)
 		return err
 	}
 	d.touchMRU(newSess)
 	})
 	if err != nil {
 		if created != nil {
-			_ = d.killSession(created, ports.ReasonSessionKilled, true)
+			_ = d.killSession(created, protocol.ReasonSessionKilled, true)
 		}
 		return err
 	}
 		var err error
 		if effect != nil {
 			effect.bindActionEnd(d, "close-tab")
-			err = d.killSessionForAttachment(sess, ports.ReasonSessionKilled, false, effect, "close-tab")
+			err = d.killSessionForAttachment(sess, protocol.ReasonSessionKilled, false, effect, "close-tab")
 		} else {
-			err = d.killSession(sess, ports.ReasonSessionKilled, false)
+			err = d.killSession(sess, protocol.ReasonSessionKilled, false)
 		}
 		if err != nil {
 			d.log.Warn("closing last tab failed", "session", name, "err", err)
 			name := sess.name
 			sess.mu.Unlock()
 			terminalSnapshotErr = fmt.Errorf("retain final snapshot for session %q: snapshot worker unavailable, saturated, or timed out", name)
-			if reason != ports.ReasonServerShutdown {
+			if reason != protocol.ReasonServerShutdown {
 				return terminalSnapshotErr
 			}
 			// Preserve any already-queued routine capture until the blocked
 	unlockSessions()
 	d.notices.routingMu.Unlock()
 	if !ephemeral {
-		stopped := inactiveSessionFromRecord(stoppedRecord, ports.SessionDown, nil)
+		stopped := inactiveSessionFromRecord(stoppedRecord, protocol.SessionDown, nil)
 		stopped.purging = purge
 		d.inactive[stoppedName] = stopped
 	}

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


@@ -5,7 +5,7 @@ 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/stretchr/testify/require"	9		"github.com/stretchr/testify/require"
10		)	10		)
11			11

@@ -103,7 +103,7 @@ func TestLocalCreateThenKillRemovesLiveRegistryEntry(t *testing.T) {
103		d.mu.Unlock()	103		d.mu.Unlock()
104		require.Same(t, sess, registered)	104		require.Same(t, sess, registered)
105			105
106	-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))	106	+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
107		d.mu.Lock()	107		d.mu.Lock()
108		_, live := d.sessions[sess.id]	108		_, live := d.sessions[sess.id]
109		d.mu.Unlock()	109		d.mu.Unlock()

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

 	"github.com/stretchr/testify/require"
 	"github.com/bnema/vev/internal/domain"
-	"github.com/bnema/vev/internal/ports"
 	portsmocks "github.com/bnema/vev/internal/ports/mocks"
+	"github.com/bnema/vev/internal/protocol"
 )
 type retryablePurgeRepository struct {
 	pty.EXPECT().Close().Return(nil).Once()
 	d.sessions = map[domain.SessionID]*session{sess.id: sess}
-	require.Error(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.Error(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 	require.Equal(t, []string{"delete incarnation"}, repository.calls)
 	_, exists, err := d.catalogue.Record("work")
 	require.NoError(t, err)

M internal/usecase/daemon/session_test.go +73 -72

 	"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/picker"
 	themeui "github.com/bnema/vev/internal/usecase/theme"
 )
 func TestHandshakeEphemeralHappy(t *testing.T) {
 	p, releasePTY := newBlockingPTY(t)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
-	tr, sends, releaseConn := newConn(t, mustHello(ports.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, releaseConn := newConn(t, mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
 func TestHandshakeNewHappy(t *testing.T) {
 	p, releasePTY := newBlockingPTY(t)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
-	tr, sends, releaseConn := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, releaseConn := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
 	require.NotNil(t, sess)
 	releaseConn()
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 	releasePTY()
 	hg.Wait()
 	d.sessWg.Wait()
 func TestHandshakeVersionMismatch(t *testing.T) {
 	// No Open expectation: the factory must never be asked to spawn a PTY.
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
-	bad := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(ports.Hello{
+	bad := ports.Frame{Type: ports.MsgHello, Payload: ports.MarshalHello(protocol.Hello{
-		Version: ports.ProtocolVersion + 99, Intent: ports.IntentEphemeral, Size: domain.Size{Cols: 80, Rows: 24},
+		Version: protocol.Version + 99, Intent: protocol.IntentEphemeral, Size: domain.Size{Cols: 80, Rows: 24},
 	})}
 	tr, sends, _ := newConn(t, bad)
 	e := awaitFrame(t, sends, ports.MsgError)
 	em, err := ports.UnmarshalErrorMsg(e.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ErrVersionMismatch, em.Code)
+	require.Equal(t, protocol.ErrVersionMismatch, em.Code)
 	require.Equal(t, 0, sessionCount(d))
 }
 func TestHandshakeOldHelloLayoutReportsVersionMismatch(t *testing.T) {
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
 	oldLayout := []byte{
-		0x00, byte(ports.ProtocolVersion - 1),
+		0x00, byte(protocol.Version - 1),
-		ports.IntentEphemeral,
+		protocol.IntentEphemeral,
 		0x00, 0x00,
 		0x00, 0x50,
 		0x00, 0x18,
 	e := awaitFrame(t, sends, ports.MsgError)
 	em, err := ports.UnmarshalErrorMsg(e.Payload)
 	require.NoError(t, err)
-	require.Equal(t, ports.ErrVersionMismatch, em.Code)
+	require.Equal(t, protocol.ErrVersionMismatch, em.Code)
 	require.Equal(t, 0, sessionCount(d))
 }
 	// Pre-populate a bare session (no goroutines) to collide with.
 	d.sessions[domain.SessionID("x")] = &session{sessionCore: sessionCore{id: "x", name: "work"}}
-	tr, sends, _ := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	d.handleConn(tr)
 	e := awaitFrame(t, sends, ports.MsgError)
 	em, _ := ports.UnmarshalErrorMsg(e.Payload)
-	require.Equal(t, ports.ErrNameTaken, em.Code)
+	require.Equal(t, protocol.ErrNameTaken, em.Code)
 }
 func TestHandshakeNoSuchSession(t *testing.T) {
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
-	tr, sends, _ := newConn(t, mustHello(ports.IntentAttach, "ghost", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentAttach, "ghost", domain.Size{Cols: 80, Rows: 24}))
 	d.handleConn(tr)
 	e := awaitFrame(t, sends, ports.MsgError)
 	em, _ := ports.UnmarshalErrorMsg(e.Payload)
-	require.Equal(t, ports.ErrNoSuchSession, em.Code)
+	require.Equal(t, protocol.ErrNoSuchSession, em.Code)
 }
 func TestKillAllEmptyDaemonSignalsShutdown(t *testing.T) {
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
-	tr, _, _ := newConn(t, ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(ports.Kill{All: true})})
+	tr, _, _ := newConn(t, ports.Frame{Type: ports.MsgKill, Payload: ports.MarshalKill(protocol.Kill{All: true})})
 	d.handleConn(tr)
 	select {
 	defer release()
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	firstTransport := &closeTrackingTransport{}
-	sess, first, err := d.route(ports.Hello{
+	sess, first, err := d.route(protocol.Hello{
-		Version:  ports.ProtocolVersion,
+		Version:  protocol.Version,
-		Intent:   ports.IntentNew,
+		Intent:   protocol.IntentNew,
 		Name:     "work",
 		ClientID: [16]byte{1},
 		Size:     domain.Size{Cols: 80, Rows: 24},
 	}, firstTransport)
 	require.NoError(t, err)
 	secondTransport := &closeTrackingTransport{}
-	_, second, err := d.route(ports.Hello{
+	_, second, err := d.route(protocol.Hello{
-		Version:  ports.ProtocolVersion,
+		Version:  protocol.Version,
-		Intent:   ports.IntentAttach,
+		Intent:   protocol.IntentAttach,
 		Name:     "work",
 		ClientID: [16]byte{2},
 		Size:     domain.Size{Cols: 80, Rows: 24},
 	require.Equal(t, contentSize(domain.Size{Cols: 80, Rows: 24}), gotSize, "sizing must come from the requesting attachment")
 	assertPaneDefaultColors(t, pane, requesterTheme.Foreground, requesterTheme.Background)
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
 	d.sessWg.Wait()
 }
 	).Once()
 	d := newTestDaemon(t, f, stubClock{})
-	tr, sends, releaseConn := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, releaseConn := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
 	awaitFrame(t, sends, ports.MsgWelcome)
 	errCh := make(chan error, 1)
 	go func() { errCh <- d.createTab(sess, domain.Size{Cols: 80, Rows: 24}) }()
 	ctx := <-openCtx
-	_ = d.killSession(sess, ports.ReasonSessionKilled, false)
+	_ = d.killSession(sess, protocol.ReasonSessionKilled, false)
 	cancelled := true
 	select {
 	p, releasePTY := newBlockingPTY(t)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr, sends, _ := newConn(t,
-		mustHello(ports.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}),
+		mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}),
-		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})},
+		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
 	)
 	var hg sync.WaitGroup
 	require.Empty(t, sess.snapshotAttachmentsLocked(), "ephemeral session is headless after detach")
 	sess.mu.Unlock()
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 	releasePTY()
 	d.sessWg.Wait()
 	d.waitNotifies()
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr := &closeTrackingTransport{}
-	sess, ac, err := d.route(helloResumeCapable(ports.IntentEphemeral, "", 0), tr)
+	sess, ac, err := d.route(helloResumeCapable(protocol.IntentEphemeral, "", 0), tr)
 	require.NoError(t, err)
 	d.clientGone(sess, ac, ac.transport(), true)
 	require.True(t, got.Sessions[0].Ephemeral)
 	require.False(t, got.Sessions[0].Attached)
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 	d.sessWg.Wait()
 	d.waitNotifies()
 }
 	p, releasePTY := newBlockingPTY(t)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	tr, sends, _ := newConn(t,
-		mustHello(ports.IntentNew, "keep", domain.Size{Cols: 80, Rows: 24}),
+		mustHello(protocol.IntentNew, "keep", domain.Size{Cols: 80, Rows: 24}),
-		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})},
+		ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})},
 	)
 	var hg sync.WaitGroup
 	require.Empty(t, sess.snapshotAttachmentsLocked(), "named session is headless after detach")
 	sess.mu.Unlock()
-	_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+	_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 	releasePTY()
 	d.sessWg.Wait()
 	d.waitNotifies()
 	p.EXPECT().Pid().Return(1).Maybe()
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
-	tr, sends, _ := newConn(t, mustHello(ports.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr) })
 	// The client is detached with ReasonSessionKilled when the child exits.
 	det := awaitFrame(t, sends, ports.MsgDetached)
 	dm, _ := ports.UnmarshalDetached(det.Payload)
-	require.Equal(t, ports.ReasonSessionKilled, dm.Reason)
+	require.Equal(t, protocol.ReasonSessionKilled, dm.Reason)
 	select {
 	case <-d.done:
 func TestServeReturnsWhenLastSessionExits(t *testing.T) {
 	p, releasePTY := newBlockingPTY(t)
-	tr, sends, _ := newConn(t, mustHello(ports.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
 	l := portsmocks.NewMockListener(t)
 	connCh := make(chan ports.Transport, 1)
 func TestServeGracefulShutdownOnContextCancel(t *testing.T) {
 	p, releasePTY := newBlockingPTY(t)
 	defer releasePTY()
-	tr, sends, _ := newConn(t, mustHello(ports.IntentNew, "long", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "long", domain.Size{Cols: 80, Rows: 24}))
 	l := portsmocks.NewMockListener(t)
 	connCh := make(chan ports.Transport, 1)
 	det := awaitFrame(t, sends, ports.MsgDetached)
 	dm, _ := ports.UnmarshalDetached(det.Payload)
-	require.Equal(t, ports.ReasonServerShutdown, dm.Reason)
+	require.Equal(t, protocol.ReasonServerShutdown, dm.Reason)
 	select {
 	case err := <-served:
 		},
 	).Maybe()
-	tr1, sends1, release1 := newConn(t, mustHello(ports.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
+	tr1, sends1, release1 := newConn(t, mustHello(protocol.IntentEphemeral, "", domain.Size{Cols: 80, Rows: 24}))
 	var hg sync.WaitGroup
 	hg.Go(func() { d.handleConn(tr1) })
 	awaitFrame(t, sends1, ports.MsgWelcome)
 	require.NotNil(t, sess)
 	// The last session dies: shutdown begins irreversibly.
-	_ = d.killSession(sess, ports.ReasonSessionKilled, false)
+	_ = d.killSession(sess, protocol.ReasonSessionKilled, false)
 	select {
 	case <-d.done:
 	default:
 		intent uint8
 		sess   string
 	}{
-		{"ephemeral", ports.IntentEphemeral, ""},
+		{"ephemeral", protocol.IntentEphemeral, ""},
-		{"named", ports.IntentNew, "latecomer"},
+		{"named", protocol.IntentNew, "latecomer"},
 	} {
 		tr2, sends2, _ := newConn(t, mustHello(intent.intent, intent.sess, domain.Size{Cols: 80, Rows: 24}))
 		d.handleConn(tr2)
 		e := awaitFrame(t, sends2, ports.MsgError)
 		em, err := ports.UnmarshalErrorMsg(e.Payload)
 		require.NoError(t, err)
-		require.Equal(t, ports.ErrServerShutdown, em.Code, "%s hello racing shutdown must be rejected", intent.name)
+		require.Equal(t, protocol.ErrServerShutdown, em.Code, "%s hello racing shutdown must be rejected", intent.name)
 	}
 	require.Equal(t, 0, sessionCount(d), "no session may be inserted after shutdown began")
 	require.Zero(t, opensAfterShutdown.Load(), "no PTYFactory.Open may start after d.done/shutdown completion")
 	tr := portsmocks.NewMockTransport(t)
 	sends := make(chan ports.Frame, 64)
 	recvCh := make(chan ports.Frame, 1)
-	recvCh <- mustHello(ports.IntentNew, "wedge", domain.Size{Cols: 80, Rows: 24})
+	recvCh <- mustHello(protocol.IntentNew, "wedge", domain.Size{Cols: 80, Rows: 24})
 	connDone := make(chan struct{})
 	var connOnce sync.Once
 	closeConn := func() { connOnce.Do(func() { close(connDone) }) }
 	require.Equal(t, int64(7), stopped.createdAt)
 	require.Equal(t, incarnation, stopped.incarnation)
 	require.Equal(t, uint64(9), stopped.lastUsedSeq)
-	require.Equal(t, ports.SessionDown, stopped.state)
+	require.Equal(t, protocol.SessionDown, stopped.state)
 	require.NotNil(t, stopped.restoreDone)
 	require.Equal(t, uint64(9), d.mruSeq.Load())
 }
 	require.Equal(t, created.IncarnationID, renamed.IncarnationID)
 	require.NoError(t, renamed.Validate())
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, true))
 	require.False(t, state.has("renamed"))
 }
 	record, ok, err := d.catalogueRecord("work")
 	require.NoError(t, err)
 	require.True(t, ok)
-	d.inactive["work"] = inactiveSessionFromRecord(record, ports.SessionDown, nil)
+	d.inactive["work"] = inactiveSessionFromRecord(record, protocol.SessionDown, nil)
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr.EXPECT().Close().Return(nil).Maybe()
-	sess, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: sz}, tr)
+	sess, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: sz}, tr)
 	require.NoError(t, err)
 	require.NotNil(t, ac)
 	require.Len(t, sess.tabs, 2)
 	require.NoError(t, d.renameSession(first, "named"))
 	staleCreatedAt := first.createdAt
 	require.NotZero(t, staleCreatedAt)
-	require.NoError(t, d.killSession(first, ports.ReasonSessionKilled, true))
+	require.NoError(t, d.killSession(first, protocol.ReasonSessionKilled, true))
 	d.sessWg.Wait()
 	second, err := createSessionForTest(d, "0", true, "/tmp", ac.size, terminalEnv{}, d.baseEnv)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	WithStore(t, store)(d)
 	cwd := t.TempDir()
-	d.inactive["work"] = inactiveSession{name: "work", cwd: cwd, createdAt: 1, state: ports.SessionDown}
+	d.inactive["work"] = inactiveSession{name: "work", cwd: cwd, createdAt: 1, state: protocol.SessionDown}
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr.EXPECT().Close().Return(nil).Maybe()
-	sess, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: sz}, tr)
+	sess, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: sz}, tr)
 	require.NoError(t, err)
 	require.NotNil(t, ac)
 	require.Equal(t, "work", sess.name)
 	store, _ := newMockStore(t)
 	d := newTestDaemon(t, newFactory(t, p), stubClock{})
 	WithStore(t, store)(d)
-	d.inactive["work"] = inactiveSession{name: "work", cwd: "/definitely/missing/vev", createdAt: 1, state: ports.SessionDown}
+	d.inactive["work"] = inactiveSession{name: "work", cwd: "/definitely/missing/vev", createdAt: 1, state: protocol.SessionDown}
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr.EXPECT().Close().Return(nil).Maybe()
-	sess, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: sz}, tr)
+	sess, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: sz}, tr)
 	require.NoError(t, err)
 	require.NotEqual(t, "/definitely/missing/vev", sess.cwd)
 }
 	sess, err := createSessionForTest(d, "work", false, "/tmp/work", sz, terminalEnv{TrueColor: true}, d.baseEnv)
 	require.NoError(t, err)
 	defer func() {
-		_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+		_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 		releasePTY()
 		d.sessWg.Wait()
 	}()
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
 	d.inactive["taken"] = inactiveSession{name: "taken", cwd: "/tmp", createdAt: 1}
 	tr := portsmocks.NewMockTransport(t)
-	_, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "taken", Size: domain.Size{Cols: 80, Rows: 24}}, tr)
+	_, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "taken", Size: domain.Size{Cols: 80, Rows: 24}}, tr)
 	require.ErrorContains(t, err, "name already in use")
 }
 func TestIntentNewUnsafeNameRejected(t *testing.T) {
 	d := newTestDaemon(t, portsmocks.NewMockPTYFactory(t), stubClock{})
 	tr := portsmocks.NewMockTransport(t)
-	_, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "my work", Size: domain.Size{Cols: 80, Rows: 24}}, tr)
+	_, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "my work", Size: domain.Size{Cols: 80, Rows: 24}}, tr)
 	require.ErrorContains(t, err, domain.ErrInvalidSessionName.Error())
 }
 	require.NoError(t, err)
 	other, err := createSessionForTest(d, "other", false, "/tmp/other", sz, terminalEnv{}, d.baseEnv)
 	require.NoError(t, err)
-	_ = d.killSession(natural, ports.ReasonSessionKilled, false)
+	_ = d.killSession(natural, protocol.ReasonSessionKilled, false)
 	require.True(t, state.has("natural"))
 	d.mu.Lock()
 	stopped := d.inactive["natural"]
 	d.mu.Unlock()
 	require.Equal(t, "/tmp/latest", stopped.cwd)
-	_ = d.killSession(other, ports.ReasonSessionKilled, true)
+	_ = d.killSession(other, protocol.ReasonSessionKilled, true)
 	require.False(t, state.has("other"))
 }
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr.EXPECT().Close().Return(nil).Maybe()
-	sess, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)
+	sess, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)
 	require.NoError(t, err)
 	defer func() {
-		_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+		_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 		d.sessWg.Wait()
 	}()
 	tr2 := portsmocks.NewMockTransport(t)
 	tr2.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr2.EXPECT().Close().Return(nil).Maybe()
-	sess, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: sz, TrueColor: false}, tr1)
+	sess, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: sz, TrueColor: false}, tr1)
 	require.NoError(t, err)
-	_, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: sz, TrueColor: true}, tr2)
+	_, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: sz, TrueColor: true}, tr2)
 	require.NoError(t, err)
 	defer func() {
-		_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+		_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 		d.sessWg.Wait()
 	}()
 	tr := portsmocks.NewMockTransport(t)
 	tr.EXPECT().Send(mock.Anything).Return(nil).Maybe()
 	tr.EXPECT().Close().Return(nil).Maybe()
-	sess, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)
+	sess, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: sz, TrueColor: true}, tr)
 	require.NoError(t, err)
 	// The source coordinator is deliberately made pending so the switch must
 	// invalidate it rather than letting its stale callback render for ac.
 	require.Contains(t, opens[1], "TERM=xterm-256color")
 	require.Contains(t, opens[1], "COLORTERM=truecolor")
 	require.Contains(t, opens[1], "TERM_PROGRAM=vev")
-	_ = d.killSession(got, ports.ReasonSessionKilled, false)
+	_ = d.killSession(got, protocol.ReasonSessionKilled, false)
 	release1()
 	release2()
 	d.sessWg.Wait()
 	tr2.EXPECT().Close().Return(nil).Maybe()
 	first := []string{"SECRET=first", "TERM=bad", "TERM_PROGRAM_extra=keep", "SHELL=/usr/bin/fish", "A=a=b"}
-	sess, _, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work", Size: sz, Env: first}, tr1)
+	sess, _, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "work", Size: sz, Env: first}, tr1)
 	require.NoError(t, err)
 	second := []string{"SECRET=second", "TERM=bad", "TERM_PROGRAM_extra=keep", "SHELL=/bin/bash", "A=a=b"}
-	_, ac, err := d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work", Size: sz, Env: second}, tr2)
+	_, ac, err := d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work", Size: sz, Env: second}, tr2)
 	require.NoError(t, err)
 	defer func() {
-		_ = d.killSession(sess, ports.ReasonServerShutdown, false)
+		_ = d.killSession(sess, protocol.ReasonServerShutdown, false)
 		d.sessWg.Wait()
 	}()
 	require.Equal(t, int64(math.MaxInt64), d.lastAllocatedCreatedAt)
 	require.Equal(t, inactiveSession{name: "retained", cwd: "/tmp", createdAt: 9}, d.inactive["retained"])
-	_, _, err = d.route(ports.Hello{Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "routed", Size: domain.Size{Cols: 80, Rows: 24}}, nil)
+	_, _, err = d.route(protocol.Hello{Version: protocol.Version, Intent: protocol.IntentNew, Name: "routed", Size: domain.Size{Cols: 80, Rows: 24}}, nil)
 	require.ErrorContains(t, err, "lifecycle identities exhausted")
 	require.Empty(t, d.sessions)
 	require.Equal(t, uint64(17), d.nextID)
 	alpha := d.inactive["alpha"]
 	require.Equal(t, records[0], alpha.record)
-	require.Equal(t, ports.SessionDown, alpha.state)
+	require.Equal(t, protocol.SessionDown, alpha.state)
 	require.NotNil(t, alpha.restoreDone)
 	select {
 	case <-alpha.restoreDone:
 	}
 	work := d.inactive["work"]
 	require.Equal(t, records[1], work.record)
-	require.Equal(t, ports.SessionBroken, work.state)
+	require.Equal(t, protocol.SessionBroken, work.state)
 	require.NotNil(t, work.restoreDone)
 	select {
 	case <-work.restoreDone:
 	store, state := newMockStore(t)
 	WithStore(t, store)(d)
 	d.ptys = newFactory(t, targetPTY)
-	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 77, state: ports.SessionDown}
+	d.inactive["stopped"] = inactiveSession{name: "stopped", cwd: "/tmp", createdAt: 77, state: protocol.SessionDown}
 	require.True(t, d.resumeStoppedAndSwitch(from, ac, picker.Target{Name: "stopped", Stopped: true}))
 	resumed := ac.currentSession()
 		d, from, ac, _ := newManualSessionWithPTYs(t, fromPTY)
 		d.ptys = newFactory(t, targetPTY)
 		expected := int64(31)
-		d.inactive["target"] = inactiveSession{name: "target", cwd: "/tmp", createdAt: expected, state: ports.SessionDown}
+		d.inactive["target"] = inactiveSession{name: "target", cwd: "/tmp", createdAt: expected, state: protocol.SessionDown}
 		require.NoError(t, d.switchToTarget(from, ac, picker.Target{Session: "old-active-id", Name: "target", TabIndex: 0, ExpectedCreatedAt: &expected}))
 		require.Equal(t, "target", ac.currentSession().name)
 		fromPTY, releaseFrom := newBlockingPTY(t)
 		defer releaseFrom()
 		d, from, ac, _ := newManualSessionWithPTYs(t, fromPTY)
-		d.inactive["target"] = inactiveSession{name: "target", cwd: "/tmp", createdAt: 52, state: ports.SessionDown}
+		d.inactive["target"] = inactiveSession{name: "target", cwd: "/tmp", createdAt: 52, state: protocol.SessionDown}
 		expected := int64(51)
 		require.Error(t, d.switchToTarget(from, ac, picker.Target{Name: "target", TabIndex: 0, Stopped: true, ExpectedCreatedAt: &expected}))

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


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

@@ -45,14 +45,14 @@ func TestSharedPTYGeometryCharacterization(t *testing.T) {
45		t.Cleanup(releasePTY)	45		t.Cleanup(releasePTY)
46		d := newTestDaemon(t, newFactory(t, pty), stubClock{})	46		d := newTestDaemon(t, newFactory(t, pty), stubClock{})
47		firstTransport, _ := newCapturingTransport(t)	47		firstTransport, _ := newCapturingTransport(t)
48	-	sess, first, err := d.route(ports.Hello{	48	+	sess, first, err := d.route(protocol.Hello{
49	-	Version: ports.ProtocolVersion, Intent: ports.IntentNew, Name: "work",	49	+	Version: protocol.Version, Intent: protocol.IntentNew, Name: "work",
50		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},	50		Size: domain.Size{Cols: 80, Rows: 24}, ClientID: [16]byte{1},
51		}, firstTransport)	51		}, firstTransport)
52		require.NoError(t, err)	52		require.NoError(t, err)
53		secondTransport, _ := newCapturingTransport(t)	53		secondTransport, _ := newCapturingTransport(t)
54	-	_, second, err := d.route(ports.Hello{	54	+	_, second, err := d.route(protocol.Hello{
55	-	Version: ports.ProtocolVersion, Intent: ports.IntentAttach, Name: "work",	55	+	Version: protocol.Version, Intent: protocol.IntentAttach, Name: "work",
56		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},	56		Size: domain.Size{Cols: 100, Rows: 40}, ClientID: [16]byte{2},
57		}, secondTransport)	57		}, secondTransport)
58		require.NoError(t, err)	58		require.NoError(t, err)

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


@@ -9,7 +9,7 @@ import (
9			9
10		vt "github.com/bnema/vev-vt"	10		vt "github.com/bnema/vev-vt"
11		"github.com/bnema/vev/internal/domain"	11		"github.com/bnema/vev/internal/domain"
12	-	"github.com/bnema/vev/internal/ports"	12	+	"github.com/bnema/vev/internal/protocol"
13		"github.com/bnema/vev/internal/usecase/layout"	13		"github.com/bnema/vev/internal/usecase/layout"
14		snapcodec "github.com/bnema/vev/internal/usecase/snapshot"	14		snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
15		)	15		)

@@ -25,7 +25,7 @@ func (d *Daemon) closeRestoreDone() {
25		continue	25		continue
26		default:	26		default:
27		}	27		}
28	-	entry.state = ports.SessionBroken	28	+	entry.state = protocol.SessionBroken
29		if entry.record.DegradedReason == "" {	29		if entry.record.DegradedReason == "" {
30		entry.record.DegradedReason = "restore unavailable"	30		entry.record.DegradedReason = "restore unavailable"
31		}	31		}

M internal/usecase/daemon/snapshot_restore_incremental.go +11 -10

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 	snapcodec "github.com/bnema/vev/internal/usecase/snapshot"
 )
 var errRetryableRestoreLoad = errors.New("snapshot: retryable checkpoint load")
-func initialSessionState(record domain.CatalogueRecord) (ports.SessionState, chan struct{}) {
+func initialSessionState(record domain.CatalogueRecord) (protocol.SessionState, chan struct{}) {
 	done := make(chan struct{})
-	state := ports.SessionDown
+	state := protocol.SessionDown
 	if record.DegradedReason != "" {
-		state = ports.SessionBroken
+		state = protocol.SessionBroken
 		close(done)
 	} else if record.Committed == nil {
 		close(done)
 	wg.Wait()
 }
-func inactiveSessionFromRecord(record domain.CatalogueRecord, state ports.SessionState, done chan struct{}) inactiveSession {
+func inactiveSessionFromRecord(record domain.CatalogueRecord, state protocol.SessionState, done chan struct{}) inactiveSession {
 	tabRecords := append([]domain.CatalogueTabRecord(nil), record.TabRecords...)
 	tabNames := append([]string(nil), record.TabNames...)
 	if len(tabRecords) != 0 {
 	}
 }
-func (d *Daemon) setStoppedRecovery(record domain.CatalogueRecord, state ports.SessionState) {
+func (d *Daemon) setStoppedRecovery(record domain.CatalogueRecord, state protocol.SessionState) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	entry, ok := d.inactive[record.Name]
 	d.mu.Lock()
 	if entry, ok := d.inactive[record.Name]; ok && degraded {
-		d.inactive[record.Name] = inactiveSessionFromRecord(record, ports.SessionBroken, entry.restoreDone)
+		d.inactive[record.Name] = inactiveSessionFromRecord(record, protocol.SessionBroken, entry.restoreDone)
 	}
 	closeRuntimeRestoreDoneLocked(done)
 	d.mu.Unlock()
 func (d *Daemon) restoreRecord(ctx context.Context, record domain.CatalogueRecord) error {
 	if record.DegradedReason != "" {
-		d.setStoppedRecovery(record, ports.SessionBroken)
+		d.setStoppedRecovery(record, protocol.SessionBroken)
 		d.logSessionDegraded(record, "persisted-broken")
 		return nil
 	}
 	if record.Committed == nil {
-		d.setStoppedRecovery(record, ports.SessionDown)
+		d.setStoppedRecovery(record, protocol.SessionDown)
 		d.logSessionRestoreComplete(record, 0, false)
 		return nil
 	}
 	if err := d.restoreSession(ctx, selectedSnapshot, selectedGeneration.Generation, selected); err != nil {
 		return err
 	}
-	d.setStoppedRecovery(record, ports.SessionDown)
+	d.setStoppedRecovery(record, protocol.SessionDown)
 	d.logSessionRestoreComplete(record, selected.Generation, false)
 	return nil
 }
 	d.mu.Lock()
 	if entry, ok := d.inactive[record.Name]; ok {
-		d.inactive[record.Name] = inactiveSessionFromRecord(fresh, ports.SessionDown, entry.restoreDone)
+		d.inactive[record.Name] = inactiveSessionFromRecord(fresh, protocol.SessionDown, entry.restoreDone)
 	}
 	d.mu.Unlock()

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

 	"github.com/bnema/vev/internal/domain"
 	"github.com/bnema/vev/internal/ports"
+	"github.com/bnema/vev/internal/protocol"
 )
 type snapshotLifecycleRepository struct {
 		d.sessWg.Wait()
 	})
-	_, _, err := d.route(snapshotLifecycleHello(ports.IntentEphemeral, ""), &closeTrackingTransport{})
+	_, _, err := d.route(snapshotLifecycleHello(protocol.IntentEphemeral, ""), &closeTrackingTransport{})
 	require.NoError(t, err, "keeper session setup failed")
-	sess, _, err := d.route(snapshotLifecycleHello(ports.IntentNew, "work"), &closeTrackingTransport{})
+	sess, _, err := d.route(snapshotLifecycleHello(protocol.IntentNew, "work"), &closeTrackingTransport{})
 	require.NoError(t, err)
 	testAttachmentTab(sess).focusedPane().screen.Write([]byte("first checkpoint"))
 	require.NotNil(t, firstRecord.Committed)
 	require.Equal(t, uint64(1), firstRecord.Committed.Generation)
-	require.NoError(t, d.killSession(sess, ports.ReasonSessionKilled, false))
+	require.NoError(t, d.killSession(sess, protocol.ReasonSessionKilled, false))
 	d.mu.Lock()
 	stopped, retained := d.inactive[sess.name]
 	d.mu.Unlock()
 	require.Equal(t, firstRecord.Committed.Generation+1, closedRecord.Committed.Generation,
 		"terminal checkpoint must be authoritative before same-daemon resume")
-	resumed, _, err := d.route(snapshotLifecycleHello(ports.IntentAttach, sess.name), &closeTrackingTransport{})
+	resumed, _, err := d.route(snapshotLifecycleHello(protocol.IntentAttach, sess.name), &closeTrackingTransport{})
 	require.NoError(t, err)
 	require.NotSame(t, sess, resumed, "stopped-session attach must create a new live runtime")
 	require.Equal(t, sess.incarnation, resumed.incarnation, "resume must retain durable incarnation authority")
 		"same-daemon resume must use the committed terminal checkpoint as parent")
 }
-func snapshotLifecycleHello(intent uint8, name string) ports.Hello {
+func snapshotLifecycleHello(intent uint8, name string) protocol.Hello {
-	return ports.Hello{
+	return protocol.Hello{
-		Version: ports.ProtocolVersion,
+		Version: protocol.Version,
 		Intent:  intent,
 		Name:    name,
 		Cwd:     "/tmp",

M internal/usecase/daemon/snapshot_scheduler_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 TestSnapshotCoordinatorQuarantineCancelsPublicationBeforeDelete(t *testing.T) {
 	require.True(t, d.scheduleSnapshot(sess), "routine capture should occupy the bounded queue")
 	killed := make(chan error, 1)
-	go func() { killed <- d.killSession(sess, ports.ReasonServerShutdown, false) }()
+	go func() { killed <- d.killSession(sess, protocol.ReasonServerShutdown, false) }()
 	timer := clock.nextTimer(t)
 	timer.fire()
 	require.Error(t, <-killed)
 		return nil
 	}).Once()
-	tr, sends, _ := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	listener := serveSnapshotListener(t, tr)
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 	d.sessions[sess.id] = sess
 	first := make(chan error, 1)
-	go func() { first <- d.killSession(sess, ports.ReasonSessionKilled, false) }()
+	go func() { first <- d.killSession(sess, protocol.ReasonSessionKilled, false) }()
 	select {
 	case <-publicationStarted:
 	case <-time.After(testWaitTimeout):
 	duplicates := make(chan error, duplicateCallers)
 	for range duplicateCallers {
 		go func() {
-			duplicates <- d.killSession(sess, ports.ReasonSessionKilled, false)
+			duplicates <- d.killSession(sess, protocol.ReasonSessionKilled, false)
 		}()
 	}
 	// Synchronize on the ownership state itself: every duplicate is waiting
 		return nil
 	}).Twice()
-	tr, sends, _ := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	l := serveSnapshotListener(t, tr)
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()
 		return nil
 	}).Twice()
-	tr, sends, _ := newConn(t, mustHello(ports.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
+	tr, sends, _ := newConn(t, mustHello(protocol.IntentNew, "work", domain.Size{Cols: 80, Rows: 24}))
 	l := serveSnapshotListener(t, tr)
 	ctx, cancel := context.WithCancel(t.Context())
 	defer cancel()

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


@@ -1441,7 +1441,7 @@ func TestStatusCoalescesCreateSwitchAndResize(t *testing.T) {
1441		clock := newCoordinatorMockClock(t, 64)	1441		clock := newCoordinatorMockClock(t, 64)
1442		d := newTestDaemon(t, newFactorySeq(t, p1, p2), clock.clock)	1442		d := newTestDaemon(t, newFactorySeq(t, p1, p2), clock.clock)
1443		tr, sends, releaseConn := newConn(t,	1443		tr, sends, releaseConn := newConn(t,
1444	-	mustHello(ports.IntentNew, "work", domain.Size{Cols: 20, Rows: 5}),	1444	+	mustHello(protocol.IntentNew, "work", domain.Size{Cols: 20, Rows: 5}),
1445		frameInput([]byte("\x1b ")),	1445		frameInput([]byte("\x1b ")),
1446		frameInput([]byte("CNT\r")),	1446		frameInput([]byte("CNT\r")),
1447		frameInput([]byte("\x1b1")),	1447		frameInput([]byte("\x1b1")),

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


@@ -16,11 +16,11 @@ func frameWelcome(s *session, resumeToken uint64) (ports.Frame, error) {
16		Ephemeral: s.ephemeral,	16		Ephemeral: s.ephemeral,
17		}	17		}
18		}	18		}
19	-	w := ports.Welcome{	19	+	w := protocol.Welcome{
20		SessionID: string(s.id),	20		SessionID: string(s.id),
21		SessionName: s.name,	21		SessionName: s.name,
22		Ephemeral: s.ephemeral,	22		Ephemeral: s.ephemeral,
23	-	Capabilities: ports.CapabilityResume,	23	+	Capabilities: protocol.CapabilityResume,
24		CommittedIdentity: identity,	24		CommittedIdentity: identity,
25		}	25		}
26		s.mu.Unlock()	26		s.mu.Unlock()

@@ -33,7 +33,7 @@ func frameWelcome(s *session, resumeToken uint64) (ports.Frame, error) {
33		}	33		}
34			34
35		func frameError(code uint16, text string) ports.Frame {	35		func frameError(code uint16, text string) ports.Frame {
36	-	return ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(ports.ErrorMsg{Code: code, Text: text})}	36	+	return ports.Frame{Type: ports.MsgError, Payload: ports.MarshalErrorMsg(protocol.ErrorMsg{Code: code, Text: text})}
37		}	37		}
38			38
39		func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64) (ports.Frame, error) {	39		func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64) (ports.Frame, error) {

@@ -48,13 +48,13 @@ func frameOutputState(b []byte, baseState uint64, state uint64, echoAck uint64)
48		}	48		}
49			49
50		func frameDetached(reason uint8) ports.Frame {	50		func frameDetached(reason uint8) ports.Frame {
51	-	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(ports.Detached{Reason: reason})}	51	+	return ports.Frame{Type: ports.MsgDetached, Payload: ports.MarshalDetached(protocol.Detached{Reason: reason})}
52		}	52		}
53			53
54		func framePong() ports.Frame {	54		func framePong() ports.Frame {
55	-	return ports.Frame{Type: ports.MsgPong, Payload: ports.MarshalPong(ports.Pong{})}	55	+	return ports.Frame{Type: ports.MsgPong, Payload: ports.MarshalPong(protocol.Pong{})}
56		}	56		}
57			57
58	-	func frameSessions(infos []ports.SessionInfo) ports.Frame {	58	+	func frameSessions(infos []protocol.SessionInfo) ports.Frame {
59	-	return ports.Frame{Type: ports.MsgSessions, Payload: ports.MarshalSessions(ports.Sessions{Sessions: infos})}	59	+	return ports.Frame{Type: ports.MsgSessions, Payload: ports.MarshalSessions(protocol.Sessions{Sessions: infos})}
60		}	60		}

M scripts/remote-picker-harness/main.go +25 -25


@@ -86,8 +86,8 @@ func runLiveStdioPhase(ctx context.Context, target string, catalog ports.RemoteC
86		return fmt.Errorf("open stdio transport: %w", err)	86		return fmt.Errorf("open stdio transport: %w", err)
87		}	87		}
88		defer func() { _ = stdio.Close() }()	88		defer func() { _ = stdio.Close() }()
89	-	if err := attachAndCheck(ctx, stdio, ports.Hello{	89	+	if err := attachAndCheck(ctx, stdio, protocol.Hello{
90	-	Intent: ports.IntentNew, Name: sessionName, Env: localEnvironment(), Cwd: "/tmp/local-cwd",	90	+	Intent: protocol.IntentNew, Name: sessionName, Env: localEnvironment(), Cwd: "/tmp/local-cwd",
91		TermEnv: "xterm-256color", TrueColor: true,	91		TermEnv: "xterm-256color", TrueColor: true,
92		}); err != nil {	92		}); err != nil {
93		return fmt.Errorf("stdio live attach: %w", err)	93		return fmt.Errorf("stdio live attach: %w", err)

@@ -177,8 +177,8 @@ func runLocalPickerUnitedPhase(ctx context.Context, target string, catalog ports
177		err = errors.Join(err, fmt.Errorf("destroy remote picker session: %w", cleanupErr))	177		err = errors.Join(err, fmt.Errorf("destroy remote picker session: %w", cleanupErr))
178		}	178		}
179		}()	179		}()
180	-	if err := attachAndCheck(ctx, remote, ports.Hello{	180	+	if err := attachAndCheck(ctx, remote, protocol.Hello{
181	-	Intent: ports.IntentNew, Name: remoteSession, Env: localEnvironment(), Cwd: "/tmp/remote-cwd",	181	+	Intent: protocol.IntentNew, Name: remoteSession, Env: localEnvironment(), Cwd: "/tmp/remote-cwd",
182		TermEnv: "xterm-256color", TrueColor: true,	182		TermEnv: "xterm-256color", TrueColor: true,
183		}); err != nil {	183		}); err != nil {
184		return fmt.Errorf("attach remote picker source: %w", err)	184		return fmt.Errorf("attach remote picker source: %w", err)

@@ -247,8 +247,8 @@ func runLocalPickerUnitedPhase(ctx context.Context, target string, catalog ports
247		// or MsgAttachTarget to this transport.	247		// or MsgAttachTarget to this transport.
248		local.probe.configure("local-picker")	248		local.probe.configure("local-picker")
249		defer func() { _ = local.Close() }()	249		defer func() { _ = local.Close() }()
250	-	if err := attachAndCheck(ctx, local, ports.Hello{	250	+	if err := attachAndCheck(ctx, local, protocol.Hello{
251	-	Intent: ports.IntentNew, Name: localSession, Env: localEnvironment(), Cwd: "/tmp/local-cwd",	251	+	Intent: protocol.IntentNew, Name: localSession, Env: localEnvironment(), Cwd: "/tmp/local-cwd",
252		TermEnv: "xterm-256color", TrueColor: true,	252		TermEnv: "xterm-256color", TrueColor: true,
253		}); err != nil {	253		}); err != nil {
254		return fmt.Errorf("attach local picker session: %w", err)	254		return fmt.Errorf("attach local picker session: %w", err)

@@ -351,10 +351,10 @@ func runRestartResumePhase(ctx context.Context, target string, catalog ports.Rem
351		return domain.RemoteSessionTarget{}, fmt.Errorf("open restart stdio transport: %w", err)	351		return domain.RemoteSessionTarget{}, fmt.Errorf("open restart stdio transport: %w", err)
352		}	352		}
353		defer func() { _ = resumed.Close() }()	353		defer func() { _ = resumed.Close() }()
354	-	if err := attachAndCheck(ctx, resumed, ports.Hello{	354	+	if err := attachAndCheck(ctx, resumed, protocol.Hello{
355	-	Intent: ports.IntentResume, Name: sessionName, Env: localEnvironment(), Cwd: "/tmp/local-cwd",	355	+	Intent: protocol.IntentResume, Name: sessionName, Env: localEnvironment(), Cwd: "/tmp/local-cwd",
356		TermEnv: "xterm-256color", TrueColor: true, RemoteTarget: &resumedTarget,	356		TermEnv: "xterm-256color", TrueColor: true, RemoteTarget: &resumedTarget,
357	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	357	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
358		}); err != nil {	358		}); err != nil {
359		return domain.RemoteSessionTarget{}, fmt.Errorf("exact restart resume: %w", err)	359		return domain.RemoteSessionTarget{}, fmt.Errorf("exact restart resume: %w", err)
360		}	360		}

@@ -385,8 +385,8 @@ func runUDPPhase(ctx context.Context, target string) error {
385		return fmt.Errorf("open UDP transport: %w", err)	385		return fmt.Errorf("open UDP transport: %w", err)
386		}	386		}
387		defer func() { _ = udp.Close() }()	387		defer func() { _ = udp.Close() }()
388	-	if err := attachAndCheck(ctx, udp, ports.Hello{	388	+	if err := attachAndCheck(ctx, udp, protocol.Hello{
389	-	Intent: ports.IntentNew, Name: "udp-harness", Env: localEnvironment(), Cwd: "/tmp/local-cwd",	389	+	Intent: protocol.IntentNew, Name: "udp-harness", Env: localEnvironment(), Cwd: "/tmp/local-cwd",
390		TermEnv: "xterm-256color", TrueColor: true,	390		TermEnv: "xterm-256color", TrueColor: true,
391		}); err != nil {	391		}); err != nil {
392		return fmt.Errorf("UDP attach: %w", err)	392		return fmt.Errorf("UDP attach: %w", err)

@@ -636,11 +636,11 @@ func openLocalTransport(ctx context.Context) (*harnessTransport, error) {
636		return h, nil	636		return h, nil
637		}	637		}
638			638
639	-	func attachAndCheck(ctx context.Context, tr *harnessTransport, hello ports.Hello) error {	639	+	func attachAndCheck(ctx context.Context, tr *harnessTransport, hello protocol.Hello) error {
640	-	hello.Version = ports.ProtocolVersion	640	+	hello.Version = protocol.Version
641		hello.Size = domain.Size{Cols: 80, Rows: 24}	641		hello.Size = domain.Size{Cols: 80, Rows: 24}
642		if hello.EnvironmentPolicy == 0 {	642		if hello.EnvironmentPolicy == 0 {
643	-	hello.EnvironmentPolicy = ports.EnvironmentPolicyClientOwned	643	+	hello.EnvironmentPolicy = protocol.EnvironmentPolicyClientOwned
644		}	644		}
645		payload := ports.MarshalHello(hello)	645		payload := ports.MarshalHello(hello)
646		if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {	646		if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {

@@ -668,7 +668,7 @@ func attachAndCheck(ctx context.Context, tr *harnessTransport, hello ports.Hello
668		}	668		}
669			669
670		func sendRawInput(tr *harnessTransport, data string) error {	670		func sendRawInput(tr *harnessTransport, data string) error {
671	-	return tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte(data)})})	671	+	return tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(data)})})
672		}	672		}
673			673
674		func processOutputFrame(tr *harnessTransport, frame ports.Frame) error {	674		func processOutputFrame(tr *harnessTransport, frame ports.Frame) error {

@@ -679,7 +679,7 @@ func processOutputFrame(tr *harnessTransport, frame ports.Frame) error {
679		result := tr.probe.apply(output)	679		result := tr.probe.apply(output)
680		if !result.Accepted {	680		if !result.Accepted {
681		if !tr.probe.resetPending {	681		if !tr.probe.resetPending {
682	-	if err := tr.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(ports.OutputResetRequest{})}); err != nil {	682	+	if err := tr.Send(ports.Frame{Type: ports.MsgOutputResetRequest, Payload: ports.MarshalOutputResetRequest(protocol.OutputResetRequest{})}); err != nil {
683		return err	683		return err
684		}	684		}
685		tr.probe.resetPending = true	685		tr.probe.resetPending = true

@@ -768,7 +768,7 @@ func remotePreviewContains(preview protocol.RemotePreview, want string) bool {
768		}	768		}
769			769
770		func sendInputAndAwait(ctx context.Context, tr *harnessTransport, command, want string) error {	770		func sendInputAndAwait(ctx context.Context, tr *harnessTransport, command, want string) error {
771	-	if err := tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(ports.Input{Data: []byte(command + "\n")})}); err != nil {	771	+	if err := tr.Send(ports.Frame{Type: ports.MsgInput, Payload: ports.MarshalInput(protocol.Input{Data: []byte(command + "\n")})}); err != nil {
772		return err	772		return err
773		}	773		}
774		deadline, cancel := context.WithTimeout(ctx, 5*time.Second)	774		deadline, cancel := context.WithTimeout(ctx, 5*time.Second)

@@ -795,8 +795,8 @@ func sendInputAndAwait(ctx context.Context, tr *harnessTransport, command, want
795			795
796		func sendCommand(ctx context.Context, tr *harnessTransport, slug string) error {	796		func sendCommand(ctx context.Context, tr *harnessTransport, slug string) error {
797		id := requestID.Add(1)	797		id := requestID.Add(1)
798	-	request := ports.CommandRequest{	798	+	request := protocol.CommandRequest{
799	-	Version: ports.ProtocolVersion,	799	+	Version: protocol.Version,
800		RequestID: id,	800		RequestID: id,
801		Attached: true,	801		Attached: true,
802		Slug: slug,	802		Slug: slug,

@@ -836,7 +836,7 @@ func sendCommand(ctx context.Context, tr *harnessTransport, slug string) error {
836		}	836		}
837			837
838		func detach(ctx context.Context, tr *harnessTransport) error {	838		func detach(ctx context.Context, tr *harnessTransport) error {
839	-	if err := tr.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(ports.Detach{})}); err != nil {	839	+	if err := tr.Send(ports.Frame{Type: ports.MsgDetach, Payload: ports.MarshalDetach(protocol.Detach{})}); err != nil {
840		return err	840		return err
841		}	841		}
842		deadline, cancel := context.WithTimeout(ctx, 5*time.Second)	842		deadline, cancel := context.WithTimeout(ctx, 5*time.Second)

@@ -859,9 +859,9 @@ func expectNoSuchTarget(ctx context.Context, tr *harnessTransport, target domain
859		if err := target.Validate(); err != nil {	859		if err := target.Validate(); err != nil {
860		return err	860		return err
861		}	861		}
862	-	hello := ports.Hello{	862	+	hello := protocol.Hello{
863	-	Version: ports.ProtocolVersion,	863	+	Version: protocol.Version,
864	-	Intent: ports.IntentResume,	864	+	Intent: protocol.IntentResume,
865		Name: sessionName,	865		Name: sessionName,
866		Size: domain.Size{Cols: 80, Rows: 24},	866		Size: domain.Size{Cols: 80, Rows: 24},
867		TermEnv: "xterm-256color",	867		TermEnv: "xterm-256color",

@@ -869,7 +869,7 @@ func expectNoSuchTarget(ctx context.Context, tr *harnessTransport, target domain
869		Env: localEnvironment(),	869		Env: localEnvironment(),
870		Cwd: "/tmp/local-cwd",	870		Cwd: "/tmp/local-cwd",
871		RemoteTarget: &target,	871		RemoteTarget: &target,
872	-	EnvironmentPolicy: ports.EnvironmentPolicyDaemonOwned,	872	+	EnvironmentPolicy: protocol.EnvironmentPolicyDaemonOwned,
873		}	873		}
874		payload := ports.MarshalHello(hello)	874		payload := ports.MarshalHello(hello)
875		if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {	875		if err := tr.Send(ports.Frame{Type: ports.MsgHello, Payload: payload}); err != nil {

@@ -886,7 +886,7 @@ func expectNoSuchTarget(ctx context.Context, tr *harnessTransport, target domain
886		if err != nil {	886		if err != nil {
887		return err	887		return err
888		}	888		}
889	-	if message.Code != ports.ErrNoSuchTarget {	889	+	if message.Code != protocol.ErrNoSuchTarget {
890		return fmt.Errorf("stale target returned error code %d", message.Code)	890		return fmt.Errorf("stale target returned error code %d", message.Code)
891		}	891		}
892		return nil	892		return nil