How do you say when a language is Turing-complete only in a trivial way?
Untyped or simply-typed lambda-calculus is Turing-complete even with no booleans at all. Adding more stuff in the language, such as boolean constants and a boolean base types, cannot make the language less powerful, therefore it is still Turing-complete.

“Turing-complete” means that there is some “reasonable encoding” under which the language can express arbitrary computations. “Reasonable encoding” is not a formal notion; what it really means is that you must say what you consider to be computation, and how natural integers are to be encoded. For example, in the lambda-calculus, computation is beta reduction, and one possible encoding of natural integers is Church numerals.

In the simply-typed lambda calculs, there are no booleans as a built-in notion, but they can be encoded:
$$\begin{align}
  \mathsf{true}_\tau &amp;:= \lambda x\colon\tau. \lambda y\colon\tau. x \\
  \mathsf{false}_\tau &amp;:= \lambda x\colon\tau. \lambda y\colon\tau. x \\
  \mathsf{ifthenelse}_\tau &amp;:= \lambda f\colon\tau. \lambda g\colon\tau. \lambda b\colon(\tau\rightarrow\tau\rightarrow\tau). b \, f \, g \\
\end{align}$$

The lambda calculus with boolean constants but no corresponding destructor¹ nor any way to encode it (such as a polymorphic equality construct) does lack expressive power in a sense, but only in that it is unable to distinguish between the two boolean values. It isn't the language's computational power which is at state, but the particular encoding of booleans as the boolean constants you picked: the boolean data structure is not implemented correctly. In fact, that language does not have any boolean data structures: it has constants that you chose to call “true” and “false”, but that doesn't make them booleans given the lack of a destructor.

Consider a variant where you define the following constructors and destructor:
$$
  \dfrac{}{\Gamma \vdash \mathsf{dog} : \mathsf{daisy}} \qquad
  \dfrac{}{\Gamma \vdash \mathsf{cat} : \mathsf{daisy}} \qquad
  \dfrac{\Gamma \vdash M : \mathsf{daisy} \quad \Gamma \vdash N_0 : \tau \quad \Gamma \vdash N_1 : \tau}{\Gamma \vdash \mathsf{cheese}(M, N_0, N_1) : \tau} \\
  \dfrac{}{\Gamma \vdash \mathsf{true} : \mathsf{boolean}} \qquad
  \dfrac{}{\Gamma \vdash \mathsf{false} : \mathsf{boolean}}
$$
and the following reduction rules:
$$\begin{align}
  \mathsf{cheese}(\mathsf{dog},M,N) &amp;\to M \\
  \mathsf{cheese}(\mathsf{cat},M,N) &amp;\to N \\
\end{align}$$

This language has an encoding of the booleans as the type $\mathsf{daisy}$, with $\mathsf{cat}$ and $\mathsf{dog}$ as the constructors and $\mathsf{cheese}$ as the destructor. The type $\mathsf{boolean}$ is not a boolean type: it's just some type that happens to have two values (which are undistinguishable).

A “typed lambda calculus with booleans [without] that conditional operator” is a Turing-complete language that doesn't have booleans.

¹  A destructor in a typed calculus is a term such that a type constructor appears in the premises of its typing rules but not in the type of its conclusion. If/then/else is a destructor for booleans.