You’re very close — this is a classic case of "the generic parameter is not flowing through the subclass hierarchy".

What’s going wrong

The key issue is here:

class DirManager(Manager[Dir]):
create = Dir

By inheriting from Manager[Dir], you are freezing T = Dir for all subclasses of DirManager.
So even though GitManager creates Git, the generic parameter is still Dir, and that’s why:

reveal_type(GitManager().create2())

tuple[Dir, Dir]

Type checkers are doing exactly what the type hierarchy tells them to do.

✅ Correct pattern: make the intermediate class generic too

You want the generic parameter to remain open until the leaf class.

from future import annotations
from typing import Generic, TypeVar

class Dir:
def walk(self) -> None: print("Dir")

class Git(Dir):
def walk(self) -> None: print("Git")
def commit(self) -> None: print("Commit")

T = TypeVar("T", bound=Dir)

class Manager(Generic[T]):
def create(self) -> T:
raise NotImplementedError

def create2(self) -> tuple[T, T]:
 return self.create(), self.create()

🔑 Make DirManager generic instead of fixing T
class DirManager(Manager[T], Generic[T]):
pass

Concrete leaf classes finally bind the type
class GitManager(DirManager[Git]):
def create(self) -> Git:
return Git()

✅ Result (what you want)
from typing import reveal_type

reveal_type(GitManager().create())

reveal_type(GitManager().create2())

tuple[Git, Git]

This works correctly in mypy, pyright, and pyre.

Why this works

Manager[T] defines behavior

DirManager[T] preserves the generic parameter

GitManager finally binds T = Git

create2() stays fully generic and does not need to be overridden

This is the same pattern used by the standard library (collections, typing, asyncio, etc.).

About ClassVar[type[T]]

You’re also correct that:

create: ClassVar[type[T]]

is rejected by pyright/pyre — that’s intentional and specified behavior.
ClassVar cannot contain TypeVars, because it would imply per-instance specialization of a class attribute, which Python’s type system does not support.

Using a normal method override (as above) is the correct and portable solution.