(This is particularly annoying when one wants to have a class decorator, which it seems must have a bound somewhere in the vicinity of Type, that validates something about the constructor of the type it's decorating...)

Constructors (and, in Python, initializers) are generally seen as irrelevant to LSP, because LSP concerns the properties of constructed objects; if a subclass has an incompatible signature with a superclass, that's basically outside the scope of LSP.

If you can declare __init__ on Protocols, shouldn't implementations have to match, at least when assigned as Types?

I believe the reason why this is allowed is to enable patterns such as the following. In this snippet, Abstract does not have to be explicitly subclassed in order for Concrete to be considered a subtype of Abstract. But classes who do subclass Abstract are allowed to call super().__init__() and use the implementation of Abstract.__init__() in Concrete.__init__().

from typing import Protocol

class Abstract(Protocol):
    foo: str
    def __init__(self, foo: str) -> None:
        self.foo = foo

class Concrete(Abstract):
    def __init__(self, foo: str, bar: int) -> None:
        super().__init__(foo)
        self.bar = bar

This is a duplicate of #3823 (also see exactly the point about Type[...] in the original issue). FWIW I agree with this, just never had time for this.