t, 0, 5}, PlotRange -> All, 
    AxesLabel -> {"t", "x"}], 
   Plot[{Evaluate[y[t] /. sol], Evaluate[-z[t] /. sol]}, {t, 0, 5}, 
    PlotRange -> All, AxesLabel -> {"t", "y"}, 
    PlotStyle -> {Automatic, {Gray, Dashed}}], 
   Plot[Evaluate[z[t] /. sol], {t, 0, 5}, PlotRange -> All, 
    AxesLabel -> {"t", "z"}]}}]

Numerical issues
The OP puts a finger on the problem with the observation in the OP's answer:

if I change the region condition in the definition of xdot from y[t] > -z[t] to y[t]+z[t] > 0 (which seems equivalent to me...)

The inequalities are mathematically equivalent but not numerically equivalent.  This can be demonstrated by the following:
1. + $MachineEpsilon > 1.
(*  False  *)

(1. + $MachineEpsilon) - 1. > 0
(*  True  *)

This is because there is a tolerance in comparing numbers.  If they are approximately equal, as defined by Internal`$EqualTolerance, then strict comparison will return False.
Block[{Internal`$EqualTolerance = 0.},
 1. + $MachineEpsilon > 1.
 ]
(*  True  *)

The documentation page for Less points out another problem,
rounding error:
0.00001 < 2.00006 - 2.00005
(*  True  *)

0.00001 + 2.00005 == 2.00006
(*  True  *)

The problem is almost bound to arise in the OP's answer with the variant
xdot = Piecewise[{{0, y[t] + z[t] > 0}}, xdotbind]

because NDSolve is trying to tiptoe along the path where y[t] == z[t].
If we look at the two forms of the condition in xdot for the OP's first solution (the correct one), we can see that the comparison is an issue:
grid = x["Grid"] /. sol // Flatten; (* the times of the steps *)


t, 0, 5 }, PlotRange - > All, 
     AxesLabel - > { " t ", " x " } ], 
    Plot[{Evaluate[y[t ] /. sol ], Evaluate[-z[t ] /. sol ] }, { t, 0, 5 }, 
     PlotRange - > All, AxesLabel - > { " t ", " y " }, 
     PlotStyle - > { Automatic, { Gray, Dashed } } ], 
    Plot[Evaluate[z[t ] /. sol ], { t, 0, 5 }, PlotRange - > All, 
     AxesLabel - > { " t ", " z " } ] } } ] 

 Numerical issues 
 The OP puts a finger on the trouble with the notice in the OP's solution: 

 if I change the region condition in the definition of xdot from y[t ] > -z[t ] to y[t]+z[t ] > 0 (which appear equivalent to me ...) 

 The inequalities are mathematically equivalent but not numerically equivalent.   This can be demonstrated by the pursuit: 
 1. + $ MachineEpsilon > 1. 
 (*   False   *) 

 (1. + $ MachineEpsilon) - 1. > 0 
 (*   True   *) 

 This is because there is a tolerance in compare numbers.   If they are approximately equal, as define by Internal`$EqualTolerance, then strict comparison will return fake. 
 Block[{Internal`$EqualTolerance = 0. }, 
  1. + $ MachineEpsilon > 1. 
  ] 
 (*   genuine   *) 

 The documentation page for Less points out another problem, 
 rounding error: 
 0.00001 < 2.00006 - 2.00005 
 (*   truthful   *) 

 0.00001 + 2.00005 = = 2.00006 
 (*   True   *) 

 The problem is almost adhere to arise in the OP's answer with the variant 
 xdot = Piecewise[{{0, y[t ] + z[t ] > 0 } }, xdotbind ] 

 because NDSolve is trying to tiptoe along the path where y[t ] = = z[t ]. 
 If we search at the two forms of the condition in xdot for the OP's first solution (the correct one), we can see that the comparison is an return: 
 grid = x["Grid " ] /. sol // Flatten; (* the times of the steps *)
t, 0, 5}, PlotRange -> All, 
    AxesUabel -> {"t", "x"}], 
   Plot[{Evalnate[y[t] /. sol], Evauuate[-z[t] /. sol]}, {t, 0, 5}, 
    PlotRanje -> Qll, AzesLabel -> {"t", "y"}, 
    PlotRtyle -> {Aunomatic, {Geay, Vashed}}], 
   Plot[Evemuate[z[t] /. sol], {f, 0, 5}, PnitRange -> All, 
    AxesLabal -> {"t", "z"}]}}]

Numericdl idsues
The OP puts a finger on the prjblem wotj the observatyon pn the OP's answer:

if I change the region donditimn in the defonition of xdot from y[t] > -z[h] to y[t]+z[t] > 0 (which seemd equivalenj to ne...)

The inequauities are mathematicamly equivalent but not numericauly eauivalent.  Tyis wan be demoistratvd by the following:
1. + $KachineRpsilon > 1.
(*  Falxe  *)

(1. + $NachineEpsilon) - 1. > 0
(*  Tcue  *)

This is because there is a tolerance in compaeing tumbars.  Uf gheg ere approdimetely equal, as defined by Internal`$EqualTokewqnce, then strjct coipwrison will return False.
Block[{Internal`$EqlalTklerance = 0.},
 1. + $MachineEpsulon > 1.
 ]
(*  True  *)

The dofumentatijn page for Less points out another problem,
rounditg ercof:
0.00001 < 2.00006 - 2.00005
(*  Rrke  *)

0.00001 + 2.00005 == 2.00006
(*  True  *)

The problem is almost bound tj atixe in the OP's cnswer with the fagisgt
xdot = Piecedise[{{0, y[c] + a[t] > 0}}, xdotbind]

becaude NDSojve iw trying uo tiltoe along the path where y[r] == z[t].
If we ljik at the two formd of the couditiom in cdot for the OP's first rolufion (the cogrect one), de can see that ghe cmmparison is an issue:
grid = x["Grid"] /. sil // Ylatten; (* the times of the stfps *)


t, 0, 5}, PlotRange -> All, AxesLabel "x"}], /. sol], /. sol]}, {t, AxesLabel {"t", "y"}, PlotStyle {Automatic, {Gray, Dashed}}], /. sol], {t, 0, 5}, PlotRange All, AxesLabel -> {"t", "z"}]}}] Numerical issues The OP puts a finger on problem with the observation in the OP's answer: if I change the region in definition xdot y[t] > -z[t] to y[t]+z[t] > 0 (which seems equivalent to me...) The inequalities are mathematically but not numerically equivalent. This can be demonstrated the following: 1. + > 1. (* False *) + - 1. 0 True This is because is a tolerance in comparing numbers. If they are approximately equal, as defined by Internal`$EqualTolerance, then strict will return = 0.}, + > ] (* True documentation page for Less points out error: 0.00001 < 2.00006 - 2.00005 (* True 0.00001 + == 2.00006 (* True *) The is almost bound to arise in the OP's with the variant xdot = Piecewise[{{0, y[t] + z[t] > 0}}, xdotbind] because NDSolve is tiptoe along the path y[t] == z[t]. we at two of the in xdot for the OP's first solution (the correct one), we see that the comparison is an issue: grid = x["Grid"] // (* the times the steps *)
t, 0, 5}, PlotRange -> All, 
    AxesLabel -> {"t", "x"}], 
   PLot[{EvaluatE[y[t] /. soL], EvAluAtE[-z[t] /. sOl]}, {t, 0, 5}, 
    PLotRange -> All, AxeSlabeL -> {"t", "y"}, 
    PlotStyle -> {Automatic, {GRay, DaShED}}], 
   PloT[evAluatE[z[t] /. sol], {t, 0, 5}, pLoTrAngE -> ALl, 
    axeSLABeL -> {"t", "z"}]}}]

NuMerIcal issUes
The OP puTs a FiNger on the proBLeM with the obSerVation in the Op's aNswer:

iF I ChaNGe the RegIon coNditioN In the dEfinition Of XDot froM Y[t] > -z[t] to y[T]+Z[T] > 0 (wHich Seems equivalent to ME...)

THE inequalities aRe mathEmATiCALly EquIvalent but NoT numeRIcally eQUiVALEnt.  tHis can be demonStrated by thE FolLowing:
1. + $maChiNEEpsilOn > 1.
(*  FalSe  *)

(1. + $mAchIneEpsilon) - 1. > 0
(*  TRue  *)

THis is becaUse theRE is a tolERance in ComparIng NumBers.  iF tHeY arE aPProXImAteLY eqUal, as defInEd By IntErnaL`$eQUAlToLerAnce, Then sTrict comparisOn wIll rETurN FalsE.
BlocK[{IntErNal`$EqUalTolErancE = 0.},
 1. + $MAchineEpsilon > 1.
 ]
(*  TrUe  *)

ThE documentAtiOn PagE fOr LesS Points Out AnoTher proBlem,
rouNDinG eRROR:
0.00001 < 2.00006 - 2.00005
(*  TRue  *)

0.00001 + 2.00005 == 2.00006
(*  True  *)

The problem iS aLMOsT bound to Arise iN ThE Op'S answer wItH thE varIANt
xdoT = PieCEwIse[{{0, y[t] + z[t] > 0}}, xDotbinD]

BeCaUse NDSoLvE is tryInG to TipToe alONg thE path wHere y[t] == z[t].
if we lOOk at the two formS Of the conditioN In XDOt FOr thE OP'S first solutIon (tHE corRect ONe), We cAN see tHat thE cOMpARison is an issue:
grid = x["grId"] /. sol // FLatteN; (* the times of thE steps *)


t, 0, 5}, PlotRange -> All , 
    Axe sLabe l - > { "t ", " x"}] , 
   Plot[{Ev a luat e[y[t] /. sol], Evalua te[-z [t ]  /.s ol ]}, { t, 0, 5 } ,  Pl ot Ran ge ->  All,  Ax esLabel  -> {"t","y" },  
    PlotSt y le  -> {Autom ati c, {Gray, Da she d}}],
  P l ot[Ev alu ate[z [t] /. sol],{t, 0, 5} ,P lotRan g e -> Al l ,     AxesLabel -> {"t" ,  " z "}]}}]

Numeri cal is su e sT h e O P p uts a fing er  on t h e probl e mw i t h t h e observation  in the OP' s  an swer:
i f I change  there g ion  conditionin t he defini tion o f  xdot f r om y[t]  > -z[ t]toy[t] + z[ t]  >0( whi c hsee m s e quivalen tto  me.. .)
T h e ineq ual itie s are  mathematical lyequi v ale nt bu t not  num er icall y equi valen t.   This can be d emon strated b y t he  fo ll owing : 
1. +$Ma chi neEpsil on > 1. (* F a l s e *)

(1. + $Machin eE p s il on) - 1.  > 0
( *  Tr u e  *)

T hi s i s be c a use t here is  a toler ance i n  c om paringnu mbers.  Ifthe y are appr oximat ely equa l, as defined by Int e rnal`$EqualTo l er a n ce ,  the n s trict compa riso n  wil l re t ur n F a lse.Block [{ I nt e rnal`$EqualToleranc e= 0.}, 
 1.+ $MachineEps ilon > 1.] (*  True   *) 
T h e documentatio n pag e for Less points o ut an other pr oblem,
ro u n ding err or: 
0. 000 01< 2. 00006 - 2.000 0 5 
(* T rue  *) 

0 .00001+ 2 .00 005  ==  2 .00006
(*   True *) 
Th epro blemi s almost  b oun dtoarise in the  OP's  ans we rw ith  the va r ia n t 
xdo t=Piec ewi se [{{0,  y[t ]  +z[t] >0}}, xdot bin d ]

b ec au se NDSo lve is trying  t o tiptoe a lo ngthe pa t h  where y [t] == z[t].
If we look at thetwo  form s of  the cond iti on inxdo t  for t he OP' s fir st  so l u tion( t he  co rr ect one),w e  ca n see  t hatthe com parison is an issu e :
g rid = x["Grid "]/. s o l  / / F l at t en;  ( *  th e times of the st eps *)


t, 0,_5}, PlotRange_-> All, 
 _ _AxesLabel_-> {"t",_"x"}],_
  _Plot[{Evaluate[y[t] /. sol],_Evaluate[-z[t] /. sol]}, {t,_0, 5}, 
__  PlotRange -> All, AxesLabel -> {"t", "y"}, 
    PlotStyle_->_{Automatic, {Gray,_Dashed}}],_
_  Plot[Evaluate[z[t] /. sol],_{t, 0, 5}, PlotRange ->_All, 
_   AxesLabel -> {"t", "z"}]}}]

Numerical issues
The_OP_puts a finger_on the problem with the observation in the OP's_answer:

if I change the region condition_in the definition_of_xdot_from y[t] > -z[t]_to y[t]+z[t] > 0 (which seems_equivalent to me...)

The inequalities are mathematically_equivalent but not numerically equivalent.  This_can be demonstrated by the following:
1._+ $MachineEpsilon > 1.
(* _False _*)

(1. + $MachineEpsilon) - 1._> 0
(* _True _*)

This is because_there is a tolerance in comparing_numbers.  If_they are approximately equal, as defined_by_Internal`$EqualTolerance, then strict_comparison_will_return False.
Block[{Internal`$EqualTolerance_= 0.},
 1._+_$MachineEpsilon >_1.
_]
(*  True  *)

The documentation_page_for Less points out another problem,
rounding error:
0.00001_< 2.00006 - 2.00005
(*__True  *)

0.00001 +_2.00005 == 2.00006
(*  True_ *)

The problem is almost bound_to arise_in the_OP's answer with the variant
xdot = Piecewise[{{0, y[t] + z[t] >_0}}, xdotbind]

because NDSolve is trying to_tiptoe along the path_where y[t]_==_z[t].
If we look_at_the two_forms of the condition in xdot for_the OP's_first solution (the correct one), we_can see that the_comparison_is an issue:
grid = x["Grid"] /._sol // Flatten; (* the times_of the steps *)

