From c77abcb8ef2859edd711c3242e70db95da0c9d72 Mon Sep 17 00:00:00 2001
From: Kaj Kowalski <info@kajkowalski.nl>
Date: Thu, 4 Jun 2026 09:06:25 +0000
Subject: [PATCH 1/3] Surface pyproject.toml [project.scripts] as runnable
 tasks

Python projects detected a package manager (uv/poetry/pipenv) but never
listed their PEP 621 [project.scripts] console entry points, so `runner`
showed "no tasks" for a project full of declared scripts.

Add a PyprojectScripts task source: parse [project.scripts] from
pyproject.toml, surface each entry with its entry-point target as the
description, and dispatch via the detected Python PM's run subcommand
(uv run / poetry run / pipenv run). Honors an explicit Python-ecosystem
--pm / [pm].python override, falling back to the detected PM.
---
 CHANGELOG.md            |   8 +++
 README.md               |   1 +
 src/cmd/list.rs         |   5 ++
 src/cmd/run/dispatch.rs |  87 +++++++++++++++++++++++++++++-
 src/cmd/run/select.rs   |   1 +
 src/cmd/why.rs          |   1 +
 src/detect.rs           |  73 ++++++++++++++++++++++++-
 src/schema/v1.rs        |   1 +
 src/tool/pipenv.rs      |  19 ++++++-
 src/tool/poetry.rs      |  19 ++++++-
 src/tool/python.rs      | 117 +++++++++++++++++++++++++++++++++++++++-
 src/tool/uv.rs          |  30 ++++++++++-
 src/types.rs            |   9 ++++
 13 files changed, 365 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 948318d..3bb346e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,14 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 
 ### Added
 
+- `pyproject.toml` `[project.scripts]` entry points (PEP 621 console
+  scripts) are now extracted as runnable tasks for Python projects. They
+  surface under the `pyproject.toml` source in `runner list` (with the
+  entry-point target shown as the description) and dispatch via the
+  detected Python package manager's `run` subcommand — `uv run <name>`,
+  `poetry run <name>`, or `pipenv run <name>`. Previously a uv/poetry
+  project's declared scripts were invisible to `runner`, which detected
+  the package manager but listed no tasks.
 - AUR distribution channel. Two packages on the Arch User Repository:
   `runner-run-bin` (prebuilt binaries for `x86_64`, `aarch64`, `armv7h`)
   and `runner-run` (source build for `x86_64`, `aarch64`). `-bin`
diff --git a/README.md b/README.md
index 6ea2fce..6182e2d 100644
--- a/README.md
+++ b/README.md
@@ -362,6 +362,7 @@ Taskfile
 bacon.toml
 mise.toml / .mise.toml
 Cargo aliases from .cargo/config.toml
+pyproject.toml [project.scripts] (run via uv / poetry / pipenv)
 ```
 
 It also understands monorepo/workspace context from:
diff --git a/src/cmd/list.rs b/src/cmd/list.rs
index a8cd3c1..99c3af9 100644
--- a/src/cmd/list.rs
+++ b/src/cmd/list.rs
@@ -190,6 +190,7 @@ fn render_tasks_grouped_rich(
         TaskSource::GoPackage,
         TaskSource::BaconToml,
         TaskSource::MiseToml,
+        TaskSource::PyprojectScripts,
     ];
     for source in sources {
         let source_tasks = tasks_for_source(tasks, source);
@@ -370,6 +371,7 @@ fn render_tasks_grouped_compact(tasks: &[&Task], stdout_is_terminal: bool) -> St
         TaskSource::GoPackage,
         TaskSource::BaconToml,
         TaskSource::MiseToml,
+        TaskSource::PyprojectScripts,
     ];
     for source in sources {
         let source_tasks = tasks_for_source(tasks, source);
@@ -472,6 +474,9 @@ fn source_path(source: TaskSource, root: &Path) -> Option<PathBuf> {
             tool::files::find_first(root, tool::bacon::FILENAMES).filter(|path| path.is_file())
         }
         TaskSource::MiseToml => tool::mise::find_file(root),
+        TaskSource::PyprojectScripts => {
+            tool::files::find_first(root, &["pyproject.toml"]).filter(|path| path.is_file())
+        }
     }?;
 
     Some(path.canonicalize().unwrap_or(path))
diff --git a/src/cmd/run/dispatch.rs b/src/cmd/run/dispatch.rs
index 63d8e0b..0a23ef4 100644
--- a/src/cmd/run/dispatch.rs
+++ b/src/cmd/run/dispatch.rs
@@ -22,7 +22,7 @@ use super::qualify::{
 use super::select::select_task_entry;
 use crate::resolver::{ResolutionOverrides, ResolveError, Resolver};
 use crate::tool;
-use crate::types::{PackageManager, ProjectContext, Task, TaskSource};
+use crate::types::{Ecosystem, PackageManager, ProjectContext, Task, TaskSource};
 
 /// Resolve `task` to a fully-configured [`Command`] without spawning it.
 ///
@@ -282,9 +282,47 @@ fn build_run_command(
         }
         TaskSource::BaconToml => tool::bacon::run_cmd(&entry.name, args),
         TaskSource::MiseToml => tool::mise::run_cmd(&entry.name, args),
+        TaskSource::PyprojectScripts => {
+            let Some(pm) = resolve_python_pm(ctx, overrides) else {
+                bail!(
+                    "no Python package manager detected to run {:?}; install uv, poetry, or pipenv",
+                    entry.name,
+                );
+            };
+            match pm {
+                PackageManager::Uv => tool::uv::run_cmd(&entry.name, args),
+                PackageManager::Poetry => tool::poetry::run_cmd(&entry.name, args),
+                PackageManager::Pipenv => tool::pipenv::run_cmd(&entry.name, args),
+                other => bail!("{} cannot run pyproject scripts", other.label()),
+            }
+        }
     })
 }
 
+/// Pick the Python package manager that dispatches a `[project.scripts]`
+/// entry: an explicit Python-ecosystem `--pm` / `RUNNER_PM` override
+/// first, then a `[pm].python` `runner.toml` override, then the PM
+/// detected for the project. A non-Python `--pm` (e.g. `--pm pnpm` in a
+/// mixed repo) is ignored here rather than forced, falling through to the
+/// detected Python PM.
+fn resolve_python_pm(
+    ctx: &ProjectContext,
+    overrides: &ResolutionOverrides,
+) -> Option<PackageManager> {
+    if let Some(o) = overrides.pm.as_ref()
+        && o.pm.ecosystem() == Ecosystem::Python
+    {
+        return Some(o.pm);
+    }
+    if let Some(o) = overrides.pm_by_ecosystem.get(&Ecosystem::Python) {
+        return Some(o.pm);
+    }
+    ctx.package_managers
+        .iter()
+        .copied()
+        .find(|pm| pm.ecosystem() == Ecosystem::Python)
+}
+
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
@@ -350,6 +388,53 @@ mod tests {
         );
     }
 
+    #[test]
+    fn resolve_dispatch_pyproject_script_uses_uv_run() {
+        let mut ctx = context();
+        ctx.package_managers.push(PackageManager::Uv);
+        ctx.tasks.push(Task {
+            name: "greenpy".to_string(),
+            source: TaskSource::PyprojectScripts,
+            run_target: None,
+            description: Some("greenpy.main:main".to_string()),
+            alias_of: None,
+            passthrough_to: None,
+        });
+        let args = [String::from("--flag")];
+
+        let command = resolve_dispatch(
+            &ctx,
+            &ResolutionOverrides::default(),
+            "greenpy",
+            &args,
+            None,
+        )
+        .expect("pyproject script should dispatch");
+
+        assert_eq!(command.get_program().to_string_lossy(), "uv");
+        assert_eq!(command_args(&command), ["run", "greenpy", "--flag"]);
+    }
+
+    #[test]
+    fn resolve_dispatch_pyproject_script_uses_poetry_run_when_detected() {
+        let mut ctx = context();
+        ctx.package_managers.push(PackageManager::Poetry);
+        ctx.tasks.push(Task {
+            name: "greenpy".to_string(),
+            source: TaskSource::PyprojectScripts,
+            run_target: None,
+            description: None,
+            alias_of: None,
+            passthrough_to: None,
+        });
+
+        let command = resolve_dispatch(&ctx, &ResolutionOverrides::default(), "greenpy", &[], None)
+            .expect("pyproject script should dispatch");
+
+        assert_eq!(command.get_program().to_string_lossy(), "poetry");
+        assert_eq!(command_args(&command), ["run", "greenpy"]);
+    }
+
     #[test]
     fn build_pm_exec_command_go_versioned_uses_go_run() {
         let args = [String::from("--help")];
diff --git a/src/cmd/run/select.rs b/src/cmd/run/select.rs
index 9fc4696..6cf46f4 100644
--- a/src/cmd/run/select.rs
+++ b/src/cmd/run/select.rs
@@ -125,6 +125,7 @@ fn source_dir(source: TaskSource, root: &Path) -> Option<PathBuf> {
         TaskSource::Taskfile => tool::files::find_first_upwards(root, tool::go_task::FILENAMES),
         TaskSource::BaconToml => tool::files::find_first_upwards(root, tool::bacon::FILENAMES),
         TaskSource::MiseToml => tool::files::find_first_upwards(root, tool::mise::FILENAMES),
+        TaskSource::PyprojectScripts => tool::files::find_first_upwards(root, &["pyproject.toml"]),
     };
     path.and_then(|path| path.parent().map(Path::to_path_buf))
 }
diff --git a/src/cmd/why.rs b/src/cmd/why.rs
index 7a7e480..9c7ef8e 100644
--- a/src/cmd/why.rs
+++ b/src/cmd/why.rs
@@ -157,6 +157,7 @@ fn source_dir_for_task(task: &Task, ctx: &ProjectContext) -> Option<PathBuf> {
         TaskSource::GoPackage => tool::go_pm::find_file(&ctx.root),
         TaskSource::BaconToml => tool::files::find_first(&ctx.root, tool::bacon::FILENAMES),
         TaskSource::MiseToml => tool::mise::find_file(&ctx.root),
+        TaskSource::PyprojectScripts => tool::files::find_first(&ctx.root, &["pyproject.toml"]),
     }
 }
 
diff --git a/src/detect.rs b/src/detect.rs
index 2667009..44b1668 100644
--- a/src/detect.rs
+++ b/src/detect.rs
@@ -8,7 +8,8 @@ use serde::Deserialize;
 
 use crate::tool;
 use crate::types::{
-    DetectionWarning, NodeVersion, PackageManager, ProjectContext, Task, TaskRunner, TaskSource,
+    DetectionWarning, Ecosystem, NodeVersion, PackageManager, ProjectContext, Task, TaskRunner,
+    TaskSource,
 };
 
 /// Scan `dir` for known config/lock files and return a populated [`ProjectContext`].
@@ -318,6 +319,13 @@ fn extract_tasks(dir: &Path, ctx: &mut ProjectContext) {
     let want_go_packages = ctx.package_managers.contains(&PackageManager::Go);
     let want_bacon = ctx.task_runners.contains(&TaskRunner::Bacon);
     let want_mise = ctx.task_runners.contains(&TaskRunner::Mise);
+    // `[project.scripts]` is shared PEP 621 metadata; surface it whenever
+    // any Python package manager (uv, poetry, pipenv) governs the project,
+    // since each dispatches the same entry points via its own `run`.
+    let want_pyproject_scripts = ctx
+        .package_managers
+        .iter()
+        .any(|pm| pm.ecosystem() == Ecosystem::Python);
 
     thread::scope(|s| {
         let pkg_json_h = want_pkg_json.then(|| {
@@ -338,6 +346,8 @@ fn extract_tasks(dir: &Path, ctx: &mut ProjectContext) {
         let go_h = want_go_packages.then(|| s.spawn(move || tool::go_pm::extract_tasks(dir)));
         let bacon_h = want_bacon.then(|| s.spawn(move || tool::bacon::extract_tasks(dir)));
         let mise_h = want_mise.then(|| s.spawn(move || tool::mise::extract_tasks(dir)));
+        let pyproject_h = want_pyproject_scripts
+            .then(|| s.spawn(move || tool::python::extract_pyproject_scripts(dir)));
 
         if let Some(h) = pkg_json_h {
             push_package_json_tasks(ctx, h.join().expect("extractor thread panicked"));
@@ -389,6 +399,13 @@ fn extract_tasks(dir: &Path, ctx: &mut ProjectContext) {
         if let Some(h) = mise_h {
             push_mise_tasks(ctx, h.join().expect("extractor thread panicked"));
         }
+        if let Some(h) = pyproject_h {
+            push_described_tasks(
+                ctx,
+                TaskSource::PyprojectScripts,
+                h.join().expect("extractor thread panicked"),
+            );
+        }
     });
 }
 
@@ -728,6 +745,60 @@ mod tests {
         }));
     }
 
+    #[test]
+    fn detect_lists_pyproject_scripts_for_uv_projects() {
+        // Headline regression (issue): a uv project's `[project.scripts]`
+        // console entry points were detected as a package manager but
+        // never surfaced as runnable tasks.
+        let dir = TempDir::new("detect-pyproject-scripts-uv");
+        fs::write(dir.path().join("uv.lock"), "").expect("uv.lock should be written");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\nversion = \"0.1.0\"\n\n[project.scripts]\nbodysuit = \"greenpy.bodysuit:main\"\ngreenpy = \"greenpy.main:main\"\nnavel-stamper = \"greenpy.navel_stamper:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let ctx = detect(dir.path());
+
+        assert!(
+            ctx.package_managers
+                .contains(&crate::types::PackageManager::Uv)
+        );
+        let names: Vec<&str> = ctx
+            .tasks
+            .iter()
+            .filter(|t| t.source == crate::types::TaskSource::PyprojectScripts)
+            .map(|t| t.name.as_str())
+            .collect();
+        assert_eq!(names, ["bodysuit", "greenpy", "navel-stamper"]);
+        // The entry-point target rides along as the task description.
+        assert!(ctx.tasks.iter().any(|t| {
+            t.source == crate::types::TaskSource::PyprojectScripts
+                && t.name == "greenpy"
+                && t.description.as_deref() == Some("greenpy.main:main")
+        }));
+    }
+
+    #[test]
+    fn detect_lists_pyproject_scripts_for_poetry_projects() {
+        let dir = TempDir::new("detect-pyproject-scripts-poetry");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[tool.poetry]\nname = \"demo\"\nversion = \"0.1.0\"\n\n[project.scripts]\ncli = \"demo.cli:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let ctx = detect(dir.path());
+
+        assert!(
+            ctx.package_managers
+                .contains(&crate::types::PackageManager::Poetry)
+        );
+        assert!(ctx.tasks.iter().any(|t| {
+            t.source == crate::types::TaskSource::PyprojectScripts && t.name == "cli"
+        }));
+    }
+
     #[test]
     fn detect_uses_deno_for_package_json_deno_projects() {
         let dir = TempDir::new("detect-package-json-deno");
diff --git a/src/schema/v1.rs b/src/schema/v1.rs
index 10c7c3f..fc2e345 100644
--- a/src/schema/v1.rs
+++ b/src/schema/v1.rs
@@ -28,5 +28,6 @@ pub(crate) const fn source_label(source: TaskSource) -> &'static str {
         TaskSource::GoPackage => "go",
         TaskSource::BaconToml => "bacon.toml",
         TaskSource::MiseToml => "mise.toml",
+        TaskSource::PyprojectScripts => "pyproject.toml",
     }
 }
diff --git a/src/tool/pipenv.rs b/src/tool/pipenv.rs
index 9f3deb9..a5b8610 100644
--- a/src/tool/pipenv.rs
+++ b/src/tool/pipenv.rs
@@ -28,9 +28,17 @@ pub(crate) fn install_cmd(frozen: bool) -> Command {
     c
 }
 
+/// `pipenv run <script> [args...]` — run a `[project.scripts]` console
+/// entry point inside the project's virtualenv.
+pub(crate) fn run_cmd(script: &str, args: &[String]) -> Command {
+    let mut c = super::program::command("pipenv");
+    c.arg("run").arg(script).args(args);
+    c
+}
+
 #[cfg(test)]
 mod tests {
-    use super::install_cmd;
+    use super::{install_cmd, run_cmd};
 
     #[test]
     fn install_unfrozen_uses_install_subcommand() {
@@ -49,4 +57,13 @@ mod tests {
             .collect();
         assert_eq!(args, ["sync"]);
     }
+
+    #[test]
+    fn run_cmd_forwards_script_and_args() {
+        let args: Vec<_> = run_cmd("serve", &["--port".into(), "8000".into()])
+            .get_args()
+            .map(|arg| arg.to_string_lossy().into_owned())
+            .collect();
+        assert_eq!(args, ["run", "serve", "--port", "8000"]);
+    }
 }
diff --git a/src/tool/poetry.rs b/src/tool/poetry.rs
index b995559..3368117 100644
--- a/src/tool/poetry.rs
+++ b/src/tool/poetry.rs
@@ -53,13 +53,30 @@ pub(crate) fn install_cmd() -> Command {
     c
 }
 
+/// `poetry run <script> [args...]` — run a `[project.scripts]` console
+/// entry point inside the project's virtualenv.
+pub(crate) fn run_cmd(script: &str, args: &[String]) -> Command {
+    let mut c = super::program::command("poetry");
+    c.arg("run").arg(script).args(args);
+    c
+}
+
 #[cfg(test)]
 mod tests {
     use std::fs;
 
-    use super::detect;
+    use super::{detect, run_cmd};
     use crate::tool::test_support::TempDir;
 
+    #[test]
+    fn run_cmd_forwards_script_and_args() {
+        let args: Vec<_> = run_cmd("greenpy", &["--verbose".into()])
+            .get_args()
+            .map(|arg| arg.to_string_lossy().into_owned())
+            .collect();
+        assert_eq!(args, ["run", "greenpy", "--verbose"]);
+    }
+
     #[test]
     fn detects_poetry_lockfile() {
         let dir = TempDir::new("poetry-lock");
diff --git a/src/tool/python.rs b/src/tool/python.rs
index d36d310..001e6e3 100644
--- a/src/tool/python.rs
+++ b/src/tool/python.rs
@@ -1,7 +1,11 @@
 //! Shared Python tooling helpers.
 
+use std::collections::BTreeMap;
 use std::path::Path;
 
+use anyhow::Context as _;
+use serde::Deserialize;
+
 /// Common Python artifact and cache directories.
 pub(crate) const CLEAN_DIRS: &[&str] = &[
     ".venv",
@@ -60,6 +64,53 @@ pub(crate) fn clean_dirs(dir: &Path) -> Vec<String> {
     dirs
 }
 
+/// Extract `[project.scripts]` entry points (PEP 621 console scripts)
+/// from `pyproject.toml`, each paired with its entry-point target as a
+/// description (e.g. `("greenpy", Some("greenpy.main:main"))`).
+///
+/// These are surfaced as tasks and dispatched via the detected Python
+/// PM's `run` subcommand (`uv run <name>`, `poetry run <name>`,
+/// `pipenv run <name>`) — the same way the script's installed console
+/// entry point would be invoked inside the project environment.
+///
+/// Returns an empty list when `pyproject.toml` is absent or declares no
+/// `[project.scripts]`; errors only when the file exists but can't be
+/// read or parsed, so a malformed manifest surfaces as a
+/// `TaskListUnreadable` warning rather than silently dropping tasks.
+pub(crate) fn extract_pyproject_scripts(
+    dir: &Path,
+) -> anyhow::Result<Vec<(String, Option<String>)>> {
+    let path = dir.join("pyproject.toml");
+    if !path.exists() {
+        return Ok(vec![]);
+    }
+    let content = std::fs::read_to_string(&path)
+        .with_context(|| format!("failed to read {}", path.display()))?;
+    let doc: PyprojectDoc =
+        toml::from_str(&content).with_context(|| format!("failed to parse {}", path.display()))?;
+
+    // `BTreeMap` iterates in sorted key order, so the returned list is
+    // already alphabetized — matching the post-extraction sort that
+    // `detect::detect` applies to the full task list.
+    Ok(doc
+        .project
+        .and_then(|project| project.scripts)
+        .unwrap_or_default()
+        .into_iter()
+        .map(|(name, target)| (name, Some(target)))
+        .collect())
+}
+
+#[derive(Deserialize)]
+struct PyprojectDoc {
+    project: Option<PyprojectProject>,
+}
+
+#[derive(Deserialize)]
+struct PyprojectProject {
+    scripts: Option<BTreeMap<String, String>>,
+}
+
 fn has_python_pyproject(dir: &Path) -> bool {
     let path = dir.join("pyproject.toml");
     let Ok(content) = std::fs::read_to_string(path) else {
@@ -79,9 +130,73 @@ fn has_python_pyproject(dir: &Path) -> bool {
 mod tests {
     use std::fs;
 
-    use super::{clean_dirs, detect};
+    use super::{clean_dirs, detect, extract_pyproject_scripts};
     use crate::tool::test_support::TempDir;
 
+    #[test]
+    fn extract_scripts_returns_names_with_entry_point_targets_sorted() {
+        let dir = TempDir::new("pyproject-scripts");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\n\n[project.scripts]\ngreenpy = \"greenpy.main:main\"\nbodysuit = \"greenpy.bodysuit:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let scripts = extract_pyproject_scripts(dir.path()).expect("scripts should parse");
+
+        assert_eq!(
+            scripts,
+            [
+                (
+                    "bodysuit".to_string(),
+                    Some("greenpy.bodysuit:main".to_string())
+                ),
+                ("greenpy".to_string(), Some("greenpy.main:main".to_string())),
+            ]
+        );
+    }
+
+    #[test]
+    fn extract_scripts_returns_empty_without_scripts_table() {
+        let dir = TempDir::new("pyproject-no-scripts");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\nversion = \"0.1.0\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        assert!(
+            extract_pyproject_scripts(dir.path())
+                .expect("scripts should parse")
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn extract_scripts_returns_empty_without_pyproject() {
+        let dir = TempDir::new("pyproject-missing");
+        assert!(
+            extract_pyproject_scripts(dir.path())
+                .expect("absent file is not an error")
+                .is_empty()
+        );
+    }
+
+    #[test]
+    fn extract_scripts_surfaces_parse_error_for_malformed_toml() {
+        let dir = TempDir::new("pyproject-malformed");
+        fs::write(dir.path().join("pyproject.toml"), "[project.scripts")
+            .expect("pyproject.toml should be written");
+
+        let err = extract_pyproject_scripts(dir.path())
+            .expect_err("malformed pyproject.toml should error");
+
+        assert!(
+            err.to_string().contains("failed to parse"),
+            "error chain should mention parse failure: {err:#}"
+        );
+    }
+
     #[test]
     fn detect_recognizes_generic_python_projects() {
         let dir = TempDir::new("python-detect");
diff --git a/src/tool/uv.rs b/src/tool/uv.rs
index 9ed1779..ae612c3 100644
--- a/src/tool/uv.rs
+++ b/src/tool/uv.rs
@@ -18,6 +18,20 @@ pub(crate) fn install_cmd(frozen: bool) -> Command {
     c
 }
 
+/// `uv run <script> [args...]` — run a `[project.scripts]` console
+/// entry point inside the project environment.
+///
+/// `uv run` resolves the name against the scripts installed for the
+/// project (the PEP 621 `[project.scripts]` entry points), syncing the
+/// environment first if needed — exactly the dispatch path a
+/// `[project.scripts]` task wants. This is distinct from [`exec_cmd`]
+/// (`uvx`), which fetches and runs an arbitrary tool from `PyPI`.
+pub(crate) fn run_cmd(script: &str, args: &[String]) -> Command {
+    let mut c = super::program::command("uv");
+    c.arg("run").arg(script).args(args);
+    c
+}
+
 /// `uvx <args...>` — uv's `npx`-equivalent (i.e. `uv tool run`).
 ///
 /// Runs a tool from `PyPI` in an ephemeral environment without
@@ -34,7 +48,21 @@ pub(crate) fn exec_cmd(args: &[String]) -> Command {
 
 #[cfg(test)]
 mod tests {
-    use super::exec_cmd;
+    use super::{exec_cmd, run_cmd};
+
+    #[test]
+    fn run_uses_uv_run_with_script_and_args() {
+        // `runner run greenpy --flag` on a uv project should build
+        // `uv run greenpy --flag` — the project-environment dispatch
+        // for a `[project.scripts]` entry point, not the `uvx`
+        // fetch-and-run path.
+        let built: Vec<_> = run_cmd("greenpy", &[String::from("--flag")])
+            .get_args()
+            .map(|arg| arg.to_string_lossy().into_owned())
+            .collect();
+
+        assert_eq!(built, ["run", "greenpy", "--flag"]);
+    }
 
     #[test]
     fn exec_uses_uvx_passthrough() {
diff --git a/src/types.rs b/src/types.rs
index 274b628..c06fceb 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -144,6 +144,10 @@ pub(crate) enum TaskSource {
     /// `mise.toml` / `.mise.toml` `[tasks.<name>]` tables (and the
     /// inline `[tasks]` flat form).
     MiseToml,
+    /// `pyproject.toml` `[project.scripts]` — PEP 621 console-script
+    /// entry points, dispatched via the detected Python PM's `run`
+    /// (`uv run`, `poetry run`, `pipenv run`).
+    PyprojectScripts,
 }
 
 /// Expected Node.js version parsed from a version file.
@@ -573,6 +577,9 @@ impl TaskSource {
             Self::GoPackage => "go",
             Self::BaconToml => "bacon",
             Self::MiseToml => "mise",
+            // Filename, not a tool name: `[project.scripts]` is read by
+            // uv, poetry, and pipenv alike, so no single tool owns it.
+            Self::PyprojectScripts => "pyproject.toml",
         }
     }
 
@@ -595,6 +602,7 @@ impl TaskSource {
             "go" | "go.mod" => Some(Self::GoPackage),
             "bacon" | "bacon.toml" => Some(Self::BaconToml),
             "mise" | "mise.toml" | ".mise.toml" => Some(Self::MiseToml),
+            "pyproject" | "pyproject.toml" => Some(Self::PyprojectScripts),
             _ => None,
         }
     }
@@ -612,6 +620,7 @@ impl TaskSource {
             Self::GoPackage => 7,
             Self::BaconToml => 8,
             Self::MiseToml => 9,
+            Self::PyprojectScripts => 10,
         }
     }
 }

From 5769518688ada7a260eec15d1c818d973c8a79e4 Mon Sep 17 00:00:00 2001
From: Kaj Kowalski <info@kajkowalski.nl>
Date: Thu, 4 Jun 2026 11:48:30 +0200
Subject: [PATCH 2/3] fix(list,why): resolve pyproject source dir upwards

Match select.rs: PyprojectScripts source_dir walks ancestors via
find_first_upwards instead of probing only the root, so list/why
report the same dir where run executes the task.
---
 src/cmd/list.rs | 2 +-
 src/cmd/why.rs  | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmd/list.rs b/src/cmd/list.rs
index 99c3af9..abb759c 100644
--- a/src/cmd/list.rs
+++ b/src/cmd/list.rs
@@ -475,7 +475,7 @@ fn source_path(source: TaskSource, root: &Path) -> Option<PathBuf> {
         }
         TaskSource::MiseToml => tool::mise::find_file(root),
         TaskSource::PyprojectScripts => {
-            tool::files::find_first(root, &["pyproject.toml"]).filter(|path| path.is_file())
+            tool::files::find_first_upwards(root, &["pyproject.toml"]).filter(|path| path.is_file())
         }
     }?;
 
diff --git a/src/cmd/why.rs b/src/cmd/why.rs
index 9c7ef8e..e2af27f 100644
--- a/src/cmd/why.rs
+++ b/src/cmd/why.rs
@@ -157,7 +157,9 @@ fn source_dir_for_task(task: &Task, ctx: &ProjectContext) -> Option<PathBuf> {
         TaskSource::GoPackage => tool::go_pm::find_file(&ctx.root),
         TaskSource::BaconToml => tool::files::find_first(&ctx.root, tool::bacon::FILENAMES),
         TaskSource::MiseToml => tool::mise::find_file(&ctx.root),
-        TaskSource::PyprojectScripts => tool::files::find_first(&ctx.root, &["pyproject.toml"]),
+        TaskSource::PyprojectScripts => {
+            tool::files::find_first_upwards(&ctx.root, &["pyproject.toml"])
+        }
     }
 }
 

From e8ed91fa0438e381b8cc6fd9a5e9f098d5ebc45b Mon Sep 17 00:00:00 2001
From: Kaj Kowalski <info@kajkowalski.nl>
Date: Thu, 4 Jun 2026 12:10:19 +0200
Subject: [PATCH 3/3] fix(pyproject): resolve scripts from nested dirs

Find pyproject.toml and Python PM signals upward so nested dirs list
PEP 621 scripts. Show Python PM resolution in `why` and include
pyproject.toml in `--source` help.
---
 src/cmd/list.rs         |  55 +++++++++++++---
 src/cmd/run.rs          |   2 +
 src/cmd/run/dispatch.rs |  63 ++++++++++++++++--
 src/cmd/why.rs          | 142 +++++++++++++++++++++++++++++++---------
 src/detect.rs           |  80 +++++++++++++++++-----
 src/tool/python.rs      |  34 ++++++++--
 src/types.rs            |  18 +++++
 7 files changed, 330 insertions(+), 64 deletions(-)

diff --git a/src/cmd/list.rs b/src/cmd/list.rs
index abb759c..8a240a2 100644
--- a/src/cmd/list.rs
+++ b/src/cmd/list.rs
@@ -37,10 +37,10 @@ pub(crate) fn list(
     let parsed_source = match source {
         None => None,
         Some(label) => Some(TaskSource::from_label(label).ok_or_else(|| {
+            let expected = expected_source_labels();
             anyhow!(
-                "--source {label:?}: unknown source label (expected one of: package.json, \
-                 make, just, task, turbo, deno, cargo, go, bacon, mise — legacy filename \
-                 forms like justfile/bacon.toml/Makefile are also accepted)",
+                "--source {label:?}: unknown source label (expected one of: {expected} — legacy \
+                 filename forms like justfile/bacon.toml/Makefile are also accepted)",
             )
         })?),
     };
@@ -80,6 +80,15 @@ pub(crate) fn list(
     Ok(())
 }
 
+fn expected_source_labels() -> String {
+    TaskSource::all()
+        .iter()
+        .copied()
+        .map(TaskSource::label)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum RenderMode {
     Rich,
@@ -475,7 +484,7 @@ fn source_path(source: TaskSource, root: &Path) -> Option<PathBuf> {
         }
         TaskSource::MiseToml => tool::mise::find_file(root),
         TaskSource::PyprojectScripts => {
-            tool::files::find_first_upwards(root, &["pyproject.toml"]).filter(|path| path.is_file())
+            tool::python::find_pyproject_upwards(root).filter(|path| path.is_file())
         }
     }?;
 
@@ -529,14 +538,16 @@ fn osc8_link(label: &str, url: &str) -> String {
 #[cfg(test)]
 mod tests {
     use std::fs;
-    use std::path::Path;
+    use std::path::{Path, PathBuf};
 
     use super::{
-        RenderMode, file_uri, render_rich_row, render_tasks_grouped, render_tasks_grouped_rich,
-        select_render_mode_for, source_label, source_path,
+        RenderMode, expected_source_labels, file_uri, render_rich_row, render_tasks_grouped,
+        render_tasks_grouped_rich, select_render_mode_for, source_label, source_path,
     };
+    use crate::resolver::ResolutionOverrides;
+    use crate::schema::CURRENT_VERSION;
     use crate::tool::test_support::TempDir;
-    use crate::types::{Task, TaskSource};
+    use crate::types::{ProjectContext, Task, TaskSource};
 
     #[test]
     fn source_path_finds_existing_config_variant() {
@@ -575,6 +586,34 @@ mod tests {
         assert!(path.ends_with("Taskfile.dist.yml"));
     }
 
+    #[test]
+    fn invalid_source_error_mentions_pyproject() {
+        let ctx = ProjectContext {
+            root: PathBuf::from("."),
+            package_managers: Vec::new(),
+            task_runners: Vec::new(),
+            tasks: Vec::new(),
+            node_version: None,
+            current_node: None,
+            is_monorepo: false,
+            warnings: Vec::new(),
+        };
+
+        let err = super::list(
+            &ctx,
+            &ResolutionOverrides::default(),
+            false,
+            false,
+            Some("wat"),
+            CURRENT_VERSION,
+        )
+        .expect_err("invalid source should error");
+
+        let message = format!("{err:#}");
+        assert!(message.contains("pyproject.toml"));
+        assert!(expected_source_labels().contains("pyproject.toml"));
+    }
+
     #[test]
     fn source_label_uses_osc8_when_terminal_and_file_exists() {
         let dir = TempDir::new("list-source-label-link");
diff --git a/src/cmd/run.rs b/src/cmd/run.rs
index c49142b..ffe2cfa 100644
--- a/src/cmd/run.rs
+++ b/src/cmd/run.rs
@@ -31,6 +31,8 @@ mod select;
 pub(crate) use qualify::{allowed_runner_sources, precheck_task, runner_constraint_error};
 pub(crate) use select::{select_task_entry, source_depth, source_priority};
 
+pub(crate) use dispatch::{ResolvedPythonPm, resolve_python_pm};
+
 use crate::resolver::ResolutionOverrides;
 use crate::types::ProjectContext;
 
diff --git a/src/cmd/run/dispatch.rs b/src/cmd/run/dispatch.rs
index 0a23ef4..0434022 100644
--- a/src/cmd/run/dispatch.rs
+++ b/src/cmd/run/dispatch.rs
@@ -20,7 +20,7 @@ use super::qualify::{
     runner_constraint_error,
 };
 use super::select::select_task_entry;
-use crate::resolver::{ResolutionOverrides, ResolveError, Resolver};
+use crate::resolver::{OverrideOrigin, ResolutionOverrides, ResolveError, Resolver};
 use crate::tool;
 use crate::types::{Ecosystem, PackageManager, ProjectContext, Task, TaskSource};
 
@@ -214,6 +214,38 @@ fn build_pm_exec_command(
     }
 }
 
+/// Python package manager decision for `[project.scripts]` dispatch.
+#[derive(Debug, Clone)]
+pub(crate) struct ResolvedPythonPm {
+    pub(crate) pm: PackageManager,
+    via: PythonPmResolution,
+}
+
+#[derive(Debug, Clone)]
+enum PythonPmResolution {
+    Override(OverrideOrigin),
+    DetectedProject,
+}
+
+impl ResolvedPythonPm {
+    pub(crate) fn describe(&self) -> String {
+        match &self.via {
+            PythonPmResolution::Override(OverrideOrigin::CliFlag) => {
+                format!("{} via --pm (CLI override)", self.pm.label())
+            }
+            PythonPmResolution::Override(OverrideOrigin::EnvVar) => {
+                format!("{} via RUNNER_PM (environment)", self.pm.label())
+            }
+            PythonPmResolution::Override(OverrideOrigin::ConfigFile { path }) => {
+                format!("{} via runner.toml at {}", self.pm.label(), path.display())
+            }
+            PythonPmResolution::DetectedProject => {
+                format!("{} via detected Python project", self.pm.label())
+            }
+        }
+    }
+}
+
 /// Bun special-case for `runner test` when the project has no
 /// `package.json` `test` script: forward to `bun test`.
 ///
@@ -283,12 +315,21 @@ fn build_run_command(
         TaskSource::BaconToml => tool::bacon::run_cmd(&entry.name, args),
         TaskSource::MiseToml => tool::mise::run_cmd(&entry.name, args),
         TaskSource::PyprojectScripts => {
-            let Some(pm) = resolve_python_pm(ctx, overrides) else {
+            let Some(decision) = resolve_python_pm(ctx, overrides) else {
                 bail!(
                     "no Python package manager detected to run {:?}; install uv, poetry, or pipenv",
                     entry.name,
                 );
             };
+            if overrides.explain {
+                eprintln!(
+                    "{} {} resolved: {}",
+                    "·".dimmed(),
+                    "runner".dimmed(),
+                    decision.describe(),
+                );
+            }
+            let pm = decision.pm;
             match pm {
                 PackageManager::Uv => tool::uv::run_cmd(&entry.name, args),
                 PackageManager::Poetry => tool::poetry::run_cmd(&entry.name, args),
@@ -305,22 +346,32 @@ fn build_run_command(
 /// detected for the project. A non-Python `--pm` (e.g. `--pm pnpm` in a
 /// mixed repo) is ignored here rather than forced, falling through to the
 /// detected Python PM.
-fn resolve_python_pm(
+pub(crate) fn resolve_python_pm(
     ctx: &ProjectContext,
     overrides: &ResolutionOverrides,
-) -> Option<PackageManager> {
+) -> Option<ResolvedPythonPm> {
     if let Some(o) = overrides.pm.as_ref()
         && o.pm.ecosystem() == Ecosystem::Python
     {
-        return Some(o.pm);
+        return Some(ResolvedPythonPm {
+            pm: o.pm,
+            via: PythonPmResolution::Override(o.origin.clone()),
+        });
     }
     if let Some(o) = overrides.pm_by_ecosystem.get(&Ecosystem::Python) {
-        return Some(o.pm);
+        return Some(ResolvedPythonPm {
+            pm: o.pm,
+            via: PythonPmResolution::Override(o.origin.clone()),
+        });
     }
     ctx.package_managers
         .iter()
         .copied()
         .find(|pm| pm.ecosystem() == Ecosystem::Python)
+        .map(|pm| ResolvedPythonPm {
+            pm,
+            via: PythonPmResolution::DetectedProject,
+        })
 }
 
 #[cfg(test)]
diff --git a/src/cmd/why.rs b/src/cmd/why.rs
index e2af27f..ac2d3bf 100644
--- a/src/cmd/why.rs
+++ b/src/cmd/why.rs
@@ -13,10 +13,10 @@ use colored::Colorize;
 use serde_json::{Value, json};
 
 use crate::cmd::run::{
-    allowed_runner_sources, runner_constraint_error, select_task_entry, source_depth,
-    source_priority,
+    ResolvedPythonPm, allowed_runner_sources, resolve_python_pm, runner_constraint_error,
+    select_task_entry, source_depth, source_priority,
 };
-use crate::resolver::{ResolutionOverrides, Resolver};
+use crate::resolver::{ResolutionOverrides, ResolveError, ResolvedPm, Resolver};
 use crate::types::{ProjectContext, Task, TaskSource};
 
 /// Explain how `task` would resolve in the current project.
@@ -53,14 +53,7 @@ pub(crate) fn why(
 
     let selected = (!restricted.is_empty()).then(|| select_task_entry(ctx, overrides, &restricted));
 
-    let pm_decision = if selected
-        .as_ref()
-        .is_some_and(|t| t.source == TaskSource::PackageJson)
-    {
-        Some(Resolver::new(ctx, overrides).resolve_node_pm())
-    } else {
-        None
-    };
+    let pm_decision = pm_decision_for_selected(ctx, overrides, selected);
 
     let report = build_report(
         task,
@@ -88,11 +81,35 @@ pub(crate) fn why(
     Ok(())
 }
 
+enum PmDecision {
+    Node(Result<ResolvedPm, ResolveError>),
+    Python(Result<ResolvedPythonPm, String>),
+}
+
+fn pm_decision_for_selected(
+    ctx: &ProjectContext,
+    overrides: &ResolutionOverrides,
+    selected: Option<&Task>,
+) -> Option<PmDecision> {
+    match selected.map(|task| task.source) {
+        Some(TaskSource::PackageJson) => {
+            Some(PmDecision::Node(Resolver::new(ctx, overrides).resolve_node_pm()))
+        }
+        Some(TaskSource::PyprojectScripts) => Some(PmDecision::Python(
+            resolve_python_pm(ctx, overrides).ok_or_else(|| {
+                "no Python package manager detected to run pyproject scripts; install uv, poetry, or pipenv"
+                    .to_string()
+            }),
+        )),
+        _ => None,
+    }
+}
+
 fn build_report(
     task: &str,
     candidates: &[&Task],
     selected: Option<&Task>,
-    pm_decision: Option<&Result<crate::resolver::ResolvedPm, crate::resolver::ResolveError>>,
+    pm_decision: Option<&PmDecision>,
     overrides: &ResolutionOverrides,
     ctx: &ProjectContext,
     schema_version: u32,
@@ -104,20 +121,30 @@ fn build_report(
             .map(|c| candidate_json(c, overrides, ctx, schema_version))
             .collect::<Vec<_>>(),
         "selected": selected.map(|s| candidate_json(s, overrides, ctx, schema_version)),
-        "pm_resolution": pm_decision.map(|res| match res {
-            Ok(decision) => json!({
-                "pm": decision.pm.label(),
-                "via": decision.describe(),
-                "warnings": decision.warnings.iter().map(|w| json!({
-                    "source": w.source(),
-                    "detail": w.detail(),
-                })).collect::<Vec<_>>(),
-            }),
-            Err(err) => json!({ "error": format!("{err}") }),
-        }),
+        "pm_resolution": pm_decision.map(pm_decision_json),
     })
 }
 
+fn pm_decision_json(decision: &PmDecision) -> Value {
+    match decision {
+        PmDecision::Node(Ok(decision)) => json!({
+            "pm": decision.pm.label(),
+            "via": decision.describe(),
+            "warnings": decision.warnings.iter().map(|w| json!({
+                "source": w.source(),
+                "detail": w.detail(),
+            })).collect::<Vec<_>>(),
+        }),
+        PmDecision::Node(Err(err)) => json!({ "error": format!("{err}") }),
+        PmDecision::Python(Ok(decision)) => json!({
+            "pm": decision.pm.label(),
+            "via": decision.describe(),
+            "warnings": [],
+        }),
+        PmDecision::Python(Err(err)) => json!({ "error": err }),
+    }
+}
+
 fn candidate_json(
     task: &Task,
     overrides: &ResolutionOverrides,
@@ -157,9 +184,7 @@ fn source_dir_for_task(task: &Task, ctx: &ProjectContext) -> Option<PathBuf> {
         TaskSource::GoPackage => tool::go_pm::find_file(&ctx.root),
         TaskSource::BaconToml => tool::files::find_first(&ctx.root, tool::bacon::FILENAMES),
         TaskSource::MiseToml => tool::mise::find_file(&ctx.root),
-        TaskSource::PyprojectScripts => {
-            tool::files::find_first_upwards(&ctx.root, &["pyproject.toml"])
-        }
+        TaskSource::PyprojectScripts => tool::python::find_pyproject_upwards(&ctx.root),
     }
 }
 
@@ -167,7 +192,7 @@ fn print_human(
     task: &str,
     candidates: &[&Task],
     selected: Option<&Task>,
-    pm_decision: Option<&Result<crate::resolver::ResolvedPm, crate::resolver::ResolveError>>,
+    pm_decision: Option<&PmDecision>,
     overrides: &ResolutionOverrides,
     ctx: &ProjectContext,
 ) {
@@ -233,15 +258,17 @@ fn print_human(
         println!();
         println!("{}", "PM resolution".bold());
         match res {
-            Ok(decision) => {
+            PmDecision::Node(Ok(decision)) => {
                 println!("  {}", decision.describe());
                 for w in &decision.warnings {
                     println!("  {} {w}", "warn:".yellow().bold());
                 }
             }
-            Err(err) => {
+            PmDecision::Node(Err(err)) => {
                 println!("  {} {err}", "error:".red().bold());
             }
+            PmDecision::Python(Ok(decision)) => println!("  {}", decision.describe()),
+            PmDecision::Python(Err(err)) => println!("  {} {err}", "error:".red().bold()),
         }
     }
 }
@@ -250,9 +277,9 @@ fn print_human(
 mod tests {
     use std::path::PathBuf;
 
-    use super::why;
+    use super::{PmDecision, build_report, pm_decision_for_selected, why};
     use crate::resolver::{DiagnosticFlags, ResolutionOverrides};
-    use crate::types::{ProjectContext, Task, TaskSource};
+    use crate::types::{PackageManager, ProjectContext, Task, TaskSource};
 
     fn context(tasks: Vec<Task>) -> ProjectContext {
         ProjectContext {
@@ -341,4 +368,57 @@ mod tests {
 
         assert!(format!("{err}").contains("no candidate task is registered"));
     }
+
+    #[test]
+    fn why_pyproject_script_reports_detected_python_pm() {
+        let mut ctx = context(vec![task("greenpy", TaskSource::PyprojectScripts)]);
+        ctx.package_managers.push(PackageManager::Uv);
+        let selected = ctx.tasks.first();
+        let pm_decision = pm_decision_for_selected(&ctx, &ResolutionOverrides::default(), selected)
+            .expect("pyproject task should resolve PM diagnostics");
+
+        let report = build_report(
+            "greenpy",
+            &[&ctx.tasks[0]],
+            selected,
+            Some(&pm_decision),
+            &ResolutionOverrides::default(),
+            &ctx,
+            crate::schema::CURRENT_VERSION,
+        );
+
+        assert_eq!(report["pm_resolution"]["pm"], serde_json::json!("uv"));
+        assert!(
+            report["pm_resolution"]["via"]
+                .as_str()
+                .is_some_and(|via| via.contains("detected Python project"))
+        );
+    }
+
+    #[test]
+    fn why_pyproject_script_reports_python_pm_override() {
+        let ctx = context(vec![task("greenpy", TaskSource::PyprojectScripts)]);
+        let overrides = ResolutionOverrides::from_cli_and_env(
+            Some("uv"),
+            None,
+            None,
+            None,
+            DiagnosticFlags::default(),
+            crate::cli::ChainFailureFlags::default(),
+            None,
+        )
+        .expect("PM override should parse");
+        let selected = ctx.tasks.first();
+        let pm_decision = pm_decision_for_selected(&ctx, &overrides, selected)
+            .expect("pyproject task should resolve PM diagnostics");
+
+        match pm_decision {
+            PmDecision::Python(Ok(decision)) => {
+                assert_eq!(decision.pm, PackageManager::Uv);
+                assert!(decision.describe().contains("--pm"));
+            }
+            PmDecision::Python(Err(err)) => panic!("override should resolve: {err}"),
+            PmDecision::Node(_) => panic!("pyproject script should use Python PM resolver"),
+        }
+    }
 }
diff --git a/src/detect.rs b/src/detect.rs
index 44b1668..3579ca9 100644
--- a/src/detect.rs
+++ b/src/detect.rs
@@ -8,8 +8,7 @@ use serde::Deserialize;
 
 use crate::tool;
 use crate::types::{
-    DetectionWarning, Ecosystem, NodeVersion, PackageManager, ProjectContext, Task, TaskRunner,
-    TaskSource,
+    DetectionWarning, NodeVersion, PackageManager, ProjectContext, Task, TaskRunner, TaskSource,
 };
 
 /// Scan `dir` for known config/lock files and return a populated [`ProjectContext`].
@@ -96,12 +95,8 @@ fn detect_package_managers(dir: &Path, ctx: &mut ProjectContext) {
     if tool::deno::detect(dir) {
         ctx.package_managers.push(PackageManager::Deno);
     }
-    if tool::uv::detect(dir) {
-        ctx.package_managers.push(PackageManager::Uv);
-    } else if tool::poetry::detect(dir) {
-        ctx.package_managers.push(PackageManager::Poetry);
-    } else if tool::pipenv::detect(dir) {
-        ctx.package_managers.push(PackageManager::Pipenv);
+    if let Some(pm) = detect_python_pm_upwards(dir) {
+        ctx.package_managers.push(pm);
     }
     if tool::go_pm::detect(dir) {
         ctx.package_managers.push(PackageManager::Go);
@@ -143,6 +138,23 @@ fn detect_node_pm_upwards(dir: &Path) -> Option<PackageManager> {
     })
 }
 
+/// Walk upward — VCS-bounded — for the Python package manager governing
+/// a nested project directory. Nearest ancestor wins; within one directory
+/// keep the same uv > poetry > pipenv priority as local detection.
+fn detect_python_pm_upwards(dir: &Path) -> Option<PackageManager> {
+    tool::files::find_in_ancestors(dir, |ancestor| {
+        if tool::uv::detect(ancestor) {
+            Some(PackageManager::Uv)
+        } else if tool::poetry::detect(ancestor) {
+            Some(PackageManager::Poetry)
+        } else if tool::pipenv::detect(ancestor) {
+            Some(PackageManager::Pipenv)
+        } else {
+            None
+        }
+    })
+}
+
 // Task runners
 
 /// Detect task runners by checking for their config files.
@@ -319,13 +331,10 @@ fn extract_tasks(dir: &Path, ctx: &mut ProjectContext) {
     let want_go_packages = ctx.package_managers.contains(&PackageManager::Go);
     let want_bacon = ctx.task_runners.contains(&TaskRunner::Bacon);
     let want_mise = ctx.task_runners.contains(&TaskRunner::Mise);
-    // `[project.scripts]` is shared PEP 621 metadata; surface it whenever
-    // any Python package manager (uv, poetry, pipenv) governs the project,
-    // since each dispatches the same entry points via its own `run`.
-    let want_pyproject_scripts = ctx
-        .package_managers
-        .iter()
-        .any(|pm| pm.ecosystem() == Ecosystem::Python);
+    // `[project.scripts]` is shared PEP 621 metadata. Task discovery only
+    // needs the manifest; PM choice is resolved later, so `--pm uv` or
+    // `[pm].python` can dispatch even without a lockfile.
+    let want_pyproject_scripts = tool::python::find_pyproject_upwards(dir).is_some();
 
     thread::scope(|s| {
         let pkg_json_h = want_pkg_json.then(|| {
@@ -779,6 +788,47 @@ mod tests {
         }));
     }
 
+    #[test]
+    fn detect_lists_pyproject_scripts_from_nested_uv_project() {
+        let dir = TempDir::new("detect-pyproject-nested-uv");
+        fs::create_dir_all(dir.path().join(".git")).expect("git dir should be created");
+        let nested = dir.path().join("src").join("pkg");
+        fs::create_dir_all(&nested).expect("nested dir should be created");
+        fs::write(dir.path().join("uv.lock"), "").expect("uv.lock should be written");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\nversion = \"0.1.0\"\n\n[project.scripts]\ngreenpy = \"greenpy.main:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let ctx = detect(&nested);
+
+        assert_eq!(ctx.package_managers, [crate::types::PackageManager::Uv]);
+        assert!(ctx.tasks.iter().any(|task| {
+            task.source == crate::types::TaskSource::PyprojectScripts && task.name == "greenpy"
+        }));
+    }
+
+    #[test]
+    fn detect_lists_pyproject_scripts_without_detected_python_pm() {
+        let dir = TempDir::new("detect-pyproject-scripts-no-pm");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\nversion = \"0.1.0\"\n\n[project.scripts]\ngreenpy = \"greenpy.main:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let ctx = detect(dir.path());
+
+        assert!(
+            ctx.package_managers.is_empty(),
+            "generic pyproject scripts do not imply a specific Python PM",
+        );
+        assert!(ctx.tasks.iter().any(|task| {
+            task.source == crate::types::TaskSource::PyprojectScripts && task.name == "greenpy"
+        }));
+    }
+
     #[test]
     fn detect_lists_pyproject_scripts_for_poetry_projects() {
         let dir = TempDir::new("detect-pyproject-scripts-poetry");
diff --git a/src/tool/python.rs b/src/tool/python.rs
index 001e6e3..c71b901 100644
--- a/src/tool/python.rs
+++ b/src/tool/python.rs
@@ -1,7 +1,7 @@
 //! Shared Python tooling helpers.
 
 use std::collections::BTreeMap;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use anyhow::Context as _;
 use serde::Deserialize;
@@ -28,6 +28,8 @@ const PROJECT_MARKERS: &[&str] = &[
     "uv.lock",
 ];
 
+const PYPROJECT_FILENAMES: &[&str] = &["pyproject.toml"];
+
 /// Detected via common Python project markers.
 pub(crate) fn detect(dir: &Path) -> bool {
     PROJECT_MARKERS.iter().any(|name| dir.join(name).exists()) || has_python_pyproject(dir)
@@ -64,6 +66,12 @@ pub(crate) fn clean_dirs(dir: &Path) -> Vec<String> {
     dirs
 }
 
+/// Find the nearest `pyproject.toml` at `dir` or above, bounded by the
+/// containing VCS root when one exists.
+pub(crate) fn find_pyproject_upwards(dir: &Path) -> Option<PathBuf> {
+    super::files::find_first_upwards(dir, PYPROJECT_FILENAMES)
+}
+
 /// Extract `[project.scripts]` entry points (PEP 621 console scripts)
 /// from `pyproject.toml`, each paired with its entry-point target as a
 /// description (e.g. `("greenpy", Some("greenpy.main:main"))`).
@@ -80,10 +88,9 @@ pub(crate) fn clean_dirs(dir: &Path) -> Vec<String> {
 pub(crate) fn extract_pyproject_scripts(
     dir: &Path,
 ) -> anyhow::Result<Vec<(String, Option<String>)>> {
-    let path = dir.join("pyproject.toml");
-    if !path.exists() {
+    let Some(path) = find_pyproject_upwards(dir) else {
         return Ok(vec![]);
-    }
+    };
     let content = std::fs::read_to_string(&path)
         .with_context(|| format!("failed to read {}", path.display()))?;
     let doc: PyprojectDoc =
@@ -182,6 +189,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn extract_scripts_reads_nearest_upward_pyproject() {
+        let dir = TempDir::new("pyproject-upwards");
+        let nested = dir.path().join("src").join("pkg");
+        fs::create_dir_all(&nested).expect("nested dir should be created");
+        fs::write(
+            dir.path().join("pyproject.toml"),
+            "[project]\nname = \"greenpy\"\n\n[project.scripts]\ngreenpy = \"greenpy.main:main\"\n",
+        )
+        .expect("pyproject.toml should be written");
+
+        let scripts = extract_pyproject_scripts(&nested).expect("scripts should parse");
+
+        assert_eq!(
+            scripts,
+            [("greenpy".to_string(), Some("greenpy.main:main".to_string()))]
+        );
+    }
+
     #[test]
     fn extract_scripts_surfaces_parse_error_for_malformed_toml() {
         let dir = TempDir::new("pyproject-malformed");
diff --git a/src/types.rs b/src/types.rs
index c06fceb..113ae49 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -550,6 +550,24 @@ impl TaskRunner {
 }
 
 impl TaskSource {
+    /// Every task source in display order. Used by renderers and error
+    /// messages so adding a source updates diagnostics from one place.
+    pub(crate) const fn all() -> &'static [Self] {
+        &[
+            Self::PackageJson,
+            Self::Makefile,
+            Self::Justfile,
+            Self::Taskfile,
+            Self::TurboJson,
+            Self::DenoJson,
+            Self::CargoAliases,
+            Self::GoPackage,
+            Self::BaconToml,
+            Self::MiseToml,
+            Self::PyprojectScripts,
+        ]
+    }
+
     /// Canonical display label shown to the user — the *tool* name where a
     /// single tool owns the source (`"make"`, `"just"`, `"bacon"`, …), or
     /// the filename when multiple tools share the source (`"package.json"`