Python 2, 111 109 bytes

lambda S,T:(min(map(len,map(set,zip(*S))))>1,date.today().year in sorted(set(T))[1:-1])

from datetime import*

Try it online!

Perl 6, 47 46 bytes

-1 byte thanks to nwellnhof

{Set(@^b X<=>Date.today.year)>2,max [Z==] @^a}

Try it online!

Anonymous code block that takes two lists and returns a tuple of booleans, with the first element being whether you traveled in time, and the second being whether you didn't traveled in space.

Explanation

{                                            }  # Anonymous code block

     @^b X         # Map each element of the year list to:

          <=>      # Whether it is smaller, equal or larger than

             Date.today.year  # The current year

 Set(                       )    # Get the unique values

                             >2  # Is the length larger than 2?

                               ,

                                    [Z  ] @^a   # Reduce by zipping the lists together

                                max       # And return if any of them are

                                      ==  # All equal

Japt, 22 bytes

Takes input as a 2D-array of integers for the space dimensions and a 1D-array of integers for the years. Outputs 2 for space only, 1 for time only, 3 for both and 0 for neither.

yâ mÊeÉ Ñ+!Jõ kVmgKi¹Ê

Try it

                           :Implicit input of 2D-array U=space and array V=time

y                          :Transpose U

 â                         :Deduplicate columns

   m                       :Map

    Ê                      :  Lengths

     e                     :All truthy (not 0) when

      É                    :  1 is subtracted

        Ñ                  :Multiply by 2

           J               :-1

            õ              :Range [-1,1]

              k            :Remove all the elements present in

               Vm          :  Map V

                 g         :    Signs of difference with

                  Ki       :    The current year

                    ¹      :End removal

                     Ê     :Length

         +!                :Negate and add first result

05AB1E, 15 bytes

Output is a list [space, time] where 1 stands for x and 0 stands for no x

ø€Ë_Psžg.SÙg3Q)

Try it online!

Explanation

    ø                 # zip space coordinates

     €Ë               # for each axis, check that all values are equal

       _              # logical negation

        P             # product (1 for space, 0 for no space)

         s            # put the time list on top of the stack

          žg.S        # compare each with the current year

              Ù       # remove duplicates

               g3Q    # check if the length is 3

                  )   # wrap the space and time values in a list

Japt, 25 bytes

I'm 100% sure this is not the best approach, still looking for some shorter way to do this :c

Returns a tuple of booleans. The first is if you traveled in space and the second if you traveled in time

[Uyâ e_ʦ1ÃV®-Ki)gÃâ Ê¥3]

[Uyâ e_ʦ1ÃV®-Ki)gÃâ Ê¥3]   Full Program, U = Space, V = Time

                            -- U = [[-2,-2,-2], [-3,-3,-3]]

                            -- V = [2020, 1991, 2014, 2018]

[                       ]   Return array containing....

 Uyâ                        Transpose Space coords 

                            -- U = [[-2,-3], [-2,-3], [-2,-3]]

                            and map Z   

      _ʦ1                  Z length greater than 1?

                            -- U = [true, true, true]

     e                      return true if all Z are true   

                            -- U = true

          V®                Map each time

            -Ki)            Subtract current year   

                            -- V = [2,-27,-4,0]

                gà         get sign (-1,0,1)

                            -- V = [1,-1,-1,0]

                   â        unique elements

                            -- V = [1,-1,0]

                     ʥ3    return true if length == 3

                            -- V = true

Try it online!

JavaScript (ES6), 104 100 bytes

Takes input as (space)(time). Returns $1$ for time, $2$ for space, $3$ for both or $0$ for neither.

24% of the code is spent figuring out in which year we are ... o/

s=>t=>2*s[0].every((x,i)=>s.some(b=>x-b[i]))|t.some(y=>(s|=(y/=(new Date).getFullYear())>1?4:y+1)>6)

Try it online!

Commented

s => t =>              // s = space array; t = time array

  2 *                  // the space flag will be doubled

  s[0].every((x, i) => // for each coordinate x at position i in the first entry of s:

    s.some(b =>        //   for each entry b in s:

      x - b[i]         //     if we've found b such that b[i] != x, the coordinate is valid

    )                  //   end of some()

  )                    // end of every()

  |                    // bitwise OR with the time flag

  t.some(y =>          // for each year y in t:

    (s |=              //   update the bitmask s (initially an array, coerced to 0)

      ( y /=           //     divide y

        (new Date)     //     by the current year (this is safe as long as no time-travel

        .getFullYear() //     machine is available to run this it at year 0)

      ) > 1 ?          //   if the result is greater than 1:

        4              //     do s |= 4 (future)

      :                //   else:

        y + 1          //     do s |= y + 1; y + 1 = 2 if both years were equal (present)

                       //     otherwise: y + 1 is in [1, 2), which is rounded to 1 (past)

    ) > 6              //   set the time flag if s = 7

  )                    // end of some()

R, 106, 105 bytes

function(s,t)all((x<-apply(s,1,range))[1,]-x[2,])-2*all((-1:1)%in%sign(as.POSIXlt(Sys.Date())$ye+1900-t))

Try it online!

Input :

s : matrix of space coordinates (3 x N)

t : vector time years 

Output an integer value equal to :

 1 : if traveled through space only

-2 : if traveled through time only

-1 : if traveled through space and time

 0 : if traveled neither through space nor time

Batch, 353 bytes

@echo off

set/as=t=0,y=%date:~-4%

for %%a in (%*) do call:c %~1 %%~a

if %s%==7 (if %t%==7 (echo both)else echo space)else if %t%==7 (echo time)else echo neither

exit/b

:c

if "%6"=="" goto g

if %1 neq %4 set/as^|=1

if %2 neq %5 set/as^|=2

if %3 neq %6 set/as^|=4

exit/b

:g

if %4 lss %y% (set/at^|=1)else if %4==%y% (set/at^|=2)else set/at^|=4

Note: Since commas are argument separators in Batch, in order to input the space coordinates you need to quote then e.g.

spacetime "5,7,2" "5,3,8" "-6,3,8" "5,7,2" 2000 2002

Explantion:

@echo off

Turn off unwanted output.

set/as=t=0,y=%date:~-4%

Set up two bitmasks and also extract the current year. (In YYYY-MM-DD locales use %date:~,4% for the same byte count.)

for %%a in (%*) do call:c %~1 %%~a

Loop over all the arguments. The ~ causes coordinate values to be split into separate parameters.

if %s%==7 (if %t%==7 (echo both)else echo space)else if %t%==7 (echo time)else echo neither

exit/b

Check whether the bitmasks are fully set and output the appropriate result.

:c

if "%6"=="" goto g

See whether this is a pair of coordinates or a coordinate and a year.

if %1 neq %4 set/as^|=1

if %2 neq %5 set/as^|=2

if %3 neq %6 set/as^|=4

exit/b

If it's a coordinate then update the space bitmask according to whether the relevant spacial dimension was visited.

:g

if %4 lss %y% (set/at^|=1)else if %4==%y% (set/at^|=2)else set/at^|=4

If it's a year then update the time bitmask according to whether the relevant time dimension was visited.

Java 10, 154 bytes

s->t->{int y=java.time.Year.now().getValue(),c=0,d=1,i=3;for(;i-->0;d*=c,c=0)for(var l:s)c=l[i]!=s[0][i]?1:c;for(int a:t)c|=a>y?4:a<y?1:2;return c/7*2+d;}

Returns 1 for space, 2 for time, 3 for both, 0 for neither. Try it online here.

Ungolfed:

s -> t -> { // lambda taking two parameters in currying syntax

            // s is int, t is int; return type is int



    int y = java.time.Year.now().getValue(), // the current year

        c = 0, // auxiliary variable used for determining both space and time

        d = 1, // initally, assume we have moved in all three space dimensions

        i = 3; // for iterating over the three space dimensions



    for(; i -- > 0; d *= c, c = 0) // check all coordinates for each dimension, if we have not moved in one of them, d will be 0

        for(var l : s) // check the whole list:

            c = l[i] != s[0][i] ? 1 : c; // if one coordinate differs from the first, we have moved



    for(int a : t) // look at all the years; c is 0 again after the last loop

        c |= a > y ? 4 : a < y ? 1 : 2; // compare to the current year, setting a different bit respectively for past, present and future



    return c / 7 // if we have been to past, the present and the future ...

           * 2   // ... return 2 ...

           + d;  // ... combined with the space result, otherwise return just the space result

}