diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f174ee..7c087fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,16 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 
 ## [Unreleased]
 
+### Release checklist
+
+- [ ] Bump `Cargo.toml`; MUST run `cargo check` without `--locked` to update `Cargo.lock`.
+- [ ] Update current-version references in `schemas/`, both AUR `PKGBUILD`s, and `README.md` container-image tags.
+- [ ] Search repository-wide for the old version; account for every match.
+- [ ] Move `Unreleased` entries into the new version section and rotate links.
+- [ ] Create and push a signed `vX.Y.Z` tag from `master`.
+
+## [0.24.1] - 2026-08-03
+
 ### Added
 
 - Container images on GHCR (`ghcr.io/kjanat/runner`) and Docker Hub
@@ -21,6 +31,13 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 
 ### Fixed
 
+- Bun package-exec fallback now invokes the explicit `bun x` subcommand instead
+  of the `bunx` hard-link alias. On Windows, runner resolves bare executables
+  through `PATH` and `PATHEXT`; the stock uppercase `.EXE` produced `bunx.EXE`,
+  which Bun's case-sensitive invocation-name detection misclassified as plain
+  `bun` and reported `Script not found` for the requested package
+  (https://github.com/kjanat/runner/issues/103,
+  https://github.com/oven-sh/bun/issues/36826).
 - `install.sh` now completes on Alpine and other busybox userlands. Checksum
   verification called `sha256sum -c --status`, and `--status` is GNU-only, so
   busybox aborted the install right after downloading the archive
@@ -28,12 +45,6 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
   sha256sum` guard passes on busybox, which is why the failure surfaced
   mid-install rather than up front.
 
-### Post-release checklist
-
-- [ ] Move completed `Unreleased` items into a new version section.
-- [ ] Update the `[Unreleased]` compare link to the new tag.
-- [ ] Create and push a signed `vX.Y.Z` tag from `master`.
-
 ## [0.24.0] - 2026-08-01
 
 ### Added
@@ -1985,7 +1996,8 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 - `run` alias binary for shorter invocation.
 - Unified commands for task run/list, dependency install, clean, and exec.
 
-[Unreleased]: https://github.com/kjanat/runner/compare/v0.24.0...HEAD
+[Unreleased]: https://github.com/kjanat/runner/compare/v0.24.1...HEAD
+[0.24.1]: https://github.com/kjanat/runner/compare/v0.24.0...v0.24.1
 [0.24.0]: https://github.com/kjanat/runner/compare/v0.23.0...v0.24.0
 [0.23.0]: https://github.com/kjanat/runner/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/kjanat/runner/compare/v0.21.0...v0.22.0
diff --git a/Cargo.lock b/Cargo.lock
index 88777f8..898ce04 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -774,7 +774,7 @@ checksum = "323c417e1d9665a65b263ec744ba09030cfb277e9daa0b018a4ab62e57bc8189"
 
 [[package]]
 name = "runner-run"
-version = "0.24.0"
+version = "0.24.1"
 dependencies = [
  "actions-rs",
  "anyhow",
diff --git a/Cargo.toml b/Cargo.toml
index 1c9944d..7cdb2a5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 
 [package]
 name          = "runner-run"
-version       = "0.24.0"
+version       = "0.24.1"
 edition       = "2024"
 rust-version  = "1.95"
 description   = "Universal project task runner"
diff --git a/README.md b/README.md
index 3ae2fde..44333f3 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ And re-read/review the readme...
 **runner** is for people who bounce between codebases and refuse to memorize
 each repo’s private little task-running religion.
 
-Instead of guessing whether this one wants `npm run`, `pnpm exec`, `bunx`,
+Instead of guessing whether this one wants `npm run`, `pnpm exec`, `bun x`,
 `cargo`, `uv run`, `deno task`, `turbo`, `make`, `just`, etc. type:
 
 ```sh
@@ -170,12 +170,12 @@ yay -S runner-run
 
 ```dockerfile
 # Container image, for build stages that run `run`-form package scripts:
-COPY --from=ghcr.io/kjanat/runner:0.24.0 /run /usr/local/bin/run
-COPY --from=ghcr.io/kjanat/runner:0.24.0 /runner /usr/local/bin/runner
+COPY --from=ghcr.io/kjanat/runner:0.24.1 /run /usr/local/bin/run
+COPY --from=ghcr.io/kjanat/runner:0.24.1 /runner /usr/local/bin/runner
 ```
 
-Also on Docker Hub as `kjanat/runner`. The image is `scratch` plus two
-musl-static binaries, so one tag serves Alpine and Debian stages alike.
+Also on Docker Hub as [`kjanat/runner`][dockerhub]. The image is `scratch` plus
+two musl-static binaries, so one tag serves Alpine and Debian stages alike.
 
 ```sh
 # One-liner (latest):
@@ -380,7 +380,7 @@ Failing that, it executes `<target>` through the detected toolchain where
 appropriate, such as:
 
 ```text
-npm exec / npx, yarn run / yarn exec, pnpm exec, bun x / bunx,
+npm exec / npx, yarn run / yarn exec, pnpm exec, bun x,
 deno x, uvx, go run
 ```
 
@@ -401,13 +401,13 @@ manager gets no vote:
 | `--runtime` | `package.json` script  | local file        | ad-hoc binary |
 | ----------- | ---------------------- | ----------------- | ------------- |
 | `node`      | `node --run <task>`    | `node <file>`     | `npx`         |
-| `bun`       | `bun --bun run <task>` | `bun <file>`      | `bunx --bun`  |
+| `bun`       | `bun --bun run <task>` | `bun <file>`      | `bun x --bun` |
 | `deno`      | `deno task <task>`     | `deno run <file>` | `deno x`      |
 
 ```sh
 run --runtime bun build      # bun --bun run build
 run --runtime bun ./cli.js   # bun ./cli.js, even with a #!/usr/bin/env node line
-run --runtime bun eslint .   # bunx --bun eslint .
+run --runtime bun eslint .   # bun x --bun eslint .
 ```
 
 `bun run build` starts the script under bun, but a dependency bin carrying a
diff --git a/aur/runner-run-bin/PKGBUILD b/aur/runner-run-bin/PKGBUILD
index 807de97..9eaf06d 100644
--- a/aur/runner-run-bin/PKGBUILD
+++ b/aur/runner-run-bin/PKGBUILD
@@ -5,7 +5,7 @@
 # by CI (.github/workflows/aur-release.yml) on every release; the values below
 # are only a checked-in reference snapshot.
 pkgname=runner-run-bin
-pkgver=0.24.0
+pkgver=0.24.1
 pkgrel=1
 pkgdesc='Universal project task runner (prebuilt binary)'
 arch=('x86_64' 'aarch64' 'armv7h')
diff --git a/aur/runner-run/PKGBUILD b/aur/runner-run/PKGBUILD
index 182329b..a08433b 100644
--- a/aur/runner-run/PKGBUILD
+++ b/aur/runner-run/PKGBUILD
@@ -5,7 +5,7 @@
 # CI (.github/workflows/aur-release.yml) on every release; the values below
 # are only a checked-in reference snapshot.
 pkgname=runner-run
-pkgver=0.24.0
+pkgver=0.24.1
 pkgrel=1
 pkgdesc='Universal project task runner'
 arch=('x86_64' 'aarch64')
diff --git a/npm/facade/README.md b/npm/facade/README.md
index d8d31c8..6f5a320 100644
--- a/npm/facade/README.md
+++ b/npm/facade/README.md
@@ -15,7 +15,7 @@ runner install --frozen test build
 ```
 
 Instead of remembering whether this project wants `npm run`, `pnpm exec`,
-`bunx`, `cargo`, `uv run`, `deno task`, `make`, `just`, `go-task`, or a monorepo
+`bun x`, `cargo`, `uv run`, `deno task`, `make`, `just`, `go-task`, or a monorepo
 wrapper, use the same shape everywhere.
 
 ## What You Get
diff --git a/schemas/doctor.example.json b/schemas/doctor.example.json
index efc2a98..ebe541c 100644
--- a/schemas/doctor.example.json
+++ b/schemas/doctor.example.json
@@ -23,7 +23,7 @@
   "runner": {
     "binary": "/usr/local/bin/runner",
     "name": "runner",
-    "version": "0.24.0",
+    "version": "0.24.1",
     "schema_versions": {
       "doctor": 2,
       "list": 2,
diff --git a/schemas/doctor.schema.json b/schemas/doctor.schema.json
index 0b429f0..e06d108 100644
--- a/schemas/doctor.schema.json
+++ b/schemas/doctor.schema.json
@@ -412,7 +412,7 @@
           "const": "node"
         },
         {
-          "description": "Bun, via `bun --bun run <script>`, `bun <file>` and `bunx --bun`.",
+          "description": "Bun, via `bun --bun run <script>`, `bun <file>` and `bun x --bun`.",
           "type": "string",
           "const": "bun"
         },
diff --git a/site/src/index.html b/site/src/index.html
index 08ee388..cfdd700 100644
--- a/site/src/index.html
+++ b/site/src/index.html
@@ -206,7 +206,7 @@ <h3>Task sources · 8</h3>
 					</li>
 					<li>Monorepo-aware: turbo, nx, pnpm, npm/yarn workspaces, Cargo workspaces.</li>
 					<li>
-						No task by that name? Falls through to the package manager's exec primitive, <code>npx</code>, <code>bunx</code>, <code>pnpm exec</code>,
+						No task by that name? Falls through to the package manager's exec primitive, <code>npx</code>, <code>bun x</code>, <code>pnpm exec</code>,
 						<code>uv run</code>, etc.
 					</li>
 				</ol>
diff --git a/src/cli.rs b/src/cli.rs
index a8fce5d..36b8413 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -144,7 +144,7 @@ static RUNTIME_LONG_HELP: LazyLock<String> = LazyLock::new(|| {
             cyan_str("node")
         ),
         &format!(
-            "  {}   bun --bun run <task>  bun <file>        bunx --bun",
+            "  {}   bun --bun run <task>  bun <file>        bun x --bun",
             cyan_str("bun")
         ),
         &format!(
@@ -1410,7 +1410,7 @@ pub(crate) struct GlobalOpts {
     /// Force the JavaScript runtime a task's process tree runs on, an axis
     /// distinct from `--pm`. Each runtime brings its own script runner
     /// (`node --run` / `bun --bun run` / `deno task`), file runner and
-    /// package-exec primitive (`npx` / `bunx --bun` / `deno x`), and outranks
+    /// package-exec primitive (`npx` / `bun x --bun` / `deno x`), and outranks
     /// a local file's `#!` line. No package manager is consulted. The resolver
     /// also consults `$RUNNER_RUNTIME` and `[runtime].js` when this flag is
     /// omitted.
diff --git a/src/cmd/run.rs b/src/cmd/run.rs
index b0845bb..947bc98 100644
--- a/src/cmd/run.rs
+++ b/src/cmd/run.rs
@@ -53,7 +53,7 @@ use crate::types::ProjectContext;
 /// Resolve `task` and run it with inherited stdio, returning the exit
 /// code. Bun special case: when `task == "test"` and no package-manifest
 /// `test` script exists, falls back to `bun test`. PM-exec fallback for
-/// unqualified misses runs the target through `npx`/`bunx`/`pnpm exec`/
+/// unqualified misses runs the target through `npx`/`bun x`/`pnpm exec`/
 /// `deno x`/`uvx`, plus `go run` for Go module/path-shaped targets;
 /// otherwise spawns the binary directly from `PATH`.
 pub(crate) fn run(
diff --git a/src/cmd/run/dispatch.rs b/src/cmd/run/dispatch.rs
index 7c8c632..5e0cbee 100644
--- a/src/cmd/run/dispatch.rs
+++ b/src/cmd/run/dispatch.rs
@@ -7,7 +7,7 @@
 //! - bun-test special case: `runner test` with no `package.json` script
 //!   forwards to `bun test` directly;
 //! - PM-exec fallback: no task matched, so the token is run through
-//!   `npx`/`bunx`/`pnpm exec`/`deno x`/`uvx` or spawned from `$PATH`
+//!   `npx`/`bun x`/`pnpm exec`/`deno x`/`uvx` or spawned from `$PATH`
 //!   directly when the resolver landed on a PM without an exec primitive.
 
 use std::process::Command;
@@ -219,7 +219,7 @@ pub(super) fn resolve_dispatch(
             // strict devEngines/`packageManager` mismatch, an incompatible
             // `--pm`); running `main.ts` via its runtime doesn't need the
             // package.json PM. Tasks already matched above (`restricted` is empty
-            // here), so this never shadows a same-named task, and `bunx`/`npx`
+            // here), so this never shadows a same-named task, and `bun x`/`npx`
             // never sees a local file.
             if let Some(local) = super::local_file::try_bare_file(ctx, overrides, task_name, args)?
             {
@@ -249,7 +249,7 @@ pub(super) fn resolve_dispatch(
 
         // Qualified miss (colon or FQN syntax): the qualifier is explicit
         // task-lookup intent, so error here, never fall through to
-        // PM-exec, which would hand the token to bunx/npx as a package
+        // PM-exec, which would hand the token to bun x/npx as a package
         // spec and resolve it off the network.
         return Err(qualified_miss_error(ctx, missed_source, task_name));
     }
@@ -336,7 +336,7 @@ fn dispatch_after_miss(
 }
 
 /// The exec primitive's argument vector: the token followed by the user's
-/// args, as `npx`/`bunx`/`deno x`/`uvx` all take it.
+/// args, as `npx`/`bun x`/`deno x`/`uvx` all take it.
 fn exec_argv(task_name: &str, args: &[String]) -> Vec<String> {
     let mut v = Vec::with_capacity(args.len() + 1);
     v.push(task_name.to_string());
@@ -363,7 +363,7 @@ fn build_pm_exec_command(
         Some(PackageManager::Npm) => ("npx", tool::npm::exec_cmd(&combined())),
         Some(PackageManager::Yarn) => ("yarn exec", tool::yarn::exec_cmd(&ctx.root, &combined())),
         Some(PackageManager::Pnpm) => ("pnpm exec", tool::pnpm::exec_cmd(&combined())),
-        Some(PackageManager::Bun) => ("bunx", tool::bun::exec_cmd(&combined())),
+        Some(PackageManager::Bun) => ("bun x", tool::bun::exec_cmd(&combined())),
         Some(PackageManager::Deno) => ("deno x", tool::deno::exec_cmd(&combined())),
         Some(PackageManager::Uv) => ("uvx", tool::uv::exec_cmd(&combined())),
         Some(PackageManager::Go) => {
@@ -682,7 +682,7 @@ mod tests {
     #[test]
     fn resolve_dispatch_fqn_miss_errors_instead_of_pm_exec() {
         // Previously `run root:package.json#nope` fell through to
-        // PM-exec and bunx tried to resolve it as a GitHub package spec
+        // PM-exec and bun x tried to resolve it as a GitHub package spec
         // off the network. A `#` FQN miss must be a hard error.
         let err = resolve_dispatch(
             &context(),
@@ -699,7 +699,7 @@ mod tests {
 
     #[test]
     fn resolve_dispatch_github_spec_still_reaches_pm_exec() {
-        // `user/repo#ref` is a legit bunx/npx package spec; its prefix
+        // `user/repo#ref` is a legit bun x/npx package spec; its prefix
         // is not a source label, so it must keep flowing to PM-exec.
         let dispatch = resolve_dispatch(
             &context(),
diff --git a/src/cmd/run/local_file.rs b/src/cmd/run/local_file.rs
index fb54525..42cfb68 100644
--- a/src/cmd/run/local_file.rs
+++ b/src/cmd/run/local_file.rs
@@ -1,7 +1,7 @@
 //! Local-file execution for `run <path>`.
 //!
 //! A token that points at a local file should be *run as that file*, never
-//! handed to a package manager's package-exec primitive (`bunx`/`npx`/
+//! handed to a package manager's package-exec primitive (`bun x`/`npx`/
 //! `pnpm dlx`/`deno x`/`uvx`), which would resolve a local path as a remote
 //! package spec and fail with a registry 404 or a `git clone` error.
 //!
@@ -1208,9 +1208,9 @@ mod tests {
 
         // A recognized source file at mode 0111 (execute-only). The shebang
         // probe hits EACCES, but that must NOT propagate as an error (which
-        // `bare_file_in`'s `.ok()` would swallow into a `bunx main.ts` 404).
+        // `bare_file_in`'s `.ok()` would swallow into a `bun x main.ts` 404).
         // It routes through the detected runtime instead, upholding the
-        // no-bunx-on-a-local-file invariant.
+        // no-bun-x-on-a-local-file invariant.
         let dir = TempDir::new("local-exec-only-ts");
         let file = dir.path().join("main.ts");
         std::fs::write(&file, "console.log(1)\n").expect("file should be written");
@@ -1227,7 +1227,7 @@ mod tests {
         )
         .expect("an execute-only source file should route to its runtime");
 
-        assert_eq!(label, "bun", "a 0111 .ts routes to bun, never bunx");
+        assert_eq!(label, "bun", "a 0111 .ts routes to bun, never bun x");
         assert_eq!(command.get_program().to_string_lossy(), "bun");
     }
 
@@ -1552,7 +1552,7 @@ mod tests {
     #[test]
     fn bare_file_missing_token_falls_through_to_pm_exec() {
         // A bare token with no matching file on disk is a real package-spec
-        // candidate (`runner biome` → `bunx biome`), so it keeps falling
+        // candidate (`runner biome` → `bun x biome`), so it keeps falling
         // through to the PM-exec fallback rather than erroring.
         let dir = TempDir::new("bare-file-miss");
         let ctx = context(vec![PackageManager::Bun]);
@@ -1571,7 +1571,7 @@ mod tests {
         // Once the token names an existing regular file it is a local file: an
         // unsupported one (`data.bin`, no extension we run, no shebang, not
         // executable) surfaces the clear local-file error instead of falling
-        // through to `bunx data.bin` and a registry 404, matching the explicit
+        // through to `bun x data.bin` and a registry 404, matching the explicit
         // `./data.bin` form (#69).
         let dir = TempDir::new("bare-file-unsupported");
         std::fs::write(dir.path().join("data.bin"), [0u8, 1, 2]).expect("file should be written");
@@ -1678,7 +1678,7 @@ mod tests {
         // dir / `--dir` target), not the live process cwd; a `main.ts` under
         // the project root runs even when the shell cwd is elsewhere. This is
         // what stops a `--dir`-set run from missing the file and mis-routing
-        // into the `bunx main.ts` 404 fallback (issue #69).
+        // into the package-manager exec fallback (issue #69).
         let dir = TempDir::new("bare-root");
         std::fs::write(dir.path().join("main.ts"), "console.log(1)\n")
             .expect("file should be written");
diff --git a/src/cmd/run/qualify.rs b/src/cmd/run/qualify.rs
index b0b613d..98affaf 100644
--- a/src/cmd/run/qualify.rs
+++ b/src/cmd/run/qualify.rs
@@ -44,7 +44,7 @@ pub(super) fn parse_fqn_task(input: &str) -> Option<(TaskSource, &str)> {
 /// A `Some` qualifier, whether from colon or FQN syntax, pins the
 /// lookup to that source; the caller errors on a miss instead of
 /// falling through to PM-exec. That property is what keeps an FQN typo
-/// (`root:package.json#nope`) from being handed to bunx/npx as a
+/// (`root:package.json#nope`) from being handed to bun x/npx as a
 /// package spec and resolved off the network.
 pub(crate) struct TokenLookup<'a> {
     /// Pinned source from `source:task` or FQN (`root:source#task`) syntax.
@@ -388,7 +388,7 @@ mod tests {
 
     #[test]
     fn parse_fqn_task_leaves_package_specs_alone() {
-        // bunx/npx GitHub specs share the `#` separator; anything whose
+        // bun x/npx GitHub specs share the `#` separator; anything whose
         // prefix isn't a source label must keep flowing to PM-exec.
         assert_eq!(parse_fqn_task("user/repo#ref"), None);
         assert_eq!(parse_fqn_task("root:unknown#x"), None);
diff --git a/src/cmd/run/runtime.rs b/src/cmd/run/runtime.rs
index be1d1fe..29e5406 100644
--- a/src/cmd/run/runtime.rs
+++ b/src/cmd/run/runtime.rs
@@ -11,7 +11,7 @@
 //! | runtime | script                  | file            | exec         |
 //! |---------|-------------------------|-----------------|--------------|
 //! | node    | `node --run <task> --`  | `node <file>`   | `npx`        |
-//! | bun     | `bun --bun run <task>`  | `bun <file>`    | `bunx --bun` |
+//! | bun     | `bun --bun run <task>`  | `bun <file>`    | `bun x --bun` |
 //! | deno    | `deno task <task>`      | `deno run <file>` | `deno x`   |
 //!
 //! Argument forwarding differs per runtime and is not interchangeable.
@@ -50,14 +50,14 @@ pub(super) fn script_cmd(
 pub(super) fn exec_cmd(runtime: JsRuntime, argv: &[String]) -> (&'static str, Command) {
     match runtime {
         JsRuntime::Node => ("npx", tool::npm::exec_cmd(argv)),
-        JsRuntime::Bun => ("bunx", tool::bun::exec_cmd_with_runtime(argv, true)),
+        JsRuntime::Bun => ("bun x", tool::bun::exec_cmd_with_runtime(argv, true)),
         JsRuntime::Deno => ("deno x", tool::deno::exec_cmd(argv)),
     }
 }
 
 /// Whether the runtime axis replaces the exec primitive the resolver picked.
 ///
-/// It replaces a JS one (`npx`, `yarn exec`, `pnpm exec`, `bunx`, `deno x`)
+/// It replaces a JS one (`npx`, `yarn exec`, `pnpm exec`, `bun x`, `deno x`)
 /// and a resolver that found nothing at all. A Python/Go/Rust/Ruby/PHP
 /// project's exec primitive is left alone: there is no JS process to move.
 pub(super) fn replaces_exec(resolved_pm: Option<PackageManager>) -> bool {
@@ -205,6 +205,18 @@ mod tests {
             .collect()
     }
 
+    fn assert_program(cmd: &std::process::Command, expected: &str) {
+        let stem = std::path::Path::new(cmd.get_program())
+            .file_stem()
+            .expect("runtime command should have a file stem")
+            .to_string_lossy();
+        assert!(
+            stem.eq_ignore_ascii_case(expected),
+            "expected {expected} executable, got {:?}",
+            cmd.get_program()
+        );
+    }
+
     fn script(runtime: JsRuntime, args: &[String]) -> (String, Vec<String>) {
         let cmd = script_cmd(runtime, "build", args, HostVerbosity::default());
         (cmd.get_program().to_string_lossy().into_owned(), argv(&cmd))
@@ -245,17 +257,17 @@ mod tests {
 
         let (label, cmd) = exec_cmd(JsRuntime::Node, &argv_in);
         assert_eq!(label, "npx");
-        assert_eq!(cmd.get_program().to_string_lossy(), "npx");
+        assert_program(&cmd, "npx");
         assert_eq!(argv(&cmd), ["eslint", "."]);
 
         let (label, cmd) = exec_cmd(JsRuntime::Bun, &argv_in);
-        assert_eq!(label, "bunx");
-        assert_eq!(cmd.get_program().to_string_lossy(), "bunx");
-        assert_eq!(argv(&cmd), ["--bun", "eslint", "."]);
+        assert_eq!(label, "bun x");
+        assert_program(&cmd, "bun");
+        assert_eq!(argv(&cmd), ["x", "--bun", "eslint", "."]);
 
         let (label, cmd) = exec_cmd(JsRuntime::Deno, &argv_in);
         assert_eq!(label, "deno x");
-        assert_eq!(cmd.get_program().to_string_lossy(), "deno");
+        assert_program(&cmd, "deno");
         assert_eq!(argv(&cmd), ["x", "eslint", "."]);
     }
 
diff --git a/src/tool/bun.rs b/src/tool/bun.rs
index 9760025..52f5bf4 100644
--- a/src/tool/bun.rs
+++ b/src/tool/bun.rs
@@ -68,17 +68,23 @@ pub(crate) fn install_cmd(frozen: bool, scripts: ScriptDirective) -> Command {
     c
 }
 
-/// `bunx <args...>`
+/// `bun x <args...>`
 pub(crate) fn exec_cmd(args: &[String]) -> Command {
     exec_cmd_with_runtime(args, false)
 }
 
-/// `bunx [--bun] <args...>`
+/// `bun x [--bun] <args...>`
 ///
-/// `--bun` is bunx's counterpart to `bun --bun run`: without it a package whose
+/// `--bun` is bun x's counterpart to `bun --bun run`: without it a package whose
 /// bin carries a `#!/usr/bin/env node` shebang still executes on system Node.
 pub(crate) fn exec_cmd_with_runtime(args: &[String], force_bun_runtime: bool) -> Command {
-    let mut c = super::program::command("bunx");
+    // Use bun's explicit subcommand instead of the `bunx` hard-link alias.
+    // Bun selects alias mode from its invoked filename case-sensitively;
+    // Windows' stock uppercase `.EXE` in PATHEXT made runner resolve the alias
+    // as `bunx.EXE`, which Bun misclassified as plain `bun` (issues #103 and
+    // oven-sh/bun#36826).
+    let mut c = super::program::command("bun");
+    c.arg("x");
     if force_bun_runtime {
         c.arg("--bun");
     }
@@ -87,7 +93,7 @@ pub(crate) fn exec_cmd_with_runtime(args: &[String], force_bun_runtime: bool) ->
 }
 
 /// `bun <file> [args...]`, execute a local script file with the Bun
-/// runtime. Distinct from [`exec_cmd`] (`bunx`), which fetches and runs a
+/// runtime. Distinct from [`exec_cmd`] (`bun x`), which fetches and runs a
 /// remote package; this runs an on-disk path the caller already resolved.
 pub(crate) fn run_file_cmd(file: &Path, args: &[String]) -> Command {
     let mut c = super::program::command("bun");
@@ -110,28 +116,35 @@ mod tests {
             .collect()
     }
 
+    fn assert_bun_program(cmd: &std::process::Command) {
+        let stem = Path::new(cmd.get_program())
+            .file_stem()
+            .expect("bun command should have a file stem")
+            .to_string_lossy();
+        assert!(
+            stem.eq_ignore_ascii_case("bun"),
+            "expected bun executable, got {:?}",
+            cmd.get_program()
+        );
+    }
+
     #[test]
     fn exec_forced_runtime_prepends_bun_flag() {
-        // `bunx --bun`: without it a package bin with a node shebang still runs
+        // `bun x --bun`: without it a package bin with a node shebang still runs
         // on system Node, defeating `--runtime bun`.
         let args = [String::from("eslint"), String::from(".")];
-        assert_eq!(
-            args_of(&exec_cmd_with_runtime(&args, true)),
-            ["--bun", "eslint", "."]
-        );
+        let cmd = exec_cmd_with_runtime(&args, true);
+        assert_bun_program(&cmd);
+        assert_eq!(args_of(&cmd), ["x", "--bun", "eslint", "."]);
     }
 
     #[test]
-    fn exec_unforced_is_plain_bunx() {
+    fn exec_unforced_is_bun_x() {
         let args = [String::from("eslint"), String::from(".")];
-        assert_eq!(
-            args_of(&exec_cmd_with_runtime(&args, false)),
-            ["eslint", "."]
-        );
-        assert_eq!(
-            args_of(&exec_cmd(&args)),
-            args_of(&exec_cmd_with_runtime(&args, false))
-        );
+        let cmd = exec_cmd_with_runtime(&args, false);
+        assert_bun_program(&cmd);
+        assert_eq!(args_of(&cmd), ["x", "eslint", "."]);
+        assert_eq!(args_of(&exec_cmd(&args)), args_of(&cmd));
     }
 
     #[test]
@@ -190,7 +203,7 @@ mod tests {
             .map(|arg| arg.to_string_lossy().into_owned())
             .collect();
 
-        assert_eq!(cmd.get_program().to_string_lossy(), "bun");
+        assert_bun_program(&cmd);
         assert_eq!(built, ["/abs/script.ts", "--flag"]);
     }
 }
diff --git a/src/types.rs b/src/types.rs
index 533e1de..8724516 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -128,7 +128,7 @@ pub(crate) enum JsRuntime {
     /// `npm run`, `bun run` and `deno task` all execute; runner warns when the
     /// task being dispatched has one.
     Node,
-    /// Bun, via `bun --bun run <script>`, `bun <file>` and `bunx --bun`.
+    /// Bun, via `bun --bun run <script>`, `bun <file>` and `bun x --bun`.
     Bun,
     /// Deno, via `deno task <script>` (which reads `package.json` scripts as
     /// well as `deno.json` tasks), `deno run <file>` and `deno x`.
diff --git a/tests/runtime_override.rs b/tests/runtime_override.rs
index 507cf8a..92c8eea 100644
--- a/tests/runtime_override.rs
+++ b/tests/runtime_override.rs
@@ -387,7 +387,7 @@ fn runtime_selects_the_exec_fallback_primitive() {
     // exec primitive, which used to be the resolved PM's regardless.
     let proj = probe_project("exec");
 
-    for (runtime, expected) in [("node", "npx"), ("bun", "bunx"), ("deno", "deno x")] {
+    for (runtime, expected) in [("node", "npx"), ("bun", "bun x"), ("deno", "deno x")] {
         let output = arrow_only(
             proj.path(),
             &["--runtime", runtime, "definitely-not-a-real-tool-xyz"],