Use engine-managed modules in cwd scope

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Author: grouville

README.md

@@ -10,7 +10,7 @@ Shared, language-agnostic operations — editing a module's dependencies or its
 required engine version — are owned by the core CLI (`dagger module deps`,
 `dagger module engine`) and are no longer part of this module's surface.
 
-Backed by [`github.com/dagger/sdk-sdk/polyfill`](https://github.com/dagger/sdk-sdk/tree/main/polyfill).
+It uses the engine's native `Workspace` and `ModuleSource` APIs directly.
 
 ## Install
 

docs/cwd-aware-discovery.md

@@ -1,20 +1,19 @@
 # CWD-aware module discovery
 
-The Python SDK delegates config discovery to `github.com/dagger/polyfill`, then
-intersects the discovered directories with `currentModule.asSDK.modules`. The
-engine's managed-module list remains authoritative while the caller's current
-directory determines scope.
+The Python SDK asks
+`currentModule.asSDK(workspace: ws).modulesInScope` for the registered modules
+relevant to the caller's current directory. The engine owns both membership and
+scope selection, so the SDK does not scan config files or reconstruct the cwd
+policy.
 
-Discovery returns modules at or below the cwd and, when the cwd has no module
-config, its nearest enclosing module. Both `dagger-module.toml` and legacy
-`dagger.json` are considered together, so the nearest config wins regardless of
-filename. Virtual environments and installed packages are excluded.
+Selection returns modules at or below the cwd and, when the cwd itself is not a
+registered module, its nearest registered ancestor.
 
 ```console
 dagger check -l
 dagger call e-2-e mixed-config-lookup-check
 dagger call e-2-e module-discovery-check
 ```
 
-The fixtures cover mixed nested config formats, modern and legacy configs,
-non-Python exclusion, root discovery, and discovery from inside a module.
+The fixtures cover mixed nested config formats, modern and legacy modules,
+non-Python exclusion, root selection, and selection from inside a module.

python-sdk.dang

@@ -17,34 +17,16 @@ type PythonSdk {
   pub targetRuntime: String! { "python" }
 
   """
-  Return every managed Python SDK module visible from the client's cwd: the
-  nearest enclosing module plus modules at or below the cwd. Discovery uses the
-  engine's Workspace.findConfigDirs and intersects its results with the SDK list on the passed
-  workspace.
+  Return every managed Python SDK module in the client's cwd scope: every module
+  at or below the cwd, plus the nearest enclosing module when the cwd itself is
+  not managed. The engine selects this directly from the workspace's registered
+  SDK modules; no filesystem discovery is required.
   """
   pub modules(ws: Workspace!): [Mod!]! {
-    let managed = currentModule.asSDK(workspace: ws).modules.{{path}}
-    let cwd = normalizePath(ws.cwd)
-    ws
-      .findConfigDirs(moduleConfigFilenames, exclude: ["**/.venv/**", "**/site-packages/**"])
-      .map { dir => workspacePath(cwd, dir) }
-      .uniq
-      .filter { path => managed.filter { m => normalizePath(m.path) == path }.length > 0 }
-      .map { path => Mod(rootPath: path, ws: ws, skipGenerateFilename: skipGenerateFilename) }
-  }
-
-  let workspacePath(cwd: String!, path: String!): String! {
-    let base = if (cwd == ".") { [] } else { cwd.split("/") }
-    let segments = path.split("/").reduce(base) { acc, segment =>
-      if (segment == "..") {
-        acc.dropLast(1)
-      } else if (segment == "." or segment == "") {
-        acc
-      } else {
-        acc + [segment]
-      }
-    }
-    if (segments.length == 0) { "." } else { segments.join("/") }
+    currentModule
+      .asSDK(workspace: ws)
+      .modulesInScope.{{path}}
+      .map { module => Mod(rootPath: module.path, ws: ws, skipGenerateFilename: skipGenerateFilename) }
   }
 
   let normalizePath(path: String!): String! {