specfact-cli 0.46.9__tar.gz → 0.46.17__tar.gz

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfact-cli
-Version: 0.46.9
+Version: 0.46.17
 Summary: The swiss knife CLI for agile DevOps teams. Keep backlog, specs, tests, and code in sync with validation and contract enforcement for new projects and long-lived codebases.
 Project-URL: Homepage, https://github.com/nold-ai/specfact-cli
 Project-URL: Repository, https://github.com/nold-ai/specfact-cli.git

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "specfact-cli"
-version = "0.46.9"
+version = "0.46.17"
 description = "The swiss knife CLI for agile DevOps teams. Keep backlog, specs, tests, and code in sync with validation and contract enforcement for new projects and long-lived codebases."
 readme = "README.md"
 requires-python = ">=3.11"

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/__init__.py

@@ -3,4 +3,4 @@ SpecFact CLI - Spec→Contract→Sentinel tool for contract-driven development.
 """
 
 # Package version: keep in sync with pyproject.toml, setup.py, src/specfact_cli/__init__.py
-__version__ = "0.46.9"
+__version__ = "0.46.17"

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/specfact_cli/__init__.py

@@ -45,6 +45,6 @@ def _bootstrap_bundle_paths() -> None:
 
 _bootstrap_bundle_paths()
 
-__version__ = "0.46.9"
+__version__ = "0.46.17"
 
 __all__ = ["__version__"]

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/specfact_cli/cli.py

@@ -14,7 +14,7 @@ from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Annotated, Any, cast
+from typing import Annotated, Any, NoReturn, cast
 
 
 _DetectShellFn = Callable[..., tuple[str | None, str | None]]
@@ -532,6 +532,84 @@ def _lazy_delegate_cmd_name_ready(self: _LazyDelegateGroup) -> bool:
     return len(self._lazy_cmd_name) > 0
 
 
+def _args_request_help(args: tuple[str, ...] | list[str]) -> bool:
+    """Return True when delegated args are asking only for command help."""
+    return any(arg in ("--help", "-h", "--help-advanced", "-ha") for arg in args)
+
+
+def _delegated_help_path(cmd_name: str, args: tuple[str, ...] | list[str]) -> str:
+    """Build a stable command path for fallback help output."""
+    path_parts = [cmd_name]
+    for arg in args:
+        if arg.startswith("-"):
+            continue
+        path_parts.append(arg)
+    return " ".join(path_parts)
+
+
+def _print_lazy_help_fallback(cmd_name: str, args: tuple[str, ...] | list[str]) -> None:
+    """Print minimal help when Typer cannot materialize a command for a loaded bundle."""
+    command_path = _delegated_help_path(cmd_name, args)
+    get_configured_console().print(
+        f"[bold]{command_path}[/bold]\n\n"
+        "Help is available for this installed command path, but the command metadata could not be "
+        "materialized in this runtime. Reinstall the providing module or run the command without "
+        "`--help` to execute it."
+    )
+
+
+def _raise_lazy_delegate_click_exception(exc: Exception) -> NoReturn:
+    raise click.ClickException(str(exc)) from exc
+
+
+def _load_lazy_delegate_typer(cmd_name: str) -> typer.Typer:
+    resolved_name = resolve_command(cmd_name)
+    try:
+        return CommandRegistry.get_typer(resolved_name)
+    except ValueError as exc:
+        if cmd_name in KNOWN_BUNDLE_GROUP_OR_SHIM_NAMES:
+            _print_missing_bundle_command_help(cmd_name)
+            raise SystemExit(1) from None
+        _raise_lazy_delegate_click_exception(exc)
+        raise AssertionError("unreachable") from None
+
+
+def _build_lazy_delegate_click_command(cmd_name: str, args: tuple[str, ...], real_typer: typer.Typer) -> click.Command:
+    from typer.main import get_command
+
+    try:
+        return get_command(real_typer)
+    except (RuntimeError, ValueError) as exc:
+        if _args_request_help(args):
+            _print_lazy_help_fallback(cmd_name, args)
+            raise SystemExit(0) from None
+        _raise_lazy_delegate_click_exception(exc)
+        raise AssertionError("unreachable") from None
+
+
+def _lazy_delegate_prog_name(ctx: click.Context, cmd_name: str) -> str:
+    parts: list[str] = []
+    parent = ctx.parent
+    while parent and getattr(parent, "command", None):
+        name = getattr(parent.command, "name", None)
+        if name and name != "__delegate__":
+            parts.append(name)
+        parent = getattr(parent, "parent", None)
+    if parts:
+        return " ".join(reversed(parts))
+    original_prog_name = ctx.meta.get("original_prog_name")
+    if isinstance(original_prog_name, str) and original_prog_name:
+        return original_prog_name
+    return cmd_name
+
+
+def _strip_redundant_single_command_arg(click_cmd: click.Command, args: tuple[str, ...]) -> list[str]:
+    args_list = list(args)
+    if not isinstance(click_cmd, click.Group) and args_list and args_list[0] == getattr(click_cmd, "name", None):
+        return args_list[1:]
+    return args_list
+
+
 class _LazyDelegateGroup(click.Group):
     """Click Group that delegates all args to the real command (lazy-loaded)."""
 
@@ -544,6 +622,8 @@ class _LazyDelegateGroup(click.Group):
             name=name or cmd_name,
             help=help or help_str,
             context_settings={"ignore_unknown_options": True},
+            invoke_without_command=True,
+            no_args_is_help=False,
         )
         self._lazy_cmd_name = cmd_name
         self._lazy_help_str = help_str
@@ -553,31 +633,15 @@ class _LazyDelegateGroup(click.Group):
         cmd_name = self._lazy_cmd_name
 
         def _invoke(args: tuple[str, ...]) -> None:
-            from typer.main import get_command
-
             ctx = click.get_current_context()
-            resolved_name = resolve_command(cmd_name)
-            real_typer = CommandRegistry.get_typer(resolved_name)
-            click_cmd = get_command(real_typer)
+            real_typer = _load_lazy_delegate_typer(cmd_name)
+            click_cmd = _build_lazy_delegate_click_command(cmd_name, args, real_typer)
             # Build full prog name from root (e.g. "specfact sync") so usage shows "specfact sync bridge", not "sync sync bridge"
-            parts: list[str] = []
-            p = ctx.parent
-            while p and getattr(p, "command", None):
-                name = getattr(p.command, "name", None)
-                if name and name != "__delegate__":
-                    parts.append(name)
-                p = getattr(p, "parent", None)
-            prog_name = " ".join(reversed(parts)) if parts else cmd_name
-            args_list = list(args)
+            prog_name = _lazy_delegate_prog_name(ctx, cmd_name)
             # When the real app is a single command (e.g. drift has only "detect"), Typer
             # builds a TyperCommand, not a Group. Then args are ["detect", "bundle", "--repo", ...]
             # and the command expects ["bundle", "--repo", ...] (no leading "detect").
-            if (
-                not isinstance(click_cmd, click.Group)
-                and args_list
-                and args_list[0] == getattr(click_cmd, "name", None)
-            ):
-                args_list = args_list[1:]
+            args_list = _strip_redundant_single_command_arg(click_cmd, args)
             exit_code = click_cmd.main(args=args_list, prog_name=prog_name, standalone_mode=False)
             if exit_code and exit_code != 0:
                 raise SystemExit(exit_code)
@@ -590,6 +654,14 @@ class _LazyDelegateGroup(click.Group):
             add_help_option=False,  # Pass --help through to real Typer so "specfact backlog daily ado --help" shows correct usage
         )
 
+    @require(lambda ctx: ctx is not None, "ctx must not be None")
+    @ensure(lambda result: result is None or isinstance(result, int), "result must be None or an exit code")
+    def invoke(self, ctx: click.Context) -> Any:
+        if ctx.invoked_subcommand is None and not ctx.args:
+            ctx.meta["original_prog_name"] = ctx.command_path
+            return self._delegate_cmd.main(args=[], prog_name=ctx.command_path, standalone_mode=False)
+        return super().invoke(ctx)
+
     @require(_lazy_delegate_cmd_name_ready, "lazy command name must be set")
     @ensure(lambda result: isinstance(result, tuple) and len(result) == 3, "result must be a 3-tuple")
     def resolve_command(
@@ -597,7 +669,7 @@ class _LazyDelegateGroup(click.Group):
     ) -> tuple[str | None, click.Command | None, list[str]]:
         # Pass through all args to the delegate so "plan init bundle" becomes args for the real plan Typer.
         if not args:
-            return None, None, []
+            return self._delegate_cmd.name, self._delegate_cmd, []
         return self._delegate_cmd.name, self._delegate_cmd, list(args)
 
     @ensure(lambda result: isinstance(result, list), "result must be a list of command names")
@@ -621,8 +693,11 @@ class _LazyDelegateGroup(click.Group):
         from typer.main import get_command
 
         resolved_name = resolve_command(self._lazy_cmd_name)
-        real_typer = CommandRegistry.get_typer(resolved_name)
-        click_cmd = get_command(real_typer)
+        try:
+            real_typer = CommandRegistry.get_typer(resolved_name)
+            click_cmd = get_command(real_typer)
+        except (RuntimeError, ValueError):
+            return None
         if isinstance(click_cmd, click.Group):
             return click_cmd
         return None
@@ -633,8 +708,11 @@ class _LazyDelegateGroup(click.Group):
         from typer.main import get_command
 
         resolved_name = resolve_command(self._lazy_cmd_name)
-        real_typer = CommandRegistry.get_typer(resolved_name)
-        click_cmd = get_command(real_typer)
+        try:
+            real_typer = CommandRegistry.get_typer(resolved_name)
+            click_cmd = get_command(real_typer)
+        except (RuntimeError, ValueError):
+            return
         prog_name = (
             f"{ctx.parent.command.name} {self._lazy_cmd_name}"
             if ctx.parent and ctx.parent.command

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/specfact_cli/modules/upgrade/module-package.yaml

@@ -1,5 +1,5 @@
 name: upgrade
-version: 0.1.4
+version: 0.1.15
 commands:
   - upgrade
 category: core
@@ -17,5 +17,5 @@ publisher:
 description: Check and apply SpecFact CLI version upgrades.
 license: Apache-2.0
 integrity:
-  checksum: sha256:0648be45eb877287ebef717d38c71d48c1e17191dfb24b0c8dde57015f7ba144
-  signature: ZMw8ljS+0f4TYg2WVAqQCpgaae1d8z7wT/1r2yxuM6ZeZjMejhgeBuOyXopda5LOXjioxTxOlWZmGN94cCC3Ag==
+  checksum: sha256:134da8c48f8be96e9a4337a7cc2076bbf8b19e0d3f69161636bcec050f97e4c1
+  signature: CK8Gq+/d0zWlU1Lo1I6EcgPiT3FzVsXj+CXFn7+zUnpXRdpYZxccLLZqh1Hvl2IPv3Y4yecVlOEcWZKtn0tJBg==

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/specfact_cli/modules/upgrade/src/commands.py

@@ -9,6 +9,8 @@ CrossHair: skip (subprocess-based installation checks are intentionally side-eff
 
 from __future__ import annotations
 
+import os
+import shlex
 import subprocess
 import sys
 from datetime import UTC
@@ -45,7 +47,7 @@ validate_bundle = module_io_shim.validate_bundle
 class InstallationMethod(NamedTuple):
     """Installation method information."""
 
-    method: str  # "pip", "uvx", "pipx", or "unknown"
+    method: str  # "pip", "uv", "uvx", "pipx", or "unknown"
     command: str  # Command to run for update
     location: str | None  # Installation location if known
 
@@ -53,39 +55,102 @@ class InstallationMethod(NamedTuple):
 @beartype
 @ensure(lambda result: isinstance(result, InstallationMethod), "Must return InstallationMethod")
 def detect_installation_method() -> InstallationMethod:
-    """
-    Detect how SpecFact CLI was installed.
+    """Detect how SpecFact CLI was installed."""
+    executable_path = str(Path(sys.executable))
+
+    uvx_method = _detect_uvx_installation(executable_path)
+    if uvx_method:
+        return uvx_method
+
+    uv_method = _detect_uv_project_installation(executable_path)
+    if uv_method:
+        return uv_method
+
+    pipx_method = _detect_pipx_installation()
+    if pipx_method:
+        return pipx_method
+
+    uv_method = _detect_uv_tool_installation()
+    if uv_method:
+        return uv_method
+
+    pip_method = _detect_pip_installation()
+    if pip_method:
+        return pip_method
+
+    quoted_executable = shlex.quote(sys.executable)
+    return InstallationMethod(
+        method="pip",
+        command=f"{quoted_executable} -m pip install --upgrade specfact-cli",
+        location=None,
+    )
+
+
+def _detect_uvx_installation(executable_path: str) -> InstallationMethod | None:
+    if _path_segments_contain_uvx(sys.argv[0]) or _path_segments_contain_uvx(executable_path):
+        return InstallationMethod(method="uvx", command="uvx --from specfact-cli specfact --version", location=None)
+    return None
+
+
+def _path_segments_contain_uvx(path_value: str) -> bool:
+    segments = [segment for segment in path_value.replace("\\", "/").split("/") if segment]
+    return any(_is_uvx_executable_name(segment) for segment in segments)
 
-    Returns:
-        InstallationMethod with detected method and update command
-    """
-    # Check if running via uvx
-    if "uvx" in sys.argv[0] or "uvx" in str(Path(sys.executable)):
-        return InstallationMethod(
-            method="uvx",
-            command="uvx --from specfact-cli specfact --version",
-            location=None,
-        )
 
-    # Check if running via pipx
+def _is_uvx_executable_name(segment: str) -> bool:
+    lower_segment = segment.lower()
+    for suffix in (".exe", ".cmd", ".bat"):
+        if lower_segment.endswith(suffix):
+            lower_segment = lower_segment[: -len(suffix)]
+            break
+    return lower_segment == "uvx"
+
+
+def _detect_uv_project_installation(executable_path: str) -> InstallationMethod | None:
+    uv_project_env = os.environ.get("UV_PROJECT_ENVIRONMENT", "").strip()
+    if uv_project_env:
+        try:
+            uv_root = Path(uv_project_env).resolve()
+            executable = Path(executable_path).resolve()
+        except OSError:
+            return None
+        if executable == uv_root or uv_root in executable.parents:
+            executable_text = str(executable)
+            return InstallationMethod(
+                method="uv",
+                command=f"uv pip install --python {shlex.quote(executable_text)} --upgrade specfact-cli",
+                location=executable_text,
+            )
+    return None
+
+
+def _detect_uv_tool_installation() -> InstallationMethod | None:
     try:
         result = subprocess.run(
-            ["pipx", "list"],
+            ["uv", "tool", "list"],
             capture_output=True,
             text=True,
             timeout=5,
             check=False,
         )
-        if "specfact-cli" in result.stdout:
-            return InstallationMethod(
-                method="pipx",
-                command="pipx upgrade specfact-cli",
-                location=None,
-            )
     except (subprocess.TimeoutExpired, FileNotFoundError):
-        pass
+        return None
+    if "specfact-cli" in result.stdout:
+        return InstallationMethod(method="uv", command="uv tool upgrade specfact-cli", location=None)
+    return None
+
 
-    # Check if installed via pip (user or system)
+def _detect_pipx_installation() -> InstallationMethod | None:
+    try:
+        result = subprocess.run(["pipx", "list"], capture_output=True, text=True, timeout=5, check=False)
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None
+    if "specfact-cli" in result.stdout:
+        return InstallationMethod(method="pipx", command="pipx upgrade specfact-cli", location=None)
+    return None
+
+
+def _detect_pip_installation() -> InstallationMethod | None:
     try:
         result = subprocess.run(
             [sys.executable, "-m", "pip", "show", "specfact-cli"],
@@ -94,95 +159,88 @@ def detect_installation_method() -> InstallationMethod:
             timeout=5,
             check=False,
         )
-        if result.returncode == 0:
-            # Parse location from output
-            location = None
-            for line in result.stdout.splitlines():
-                if line.startswith("Location:"):
-                    location = line.split(":", 1)[1].strip()
-                    break
-
-            return InstallationMethod(
-                method="pip",
-                command=f"{sys.executable} -m pip install --upgrade specfact-cli",
-                location=location,
-            )
     except (subprocess.TimeoutExpired, FileNotFoundError):
-        pass
+        return None
+
+    if result.returncode != 0:
+        return None
 
-    # Fallback: assume pip
+    location = None
+    for line in result.stdout.splitlines():
+        if line.startswith("Location:"):
+            location = line.split(":", 1)[1].strip()
+            break
+    quoted_executable = shlex.quote(sys.executable)
     return InstallationMethod(
         method="pip",
-        command="pip install --upgrade specfact-cli",
-        location=None,
+        command=f"{quoted_executable} -m pip install --upgrade specfact-cli",
+        location=location,
     )
 
 
 @beartype
 @ensure(lambda result: isinstance(result, bool), "Must return bool")
 def install_update(method: InstallationMethod, yes: bool = False) -> bool:
-    """
-    Install update using the detected installation method.
-
-    Args:
-        method: InstallationMethod with update command
-        yes: If True, skip confirmation prompt
-
-    Returns:
-        True if update was successful, False otherwise
-    """
+    """Install update using the detected installation method."""
     if not yes:
         console.print(f"[yellow]This will update SpecFact CLI using:[/yellow] [cyan]{method.command}[/cyan]")
         if not Confirm.ask("Continue?", default=True):
             console.print("[dim]Update cancelled[/dim]")
             return False
 
-    try:
-        console.print("[cyan]Updating SpecFact CLI...[/cyan]")
-        # Split command into parts for subprocess
-        if method.method == "pipx":
-            cmd = ["pipx", "upgrade", "specfact-cli"]
-        elif method.method == "pip":
-            # Handle both formats: "python -m pip" and "pip"
-            if " -m pip" in method.command:
-                parts = method.command.split()
-                cmd = [parts[0], "-m", "pip", "install", "--upgrade", "specfact-cli"]
-            else:
-                cmd = ["pip", "install", "--upgrade", "specfact-cli"]
-        else:
-            # uvx - just inform user
-            console.print(
-                "[yellow]uvx automatically uses the latest version.[/yellow]\n"
-                "[dim]No update needed. If you want to force a refresh, run:[/dim]\n"
-                "[cyan]uvx --from specfact-cli@latest specfact --version[/cyan]"
-            )
-            return True
-
-        result = subprocess.run(
-            cmd,
-            check=False,
-            timeout=300,  # 5 minute timeout
+    if method.method == "uvx":
+        console.print(
+            "[yellow]uvx automatically uses the latest version.[/yellow]\n"
+            "[dim]No update needed. If you want to force a refresh, run:[/dim]\n"
+            "[cyan]uvx --from specfact-cli@latest specfact --version[/cyan]"
         )
+        return True
 
-        if result.returncode == 0:
-            console.print("[green]✓ Update successful![/green]")
-            # Update metadata to reflect new version
-            from datetime import datetime
-
-            update_metadata(
-                last_checked_version=__version__,
-                last_version_check_timestamp=datetime.now(UTC).isoformat(),
-            )
-            return True
-        console.print(f"[red]✗ Update failed with exit code {result.returncode}[/red]")
+    command = _build_upgrade_command(method)
+    if command is None:
+        console.print(f"[red]✗ Unsupported installation method: {method.method}[/red]")
         return False
 
+    return _execute_upgrade_command(command)
+
+
+def _build_upgrade_command(method: InstallationMethod) -> list[str] | None:
+    if method.method == "pipx":
+        return ["pipx", "upgrade", "specfact-cli"]
+    if method.method == "uv":
+        if "uv tool" in method.command:
+            return ["uv", "tool", "upgrade", "specfact-cli"]
+        python_target = method.location or sys.executable
+        return ["uv", "pip", "install", "--python", python_target, "--upgrade", "specfact-cli"]
+    if method.method == "pip":
+        parts = shlex.split(method.command)
+        if len(parts) >= 3 and parts[1:3] == ["-m", "pip"]:
+            return [parts[0], "-m", "pip", "install", "--upgrade", "specfact-cli"]
+        return ["pip", "install", "--upgrade", "specfact-cli"]
+    return None
+
+
+def _execute_upgrade_command(command: list[str]) -> bool:
+    try:
+        console.print("[cyan]Updating SpecFact CLI...[/cyan]")
+        result = subprocess.run(command, check=False, timeout=300)
     except subprocess.TimeoutExpired:
         console.print("[red]✗ Update timed out (exceeded 5 minutes)[/red]")
         return False
-    except Exception as e:
+    except OSError as e:
         console.print(f"[red]✗ Update failed: {e}[/red]")
         return False
+    if result.returncode != 0:
+        console.print(f"[red]✗ Update failed with exit code {result.returncode}[/red]")
+        return False
+    console.print("[green]✓ Update successful![/green]")
+    from datetime import datetime
+
+    try:
+        update_metadata(last_checked_version=__version__, last_version_check_timestamp=datetime.now(UTC).isoformat())
+    except (OSError, TypeError) as exc:
+        console.print(f"[yellow]Update succeeded, but metadata update failed: {exc}[/yellow]")
+    return True
 
 
 def _upgrade_log_started(check_only: bool, yes: bool) -> None:
@@ -246,6 +304,13 @@ def _upgrade_render_update_panel(version_result: Any) -> None:
 def _upgrade_install_or_check_only(version_result: Any, check_only: bool, yes: bool) -> None:
     if check_only:
         method = detect_installation_method()
+        if method.method == "uvx":
+            console.print(
+                "[yellow]uvx automatically uses the latest version.[/yellow]\n"
+                "[dim]No update needed. If you want to force a refresh, run:[/dim]\n"
+                "[cyan]uvx --from specfact-cli@latest specfact --version[/cyan]"
+            )
+            return
         console.print(f"\n[yellow]To upgrade, run:[/yellow] [cyan]{method.command}[/cyan]")
         console.print("[dim]Or run:[/dim] [cyan]specfact upgrade --yes[/cyan]")
         return

{specfact_cli-0.46.9 → specfact_cli-0.46.17}/src/specfact_cli/registry/module_discovery.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -48,18 +49,18 @@ class _DiscoveryMergeState:
 
 
 def _resolve_include_legacy_roots(
-    include_legacy_roots: bool | None,
-    builtin_root: Path | None,
-    user_root: Path | None,
-    marketplace_root: Path | None,
-    custom_root: Path | None,
-    project_base_path: Path | None = None,
+    options: _DiscoveryRootOptions,
 ) -> bool:
-    if include_legacy_roots is not None:
-        return include_legacy_roots
-    if project_base_path is not None:
+    if options.include_legacy_roots is not None:
+        return options.include_legacy_roots
+    if options.project_base_path is not None:
         return False
-    return builtin_root is None and user_root is None and marketplace_root is None and custom_root is None
+    return (
+        options.builtin_root is None
+        and options.user_root is None
+        and options.marketplace_root is None
+        and options.custom_root is None
+    )
 
 
 def _append_legacy_module_roots(roots: list[tuple[str, Path]]) -> None:
@@ -74,6 +75,22 @@ def _append_legacy_module_roots(roots: list[tuple[str, Path]]) -> None:
         roots.append(("custom", extra_root))
 
 
+def _append_explicit_module_roots(roots: list[tuple[str, Path]]) -> None:
+    seen_root_paths = {path.resolve() for _source, path in roots}
+    for raw_root in os.environ.get("SPECFACT_MODULES_ROOTS", "").split(os.pathsep):
+        candidate = raw_root.strip()
+        if not candidate:
+            continue
+        path = Path(candidate).expanduser()
+        if not path.exists():
+            continue
+        resolved = path.resolve()
+        if resolved in seen_root_paths:
+            continue
+        seen_root_paths.add(resolved)
+        roots.append(("custom", path))
+
+
 def _discovery_root_list(options: _DiscoveryRootOptions) -> list[tuple[str, Path]]:
     from specfact_cli.registry.module_packages import get_modules_root, get_workspace_modules_root
 
@@ -93,6 +110,7 @@ def _discovery_root_list(options: _DiscoveryRootOptions) -> list[tuple[str, Path
 
     if effective_project_root is not None and not project_matches_user_root:
         roots.append(("project", effective_project_root))
+    _append_explicit_module_roots(roots)
     roots.extend(
         [
             ("user", effective_user_root),
@@ -101,14 +119,7 @@ def _discovery_root_list(options: _DiscoveryRootOptions) -> list[tuple[str, Path
         ]
     )
 
-    legacy = _resolve_include_legacy_roots(
-        options.include_legacy_roots,
-        options.builtin_root,
-        options.user_root,
-        options.marketplace_root,
-        options.custom_root,
-        options.project_base_path,
-    )
+    legacy = _resolve_include_legacy_roots(options)
     if legacy:
         _append_legacy_module_roots(roots)
     return roots