This seems reasonable to me, && and ! are just operations. There"s no requirement that their terms are bools, or that they return bools:

abstract A(String) from String to String {
    @:op(A && B) public static function and(a:A, b:A):A {
        return (a == "true" && b == "true") ? "true" : "false";
    }

    @:op(!A) public static function neg(a:A):A {
        return a == "true" ? "false" : "true";
    }
}

class Test {
    static function main() {
        var a:A = "true";
        var b:A = "false";
        trace(a && a);
        trace(a && b);
        trace(!a);
        trace(!b);
    }
}

(And OTOH there is a requirement that an if condition is a bool, so the whole expression is coerced to one.)

I"m using this in one case to overload || for a custom type as syntactic sugar.

I thought it"s a specified behaviour. Unless you define operators overloading for an abstract, you can"t use that abstract with those operators.

If there"s no @:op overloads involved, &&, || and ! should be boolean logic ops, right? So it makes sense to try coercing operands to bool and trigger abstracts casts.

If there are @:op overloads, we should of course use those, so @RealyUniqueName"s example should evaluate to false ((1 != 0) != true).

@nadako has a point here - in all other positions where exactly one type is expected, the conversions are triggered - so why not with operators that aren"t overloaded themselves? They"re just like unary or binary functions with infix notation in those cases.
It gets more tricky when the operator is already overloaded, like + - should toInt, toFloat, toString be triggered there? One can argue that these operators aren"t just like functions, because we don"t have function overloading, and hence the same rules can"t apply. So the question is: should all operators be treated specially in that they don"t trigger conversions (like now), or should there be certain criteria when to trigger, e.g. whether the respective operator is "natively" overloaded, or should all operators trigger conversions, and how would that be specified?