diff --git a/.ai/skills/hack-repo-verify/SKILL.md b/.ai/skills/hack-repo-verify/SKILL.md
index 4b01408db..bd075c080 100644
--- a/.ai/skills/hack-repo-verify/SKILL.md
+++ b/.ai/skills/hack-repo-verify/SKILL.md
@@ -33,8 +33,24 @@ For native setup use root `mise.toml`, the Bun pin in `package.json`, and
 `bun install --frozen-lockfile`. Native gates are `bun run typecheck`, `bun run check`,
 `bun run test`. Focused CLI checks: `bun run --cwd packages/cli typecheck` and
 `bun run --cwd packages/cli check`; lint changed tests/scripts explicitly with
-`bunx ultracite check <paths>`. Rust default gates are `bun run check:local` and
-`bun run test:local`. Add `--all-features` to equivalent Cargo commands for feature
+`bunx ultracite check <paths>`. These entry points first run
+`bun run check:bun-version`, which fails when the running Bun differs from the
+`packageManager` pin that CI installs. A Bun ahead of mise's shims on `PATH`
+(for example mise's `latest` install) bypasses the checkout's `mise.toml`; use
+`mise x bun@<pin> -- bun run <script>` instead. `HACK_ALLOW_BUN_VERSION_MISMATCH=1`
+proceeds with a warning for a deliberate experiment; such a result is not CI evidence.
+Raw `bun test <paths>` does not run the guard.
+
+CI's "Config compiler" job also runs compiled-bundle CLI checks
+(`scripts/check-config-compiler-cli.ts`, `scripts/check-native-*-plan-cli.ts`,
+`scripts/check-native-config-import-cli.ts`) that `bun run test` does not. For
+compiler, native planning or config-import changes, run them locally after
+`bun run build` and `bun run build:config-compiler` with
+`bun run check:native-plan-cli`. `tests/native-plan-cli-wiring.test.ts` fails when a
+new `scripts/check-native-*-plan-cli.ts` is missing from that command or from CI.
+CI also lints those scripts and runs their transport tests; lint changed ones explicitly.
+
+Rust default gates are `bun run check:local` and `bun run test:local`. Add `--all-features` to equivalent Cargo commands for feature
 changes; the toolchain Rust tasks already enable all features. Keep default coverage.
 
 Before a full CLI suite, explicitly prepare the ignored compiler with
diff --git a/.hack/tasks.json b/.hack/tasks.json
index cda423fe4..9b79f72d1 100644
--- a/.hack/tasks.json
+++ b/.hack/tasks.json
@@ -110,12 +110,12 @@
           {
             "path": "package.json",
             "pointer": "/scripts/check",
-            "sha256": "ae7e24ee743b2aa230c6a492da63a0e7b6a0db925e691a24a7a8f1c97d3ee7fb"
+            "sha256": "c8dad6241a07d0de512741c0bc88b302f627b822b442de7d640490eaf239ce1f"
           },
           {
             "path": "package.json",
             "pointer": "/scripts/typecheck",
-            "sha256": "4209d96797d84dcd31f559acfde1395b9969d025ef6fc11f4684567a3009ef6f"
+            "sha256": "dce86c009756c167434b90e06ffa8ba3dbcfc01047abbae2a2803a4d5ecea01a"
           }
         ],
         "review": "HACK-1157"
diff --git a/AGENTS.md b/AGENTS.md
index 42818711d..9dde04905 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -80,7 +80,13 @@ or unresolved concern. Do not skip a required gate or weaken an assertion to get
   unrelated installed version. Use `bun index.ts` for a source invocation.
 - CLI typecheck/lint: `bun run --cwd packages/cli typecheck` and
   `bun run --cwd packages/cli check`. Lint changed scripts/tests explicitly as well.
-- Full gates: `bun run typecheck`, `bun run check`, `bun run test`.
+- Full gates: `bun run typecheck`, `bun run check`, `bun run test`. They fail when
+  the running Bun differs from the `packageManager` pin CI uses; run the pinned Bun
+  (`mise x bun@<pin> -- bun run <script>`), or set
+  `HACK_ALLOW_BUN_VERSION_MISMATCH=1` only for a deliberate mismatch.
+- Config compiler, native plan or config-import changes: after `bun run build` and
+  `bun run build:config-compiler`, run `bun run check:native-plan-cli`. It runs the
+  compiled-bundle CLI checks from CI's macOS "Config compiler" job.
 - CLI interface changes: regenerate `docs/reference/cli.md` with
   `bun run docs:cli-reference`.
 - Consumer agent guidance changes: regenerate the affected repository examples and plugin
diff --git a/package.json b/package.json
index 2891389ab..c3a81dd65 100644
--- a/package.json
+++ b/package.json
@@ -58,12 +58,14 @@
     "turbo:typecheck": "bunx turbo run typecheck",
     "turbo:test": "bun run test:preflight && bunx --no-install turbo run test",
     "turbo:check": "bunx turbo run check",
-    "check": "bun run privacy:check && bun run turbo:check",
+    "check": "bun run check:bun-version && bun run privacy:check && bun run turbo:check",
+    "check:bun-version": "bun scripts/check-bun-version.ts",
+    "check:native-plan-cli": "bun run check:bun-version && bun scripts/check-native-plan-clis.ts",
     "prepare": "husky",
     "release:prepare": "bunx semantic-release --no-ci",
-    "typecheck": "bun run turbo:typecheck",
+    "typecheck": "bun run check:bun-version && bun run turbo:typecheck",
     "uninstall:local": "bun run --cwd packages/cli uninstall:local",
-    "test": "bun run turbo:test",
+    "test": "bun run check:bun-version && bun run turbo:test",
     "test:preflight": "bun --no-env-file scripts/check-test-config-compiler.ts",
     "test:models": "bun run scripts/check-tla-models.ts",
     "test:e2e:local": "bun tests/e2e/run.ts",
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 7a47898ec..1828806dc 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -23,9 +23,9 @@
     "macos:release": "cd ../.. && ./scripts/build-macos-release.sh",
     "macos:ghostty:setup": "cd ../.. && bun run scripts/macos-ghostty-setup.ts",
     "macos:ghostty:bundle": "cd ../.. && bun run scripts/macos-ghostty-bundle.ts",
-    "typecheck": "bunx tsc -p tsconfig.json --noEmit",
-    "test": "cd ../.. && bun run test:preflight && bun test",
-    "check": "cd ../.. && bunx ultracite check src packages/cli/index.ts index.ts scripts/build-release.ts scripts/build-node-runtime-image.ts scripts/install-cli.ts scripts/install-status.ts scripts/uninstall-cli.ts scripts/macos-ghostty-bundle.ts scripts/macos-ghostty-setup.ts",
+    "typecheck": "bun ../../scripts/check-bun-version.ts && bunx tsc -p tsconfig.json --noEmit",
+    "test": "cd ../.. && bun run check:bun-version && bun run test:preflight && bun test",
+    "check": "cd ../.. && bun run check:bun-version && bunx ultracite check src packages/cli/index.ts index.ts scripts/build-release.ts scripts/build-node-runtime-image.ts scripts/install-cli.ts scripts/install-status.ts scripts/uninstall-cli.ts scripts/macos-ghostty-bundle.ts scripts/macos-ghostty-setup.ts",
     "lint": "bun run check"
   }
 }
diff --git a/packages/runtime-core/guest/stream-relay.c b/packages/runtime-core/guest/stream-relay.c
index 2c76a4cc0..a5b5ebb89 100644
--- a/packages/runtime-core/guest/stream-relay.c
+++ b/packages/runtime-core/guest/stream-relay.c
@@ -228,8 +228,22 @@ static int stop_owned(long pid, long start) {
     return 78;
 #endif
 }
+/*
+ * Publisher readiness contract: after the frontend and optional control socket
+ * are bound, the publisher writes exactly one readiness line to stdout and keeps
+ * serving. A Unix frontend or an explicit TCP port (1-65535) writes "ready\n",
+ * unchanged for existing callers. `--publish 0` (exactly "0") asks the kernel for
+ * an ephemeral loopback port while the listener is bound, closing the window in
+ * which a caller-probed free port can be taken by another process; that form
+ * writes "ready <port>\n" with the bound decimal port. Port 0 is accepted only by
+ * `--publish`; the relay and `--publish-unix` forms keep rejecting it with 64.
+ * Exit 73 still means the frontend could not be bound (or a bound Unix frontend
+ * path could not be verified), and no readiness line is written for any refused
+ * startup.
+ */
 int main(int argc, char **argv) {
     char *publish_args[8];
+    int ephemeral_port = 0;
     struct sockaddr_un control = {0};
     struct stat control_owned, receipt_owned, frontend_receipt_owned;
     char receipt_path[PATH_MAX] = {0};
@@ -263,7 +277,9 @@ int main(int argc, char **argv) {
         }
         /* Both publishers share upstream parsing; the Unix frontend has no TCP port. */
         publish_args[0] = argv[0]; publish_args[1] = argv[3];
-        publish_args[2] = "127.0.0.1"; publish_args[3] = publish_unix ? "1" : argv[2];
+        ephemeral_port = !publish_unix && !strcmp(argv[2], "0");
+        publish_args[2] = "127.0.0.1";
+        publish_args[3] = publish_unix || ephemeral_port ? "1" : argv[2];
         publish_args[4] = argv[5]; publish_args[5] = "--reservation";
         publish_args[6] = argv[4]; publish_args[7] = NULL;
         argv = publish_args; argc = 7; publish_mode = 1;
@@ -297,7 +313,7 @@ int main(int argc, char **argv) {
     }
     if (argc != option) return 64;
     target.sin_family = AF_INET;
-    target.sin_port = htons((uint16_t)port);
+    target.sin_port = ephemeral_port ? 0 : htons((uint16_t)port);
     local.sun_family = AF_UNIX;
     memcpy(local.sun_path, argv[1], strlen(argv[1]) + 1);
     if (publish_mode) { upstream = local; if (private_upstream(&current)) return 78; }
@@ -338,7 +354,12 @@ int main(int argc, char **argv) {
                     receipt_path, &receipt_owned, &receipt_bound)) failed = 1;
         }
     }
-    if (!failed) { puts("ready"); fflush(stdout); }
+    struct sockaddr_in bound = {0};
+    socklen_t bound_size = sizeof(bound);
+    if (!failed && ephemeral_port && (getsockname(listener, (struct sockaddr *)&bound, &bound_size) ||
+            bound_size != sizeof(bound) || bound.sin_family != AF_INET || !bound.sin_port)) failed = 1;
+    if (!failed && ephemeral_port) { printf("ready %u\n", (unsigned)ntohs(bound.sin_port)); fflush(stdout); }
+    else if (!failed) { puts("ready"); fflush(stdout); }
     while (!stopping && !failed) {
         struct pollfd descriptors[4 + 2 * CONNECTIONS];
         descriptors[3 + 2 * CONNECTIONS] = (struct pollfd){control_fd, POLLIN, 0};
diff --git a/packages/runtime-core/tests/stream_relay_contract.rs b/packages/runtime-core/tests/stream_relay_contract.rs
index 6c72f5264..02584c656 100644
--- a/packages/runtime-core/tests/stream_relay_contract.rs
+++ b/packages/runtime-core/tests/stream_relay_contract.rs
@@ -23,6 +23,8 @@ struct Relay {
     child: Child,
     root: PathBuf,
     socket: PathBuf,
+    /// The TCP port a `--publish` publisher reported or was given; None otherwise.
+    port: Option<u16>,
 }
 impl Relay {
     fn start(port: u16, idle: u32) -> Self {
@@ -93,6 +95,7 @@ impl Relay {
             child,
             root,
             socket,
+            port: None,
         }
     }
     fn connect(&self) -> UnixStream {
@@ -576,9 +579,6 @@ fn malformed_reservations_refuse_before_socket_creation() {
     fs::remove_dir_all(root).unwrap();
 }
 
-fn publisher(socket: &std::path::Path, token: &str, port: u16) -> Relay {
-    controlled_publisher(socket, token, port, None)
-}
 fn controlled_publisher(
     socket: &std::path::Path,
     token: &str,
@@ -676,9 +676,15 @@ fn try_frontend_publisher(
     startup.child = Some(command.stdout(Stdio::piped()).spawn().unwrap());
     let mut output = startup.child.as_mut().unwrap().stdout.take().unwrap();
     let deadline = Instant::now() + Duration::from_secs(3);
-    let expected = b"ready\n";
+    // Port 0 asks a TCP publisher to bind an ephemeral port and report it as
+    // "ready <port>\n"; every other form keeps the bare "ready\n" line.
+    let ephemeral = port == 0 && !unix;
+    let mut line = Vec::with_capacity(READINESS_LIMIT);
     // Read one byte per readiness notification: no unbounded read_line after POLLIN.
-    for expected_byte in expected {
+    while line.last() != Some(&b'\n') {
+        if line.len() == READINESS_LIMIT {
+            return Err(startup.failure("readiness marker"));
+        }
         loop {
             let remaining = deadline.saturating_duration_since(Instant::now());
             if remaining.is_zero() {
@@ -705,21 +711,57 @@ fn try_frontend_publisher(
             }
             let mut byte = [0];
             match output.read(&mut byte) {
-                Ok(1) if byte[0] == *expected_byte => break,
+                Ok(1) => {
+                    line.push(byte[0]);
+                    break;
+                }
                 Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
                 Ok(0) => return Err(startup.failure("readiness EOF")),
                 _ => return Err(startup.failure("readiness marker")),
             }
         }
     }
+    let published = match (ephemeral, line.as_slice()) {
+        (false, b"ready\n") => (!unix).then_some(port),
+        (true, reported) => match parse_reported_port(reported) {
+            Some(reported) => Some(reported),
+            None => return Err(startup.failure("readiness marker")),
+        },
+        _ => return Err(startup.failure("readiness marker")),
+    };
     let root = std::mem::take(&mut startup.root);
     Ok(Relay {
         child: startup.child.take().unwrap(),
         socket: root.join(if unix { "frontend.sock" } else { "unused" }),
         root,
+        port: published,
     })
 }
 
+/// "ready 65535\n" is the longest valid readiness line.
+const READINESS_LIMIT: usize = 12;
+
+/// Parses "ready <port>\n" with a canonical, nonzero decimal port.
+fn parse_reported_port(line: &[u8]) -> Option<u16> {
+    let digits = line.strip_prefix(b"ready ")?.strip_suffix(b"\n")?;
+    if digits.is_empty() || digits[0] == b'0' || !digits.iter().all(u8::is_ascii_digit) {
+        return None;
+    }
+    std::str::from_utf8(digits).ok()?.parse::<u16>().ok()
+}
+
+/// Starts a TCP publisher on a kernel-chosen port that stays bound from the
+/// publisher's bind() onward, so parallel tests cannot take it first.
+fn ephemeral_publisher(
+    socket: &std::path::Path,
+    token: &str,
+    control_token: Option<&str>,
+) -> (Relay, u16) {
+    let publication = controlled_publisher(socket, token, 0, control_token);
+    let port = publication.port.expect("TCP publication reports its port");
+    (publication, port)
+}
+
 #[test]
 fn publisher_startup_reports_port_conflict_and_reaps_child() {
     let backend = TcpListener::bind("127.0.0.1:0").unwrap();
@@ -758,12 +800,103 @@ fn publisher_startup_reports_port_conflict_and_reaps_child() {
     assert!(upstream.socket.exists());
 }
 
-fn free_loopback_port() -> u16 {
-    TcpListener::bind("127.0.0.1:0")
-        .unwrap()
-        .local_addr()
+/// Runs a command that must refuse promptly and returns its exit code and stdout.
+/// A child that is still running after the deadline was admitted instead of
+/// refused; it is killed and reaped so the test fails rather than hangs.
+fn bounded_refusal(command: &mut Command) -> (Option<i32>, Vec<u8>) {
+    let mut child = command
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .spawn()
+        .unwrap();
+    let deadline = Instant::now() + Duration::from_secs(3);
+    let status = loop {
+        if let Some(status) = child.try_wait().unwrap() {
+            break status;
+        }
+        if Instant::now() >= deadline {
+            let _ = child.kill();
+            let _ = child.wait();
+            panic!("command was admitted instead of refused: {command:?}");
+        }
+        thread::sleep(Duration::from_millis(5));
+    };
+    let mut stdout = Vec::new();
+    child
+        .stdout
+        .take()
         .unwrap()
-        .port()
+        .read_to_end(&mut stdout)
+        .unwrap();
+    (status.code(), stdout)
+}
+
+#[test]
+fn ephemeral_publication_reports_its_bound_port_and_explicit_ports_keep_bare_ready() {
+    let backend = TcpListener::bind("127.0.0.1:0").unwrap();
+    let token = "dddddddddddddddddddddddddddddddd";
+    let guard = Relay::start_options(
+        backend.local_addr().unwrap().port(),
+        10000,
+        None,
+        Some(token),
+        None,
+    );
+    // Only the exact `--publish 0` form selects an ephemeral port.
+    for (mode, endpoint) in [("--publish", "00"), ("--publish-unix", "0")] {
+        let (code, stdout) = bounded_refusal(
+            Command::new(BINARY)
+                .args([mode, endpoint])
+                .arg(&guard.socket)
+                .args([token, "10000"]),
+        );
+        assert_eq!(code, Some(64), "{mode} {endpoint}");
+        assert!(stdout.is_empty());
+    }
+    let (code, stdout) = bounded_refusal(
+        Command::new(BINARY)
+            .arg(guard.root.join("relay-port-zero.sock"))
+            .args(["127.0.0.1", "0", "1000"]),
+    );
+    assert_eq!(code, Some(64));
+    assert!(stdout.is_empty());
+    assert!(!guard.root.join("relay-port-zero.sock").exists());
+
+    let (mut first, first_port) = ephemeral_publisher(&guard.socket, token, None);
+    let (mut second, second_port) = ephemeral_publisher(&guard.socket, token, None);
+    assert_ne!(first_port, second_port);
+    for port in [first_port, second_port] {
+        // The reported port is the publisher's live listener, not a released probe.
+        assert_eq!(
+            TcpListener::bind(("127.0.0.1", port)).unwrap_err().kind(),
+            io::ErrorKind::AddrInUse
+        );
+        std::net::TcpStream::connect(("127.0.0.1", port)).unwrap();
+    }
+    first.stop();
+    second.stop();
+
+    // Explicit ports keep the bare "ready\n" line for existing callers. Picking a
+    // concrete port needs a released probe, so retry only on the publisher's
+    // confirmed bind refusal (no readiness line, exit 73) and never otherwise.
+    let mut attempts = 0;
+    let explicit = loop {
+        attempts += 1;
+        let probe = TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = probe.local_addr().unwrap().port();
+        drop(probe);
+        match try_frontend_publisher(&guard.socket, token, port, None, false) {
+            Ok(publication) => break publication,
+            Err(failure)
+                if attempts < 3
+                    && failure.stage == "readiness EOF"
+                    && failure.status.and_then(|status| status.code()) == Some(73) => {}
+            Err(failure) => panic!("explicit-port publisher refused: {failure:?}"),
+        }
+    };
+    let port = explicit.port.expect("explicit TCP port recorded");
+    std::net::TcpStream::connect(("127.0.0.1", port)).unwrap();
+    assert!(guard.socket.exists());
 }
 
 #[test]
@@ -777,8 +910,7 @@ fn loopback_publication_streams_without_exposing_handshake_and_releases_port() {
         Some(token),
         None,
     );
-    let port = free_loopback_port();
-    let mut publication = publisher(&guard.socket, token, port);
+    let (mut publication, port) = ephemeral_publisher(&guard.socket, token, None);
     let payload = vec![0x5a; 2 * 1024 * 1024];
     let expected = payload.clone();
     let worker = thread::spawn(move || {
@@ -835,8 +967,7 @@ fn publisher_refuses_port_conflicts_and_stale_reused_upstream() {
         Some(73)
     );
     assert!(std::net::TcpStream::connect(("127.0.0.1", busy_port)).is_ok());
-    let port = free_loopback_port();
-    let _publication = publisher(&guard.socket, old, port);
+    let (_publication, port) = ephemeral_publisher(&guard.socket, old, None);
     guard.stop();
     let _replacement = Relay::start_options(
         backend.local_addr().unwrap().port(),
@@ -915,17 +1046,27 @@ fn publisher_refuses_nonprivate_or_aliased_upstream_before_listening() {
     fs::create_dir(&root).unwrap();
     let path = root.join("socket");
     let _listener = UnixListener::bind(&path).unwrap();
-    let port = free_loopback_port();
+    // Hold the requested port for the whole test: a publisher that reached bind()
+    // would exit 73 on it, so exit 78 proves the refusal precedes listening without
+    // probing a released port that a parallel test could have taken.
+    let occupied = TcpListener::bind("127.0.0.1:0").unwrap();
+    occupied.set_nonblocking(true).unwrap();
+    let port = occupied.local_addr().unwrap().port();
     let attempt = |upstream: &std::path::Path| {
         let result = Command::new(BINARY)
             .arg("--publish")
             .arg(port.to_string())
             .arg(upstream)
             .args(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "10000"])
-            .status()
+            .stdin(Stdio::null())
+            .output()
             .unwrap();
-        assert_eq!(result.code(), Some(78));
-        assert!(std::net::TcpStream::connect(("127.0.0.1", port)).is_err());
+        assert_eq!(result.status.code(), Some(78));
+        assert!(result.stdout.is_empty());
+        assert_eq!(
+            occupied.accept().unwrap_err().kind(),
+            std::io::ErrorKind::WouldBlock
+        );
     };
     fs::set_permissions(&path, fs::Permissions::from_mode(0o777)).unwrap();
     attempt(&path);
@@ -955,8 +1096,7 @@ fn private_control_stops_only_matching_publisher_and_preserves_replaced_path() {
     fs::set_permissions(&upstream, fs::Permissions::from_mode(0o700)).unwrap();
     let token = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     for replace in [false, true] {
-        let port = free_loopback_port();
-        let mut publication = controlled_publisher(&upstream, token, port, Some(token));
+        let (mut publication, port) = ephemeral_publisher(&upstream, token, Some(token));
         let path = publication.root.join("control.sock");
         assert_eq!(
             fs::metadata(&path).unwrap().permissions().mode() & 0o777,
@@ -1030,44 +1170,34 @@ fn control_startup_refuses_occupied_and_nonprivate_paths_without_retaining_publi
     fs::write(&control, b"foreign").unwrap();
     let control_identity = fs::symlink_metadata(&control).unwrap();
     let frontend = root.join("frontend");
-    // The TCP leg publishes on a port that free_loopback_port() has already
-    // released, so a parallel test may re-take it before the relay binds and the
-    // relay then exits 73 at bind instead of reaching the control path. Retry a
-    // bounded number of times on a fresh port; the 70/78 expectations stay exact.
-    const PORT_ATTEMPTS: u32 = 3;
     for unix in [false, true] {
         for (mode, expected_exit) in [(0o700, 70), (0o755, 78)] {
             fs::set_permissions(&root, fs::Permissions::from_mode(mode)).unwrap();
-            let mut attempt = 1;
-            let (pid, output) = loop {
-                let mut command = Command::new(BINARY);
-                command
-                    .arg(if unix { "--publish-unix" } else { "--publish" })
-                    .arg(if unix {
-                        frontend.as_os_str().to_owned()
-                    } else {
-                        free_loopback_port().to_string().into()
-                    })
-                    .arg(&upstream)
-                    .args(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "10000", "--control"])
-                    .arg(&control)
-                    .arg("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
-                    .stdin(Stdio::null())
-                    .stdout(Stdio::piped())
-                    .stderr(Stdio::piped());
-                let child = command.spawn().unwrap();
-                let pid = child.id();
-                let output = child.wait_with_output().unwrap();
-                if !unix && output.status.code() == Some(73) && attempt < PORT_ATTEMPTS {
-                    attempt += 1;
-                    continue;
-                }
-                break (pid, output);
-            };
+            let mut command = Command::new(BINARY);
+            command
+                .arg(if unix { "--publish-unix" } else { "--publish" })
+                // TCP port 0 binds an ephemeral port inside the publisher, so the TCP
+                // leg always reaches the control path instead of racing a parallel
+                // test for a released port and exiting 73 at bind.
+                .arg(if unix {
+                    frontend.as_os_str().to_owned()
+                } else {
+                    "0".into()
+                })
+                .arg(&upstream)
+                .args(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "10000", "--control"])
+                .arg(&control)
+                .arg("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+                .stdin(Stdio::null())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped());
+            let child = command.spawn().unwrap();
+            let pid = child.id();
+            let output = child.wait_with_output().unwrap();
             assert_eq!(
                 output.status.code(),
                 Some(expected_exit),
-                "unix={unix} mode={mode:o} attempt={attempt}"
+                "unix={unix} mode={mode:o}"
             );
             assert!(output.stdout.is_empty());
             let mut status = 0;
diff --git a/scripts/check-bun-version.ts b/scripts/check-bun-version.ts
new file mode 100644
index 000000000..9be7b4319
--- /dev/null
+++ b/scripts/check-bun-version.ts
@@ -0,0 +1,105 @@
+#!/usr/bin/env bun
+/**
+ * Fails the local `test`, `check` and `typecheck` entry points when the running
+ * Bun differs from the `packageManager` pin in the root `package.json`.
+ *
+ * CI installs exactly that pin. A contributor whose PATH resolves another Bun
+ * (for example mise's `latest` install ahead of the checkout's `mise.toml`) would
+ * otherwise get results CI does not reproduce: a Bun 1.4.3 test pass hid a
+ * Bun 1.4.2 macOS SIGSTOP difference that failed in CI (HACK-1290).
+ *
+ * `HACK_ALLOW_BUN_VERSION_MISMATCH=1` proceeds deliberately, with a warning on
+ * stderr. Any other value is ignored. The check reads only the version strings.
+ */
+import { resolve } from "node:path";
+import { isRecord } from "../src/lib/guards.ts";
+
+/** The opt-in for a deliberate mismatch, such as a Bun upgrade experiment. */
+export const BUN_VERSION_OVERRIDE_ENV = "HACK_ALLOW_BUN_VERSION_MISMATCH";
+
+const PIN_PATTERN = /^bun@(\d+\.\d+\.\d+)$/;
+
+export type BunVersionVerdict =
+  | { readonly kind: "match"; readonly pinned: string }
+  | {
+      readonly kind: "overridden";
+      readonly pinned: string;
+      readonly message: string;
+    }
+  | {
+      readonly kind: "mismatch";
+      readonly pinned: string;
+      readonly message: string;
+    }
+  | { readonly kind: "invalid-pin"; readonly message: string };
+
+/** Pure comparison of the running Bun against the `packageManager` value. */
+export function checkBunVersion(opts: {
+  readonly running: string;
+  readonly packageManager: unknown;
+  readonly override: string | undefined;
+}): BunVersionVerdict {
+  const match =
+    typeof opts.packageManager === "string"
+      ? PIN_PATTERN.exec(opts.packageManager)
+      : null;
+  const pinned = match?.[1];
+  if (!pinned) {
+    return {
+      kind: "invalid-pin",
+      message:
+        'package.json "packageManager" must be "bun@<major>.<minor>.<patch>".',
+    };
+  }
+  if (opts.running === pinned) {
+    return { kind: "match", pinned };
+  }
+  const detail =
+    `Bun ${opts.running} is running, but package.json pins bun@${pinned} ` +
+    "(packageManager), which CI uses.";
+  if (opts.override === "1") {
+    return {
+      kind: "overridden",
+      pinned,
+      message: `Warning: ${detail} Continuing because ${BUN_VERSION_OVERRIDE_ENV}=1; results may differ from CI.`,
+    };
+  }
+  return {
+    kind: "mismatch",
+    pinned,
+    message:
+      `${detail} Run the pinned Bun, for example ` +
+      `\`mise x bun@${pinned} -- bun run <script>\`, or put mise shims ahead of ` +
+      "other Bun installs so the checkout's mise.toml applies. " +
+      `Set ${BUN_VERSION_OVERRIDE_ENV}=1 to run a different Bun deliberately.`,
+  };
+}
+
+async function main(): Promise<void> {
+  const root = resolve(import.meta.dir, "..");
+  let packageManager: unknown;
+  try {
+    const manifest: unknown = await Bun.file(
+      resolve(root, "package.json")
+    ).json();
+    packageManager = isRecord(manifest) ? manifest.packageManager : undefined;
+  } catch {
+    packageManager = undefined;
+  }
+  const verdict = checkBunVersion({
+    running: Bun.version,
+    packageManager,
+    override: process.env[BUN_VERSION_OVERRIDE_ENV],
+  });
+  if (verdict.kind === "match") {
+    return;
+  }
+  process.stderr.write(`${verdict.message}\n`);
+  if (verdict.kind !== "overridden") {
+    process.exitCode = 1;
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}
diff --git a/scripts/check-native-plan-clis.ts b/scripts/check-native-plan-clis.ts
new file mode 100644
index 000000000..2f11e3da9
--- /dev/null
+++ b/scripts/check-native-plan-clis.ts
@@ -0,0 +1,70 @@
+#!/usr/bin/env bun
+/**
+ * Local entry point for the compiled-bundle CLI checks that CI runs in the
+ * "Config compiler" job (HACK-1294). Each script copies `dist/hack` and
+ * `dist/hack-config-compiler` into an isolated temporary bundle with a private
+ * HOME, so the current branch must be built first:
+ *
+ *   bun run build && bun run build:config-compiler && bun run check:native-plan-cli
+ *
+ * The scripts run one at a time, in the CI order, and the first failure stops
+ * the run. `tests/native-plan-cli-wiring.test.ts` fails when a
+ * `scripts/check-native-*-plan-cli.ts` is missing from this list or from CI.
+ */
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+
+/** Repository-relative scripts, in the order CI runs them. */
+export const NATIVE_PLAN_CLI_CHECKS = [
+  "scripts/check-config-compiler-cli.ts",
+  "scripts/check-native-env-plan-cli.ts",
+  "scripts/check-native-host-plan-cli.ts",
+  "scripts/check-native-routing-plan-cli.ts",
+  "scripts/check-native-endpoint-plan-cli.ts",
+  "scripts/check-native-process-plan-cli.ts",
+  "scripts/check-native-acquisition-plan-cli.ts",
+  "scripts/check-native-config-import-cli.ts",
+] as const;
+
+const PREREQUISITES = ["dist/hack", "dist/hack-config-compiler"] as const;
+
+async function isFile(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function main(): Promise<void> {
+  const root = resolve(import.meta.dir, "..");
+  for (const prerequisite of PREREQUISITES) {
+    if (!(await isFile(resolve(root, prerequisite)))) {
+      process.stderr.write(
+        `${prerequisite} is missing. Build the current branch first: ` +
+          "bun run build && bun run build:config-compiler\n"
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  for (const script of NATIVE_PLAN_CLI_CHECKS) {
+    process.stdout.write(`check:native-plan-cli: ${script}\n`);
+    const child = Bun.spawn([process.execPath, script], {
+      cwd: root,
+      stdio: ["ignore", "inherit", "inherit"],
+    });
+    const exit = await child.exited;
+    if (exit !== 0) {
+      process.stderr.write(
+        `check:native-plan-cli: ${script} failed (exit ${exit}).\n`
+      );
+      process.exitCode = exit > 0 ? exit : 1;
+      return;
+    }
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}
diff --git a/tests/bun-version-guard.test.ts b/tests/bun-version-guard.test.ts
new file mode 100644
index 000000000..db1f68458
--- /dev/null
+++ b/tests/bun-version-guard.test.ts
@@ -0,0 +1,171 @@
+import { afterEach, expect, test } from "bun:test";
+import { copyFile, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  BUN_VERSION_OVERRIDE_ENV,
+  checkBunVersion,
+} from "../scripts/check-bun-version.ts";
+
+const root = resolve(import.meta.dir, "..");
+const owned: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    owned.splice(0).map((path) => rm(path, { recursive: true, force: true }))
+  );
+});
+
+async function pinned(): Promise<string> {
+  const manifest = await Bun.file(join(root, "package.json")).json();
+  const match = /^bun@(\d+\.\d+\.\d+)$/.exec(manifest.packageManager);
+  if (!match?.[1]) {
+    throw new Error("packageManager is not an exact Bun pin");
+  }
+  return match[1];
+}
+
+test("matching Bun passes; a mismatch fails unless the override is exactly 1", () => {
+  const packageManager = "bun@1.4.2";
+  expect(
+    checkBunVersion({ running: "1.4.2", packageManager, override: undefined })
+  ).toEqual({ kind: "match", pinned: "1.4.2" });
+
+  const mismatch = checkBunVersion({
+    running: "1.4.3",
+    packageManager,
+    override: undefined,
+  });
+  expect(mismatch.kind).toBe("mismatch");
+  if (mismatch.kind !== "mismatch") {
+    throw new Error("expected mismatch");
+  }
+  expect(mismatch.message).toContain("Bun 1.4.3 is running");
+  expect(mismatch.message).toContain("bun@1.4.2");
+  expect(mismatch.message).toContain("mise x bun@1.4.2 -- bun run <script>");
+  expect(mismatch.message).toContain(`${BUN_VERSION_OVERRIDE_ENV}=1`);
+
+  for (const override of ["", "0", "true", "yes"]) {
+    expect(
+      checkBunVersion({ running: "1.4.3", packageManager, override }).kind
+    ).toBe("mismatch");
+  }
+  expect(
+    checkBunVersion({ running: "1.4.3", packageManager, override: "1" }).kind
+  ).toBe("overridden");
+});
+
+test("a missing or inexact packageManager pin is rejected", () => {
+  for (const packageManager of [
+    undefined,
+    42,
+    "bun",
+    "bun@1.4",
+    "bun@^1.4.2",
+    "npm@1.4.2",
+    "bun@1.4.2 ",
+  ]) {
+    expect(
+      checkBunVersion({ running: "1.4.2", packageManager, override: "1" }).kind
+    ).toBe("invalid-pin");
+  }
+});
+
+test("the script exits nonzero on a mismatch and zero with the override", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hack-bun-version-guard-"));
+  owned.push(directory);
+  await Promise.all([
+    mkdir(join(directory, "scripts")),
+    mkdir(join(directory, "src/lib"), { recursive: true }),
+  ]);
+  await Promise.all([
+    copyFile(
+      join(root, "scripts/check-bun-version.ts"),
+      join(directory, "scripts/check-bun-version.ts")
+    ),
+    copyFile(
+      join(root, "src/lib/guards.ts"),
+      join(directory, "src/lib/guards.ts")
+    ),
+    Bun.write(
+      join(directory, "package.json"),
+      JSON.stringify({ packageManager: "bun@0.0.1" })
+    ),
+  ]);
+  const run = async (env: Record<string, string>) => {
+    const child = Bun.spawn(
+      [process.execPath, join(directory, "scripts/check-bun-version.ts")],
+      {
+        cwd: directory,
+        env: { PATH: process.env.PATH ?? "", HOME: directory, ...env },
+        stdio: ["ignore", "pipe", "pipe"],
+      }
+    );
+    const [exit, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stderr).text(),
+    ]);
+    return { exit, stderr };
+  };
+
+  const refused = await run({});
+  expect(refused.exit).toBe(1);
+  expect(refused.stderr).toContain(`Bun ${Bun.version} is running`);
+  expect(refused.stderr).toContain("bun@0.0.1");
+
+  const allowed = await run({ [BUN_VERSION_OVERRIDE_ENV]: "1" });
+  expect(allowed.exit).toBe(0);
+  expect(allowed.stderr).toContain("Warning:");
+});
+
+test("mise, asdf and CI agree with the packageManager pin", async () => {
+  const version = await pinned();
+  const mise = await Bun.file(join(root, "mise.toml")).text();
+  expect(mise).toMatch(
+    new RegExp(`^bun = "${version.replaceAll(".", "\\.")}"$`, "m")
+  );
+  const toolVersions = await Bun.file(join(root, ".tool-versions")).text();
+  expect(toolVersions).toMatch(
+    new RegExp(`^bun\\s+${version.replaceAll(".", "\\.")}$`, "m")
+  );
+
+  const workflows = join(root, ".github/workflows");
+  let literalPins = 0;
+  for (const name of await readdir(workflows)) {
+    const text = await Bun.file(join(workflows, name)).text();
+    for (const match of text.matchAll(/bun-version:\s*"?([^"\s]+)"?/g)) {
+      if (match[1]?.startsWith("${{")) {
+        continue;
+      }
+      literalPins += 1;
+      expect(match[1], `${name} pins another Bun`).toBe(version);
+    }
+  }
+  expect(literalPins).toBeGreaterThan(0);
+});
+
+test("local test, check and typecheck entry points run the Bun guard", async () => {
+  const guard = "bun run check:bun-version && ";
+  const rootScripts = (await Bun.file(join(root, "package.json")).json())
+    .scripts;
+  expect(rootScripts["check:bun-version"]).toBe(
+    "bun scripts/check-bun-version.ts"
+  );
+  for (const name of ["test", "check", "typecheck", "check:native-plan-cli"]) {
+    expect(rootScripts[name], name).toStartWith(guard);
+  }
+
+  const cliScripts = (
+    await Bun.file(join(root, "packages/cli/package.json")).json()
+  ).scripts;
+  expect(cliScripts.typecheck).toStartWith(
+    "bun ../../scripts/check-bun-version.ts && "
+  );
+  expect(cliScripts.test).toStartWith(`cd ../.. && ${guard}`);
+  expect(cliScripts.check).toStartWith(`cd ../.. && ${guard}`);
+
+  // Turbo's strict environment mode would otherwise drop the override for
+  // package tasks, so the documented opt-in must pass through.
+  const turbo = await Bun.file(join(root, "turbo.json")).json();
+  expect(turbo.globalPassThroughEnv).toContain(BUN_VERSION_OVERRIDE_ENV);
+});
diff --git a/tests/e2e/README.md b/tests/e2e/README.md
index b09010fed..eb0c6e5f6 100644
--- a/tests/e2e/README.md
+++ b/tests/e2e/README.md
@@ -275,6 +275,10 @@ project name, the image (the cached `oven/bun:1.4.2-slim` repository digest with
 `pull_policy: never` instead of the pinned Alpine image), a declared platform
 (the daemon's architecture) and exact owner labels. Commands, mounts, dependency
 labels, gates and health checks stay as the fixture authored them.
+Owned-container queries list, then inspect. A container that a concurrent
+`hack up` recreates can disappear in between; the helper treats only a listed ID
+that Docker reports missing and `docker ps` confirms absent as removed, and
+fails on any other inspection error (HACK-1296).
 
 - P01 runs a cold and a warm `hack up --json`, a linked worktree, a `bun.lock`
   change and an installer killed mid-run under a fresh generation. Every running
diff --git a/tests/e2e/pattern-fixture.test.ts b/tests/e2e/pattern-fixture.test.ts
new file mode 100644
index 000000000..c9118152f
--- /dev/null
+++ b/tests/e2e/pattern-fixture.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test";
+import type { CliResult } from "./harness.ts";
+import { partitionContainerInspection } from "./scenarios/pattern-fixture.ts";
+
+const KEPT = "1a2b3c4d5e6f";
+const GONE = "307b0e394010";
+
+function inspection(opts: {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr?: string;
+  readonly timedOut?: boolean;
+}): CliResult {
+  const stderr = opts.stderr ?? "";
+  return {
+    command: "docker inspect --type container",
+    exitCode: opts.exitCode,
+    stdout: opts.stdout,
+    stderr,
+    combined: `${opts.stdout}${stderr}`,
+    timedOut: opts.timedOut ?? false,
+    durationMs: 1,
+  };
+}
+
+const kept = JSON.stringify([{ Id: `${KEPT}${"0".repeat(52)}` }]);
+
+describe("partitionContainerInspection", () => {
+  test("keeps every listed container when inspection succeeds", () => {
+    const split = partitionContainerInspection({
+      ids: [KEPT],
+      result: inspection({ exitCode: 0, stdout: kept }),
+    });
+    expect(split).toEqual({
+      resources: [{ Id: `${KEPT}${"0".repeat(52)}` }],
+      missing: [],
+    });
+  });
+
+  test("reports the CI failure shape as a removed container, not an error", () => {
+    const split = partitionContainerInspection({
+      ids: [GONE],
+      result: inspection({
+        exitCode: 1,
+        stdout: "[]\n",
+        stderr: `Error: No such object: ${GONE}\n`,
+      }),
+    });
+    expect(split).toEqual({ resources: [], missing: [GONE] });
+  });
+
+  test("keeps survivors when one of several listed containers is removed", () => {
+    for (const stderr of [
+      `Error response from daemon: No such container: ${GONE}\n`,
+      `error: no such object: ${GONE}\n`,
+    ]) {
+      const split = partitionContainerInspection({
+        ids: [KEPT, GONE],
+        result: inspection({ exitCode: 1, stdout: kept, stderr }),
+      });
+      expect(split).toEqual({
+        resources: [{ Id: `${KEPT}${"0".repeat(52)}` }],
+        missing: [GONE],
+      });
+    }
+  });
+
+  test("rejects failures that are not a removed listed container", () => {
+    const failures: CliResult[] = [
+      inspection({
+        exitCode: 1,
+        stdout: "",
+        stderr: "Cannot connect to the Docker daemon\n",
+      }),
+      inspection({
+        exitCode: 1,
+        stdout: "[]\n",
+        stderr: "Error: No such object: ffffffffffff\n",
+      }),
+      inspection({
+        exitCode: 1,
+        stdout: "[]\n",
+        stderr: `Error: No such object: ${KEPT}\npermission denied\n`,
+      }),
+      // A listed container silently dropped from stdout is not "removed".
+      inspection({ exitCode: 1, stdout: "[]\n" }),
+      // Reported missing yet inspected is contradictory.
+      inspection({
+        exitCode: 1,
+        stdout: kept,
+        stderr: `Error: No such object: ${KEPT}\n`,
+      }),
+      // Exit 0 with a missing container, and a timeout, are never accepted.
+      inspection({
+        exitCode: 0,
+        stdout: "[]\n",
+        stderr: `Error: No such object: ${KEPT}\n`,
+      }),
+      inspection({ exitCode: 0, stdout: kept, timedOut: true }),
+      inspection({ exitCode: 0, stdout: "{}" }),
+    ];
+    for (const result of failures) {
+      expect(
+        partitionContainerInspection({ ids: [KEPT], result })
+      ).toHaveProperty("error");
+    }
+  });
+});
diff --git a/tests/e2e/scenarios/pattern-fixture.ts b/tests/e2e/scenarios/pattern-fixture.ts
index 796377742..6f7b42732 100644
--- a/tests/e2e/scenarios/pattern-fixture.ts
+++ b/tests/e2e/scenarios/pattern-fixture.ts
@@ -316,7 +316,80 @@ export function ownedLabels(opts: {
   return labels;
 }
 
-/** Inspect owned containers, optionally narrowed to one project and service. */
+const MISSING_CONTAINER = /no such (?:object|container): (\S+)/i;
+
+/**
+ * Split a `docker inspect --type container <ids>` result, where `ids` came
+ * from `docker ps -aq`, into the inspected containers and the listed IDs that
+ * no longer exist.
+ *
+ * Listing and inspection are two calls, so a container can be removed in
+ * between: a concurrent `hack up` that changes a service's configuration makes
+ * Compose remove and recreate that service's container (HACK-1296). Docker
+ * then exits 1, prints only the surviving objects on stdout, and reports one
+ * "No such object/container" line per missing ID on stderr (wording varies by
+ * client version). Anything else is an error: a timeout, output that is not a
+ * JSON array, a stderr line that is not a missing listed ID, a listed ID that
+ * is neither inspected nor reported missing, or a non-zero exit with nothing
+ * missing. The caller must still confirm each missing ID is really gone.
+ */
+export function partitionContainerInspection(opts: {
+  readonly ids: readonly string[];
+  readonly result: CliResult;
+}):
+  | { readonly resources: DockerResource[]; readonly missing: string[] }
+  | { readonly error: string } {
+  if (opts.result.timedOut) {
+    return { error: "docker inspect timed out" };
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(opts.result.stdout);
+  } catch {
+    return { error: "docker inspect stdout is not JSON" };
+  }
+  if (!Array.isArray(parsed)) {
+    return { error: "docker inspect stdout is not a JSON array" };
+  }
+  const resources = parsed as DockerResource[];
+  const reported = new Set<string>();
+  for (const line of opts.result.stderr.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    const id = MISSING_CONTAINER.exec(line)?.[1];
+    if (id === undefined || !opts.ids.includes(id)) {
+      return { error: `unexpected docker inspect error: ${line.trim()}` };
+    }
+    reported.add(id);
+  }
+  const missing: string[] = [];
+  for (const id of opts.ids) {
+    const found = resources.some((resource) => resource.Id?.startsWith(id));
+    if (found === reported.has(id)) {
+      return {
+        error: `listed container ${id} must be either inspected or reported missing`,
+      };
+    }
+    if (!found) {
+      missing.push(id);
+    }
+  }
+  if ((opts.result.exitCode === 0) !== (missing.length === 0)) {
+    return {
+      error: `docker inspect exit ${opts.result.exitCode} disagrees with ${missing.length} missing container(s)`,
+    };
+  }
+  return { resources, missing };
+}
+
+/**
+ * Inspect owned containers, optionally narrowed to one project and service.
+ * A listed container that Docker removed before inspection (see
+ * `partitionContainerInspection`) is confirmed absent and omitted: it is no
+ * longer an owned container, so callers count, mount-check and exec only
+ * containers that still exist.
+ */
 export async function ownedContainers(opts: {
   readonly ctx: ScenarioContext;
   readonly owner: string;
@@ -344,15 +417,39 @@ export async function ownedContainers(opts: {
   if (ids.length === 0) {
     return [];
   }
-  const inspected = await checkedDocker({
+  const inspected = await docker({
     ctx: opts.ctx,
-    args: ["inspect", ...ids],
+    args: ["inspect", "--type", "container", ...ids],
   });
-  const resources = JSON.parse(inspected.stdout) as DockerResource[];
-  for (const resource of resources) {
+  const split = partitionContainerInspection({ ids, result: inspected });
+  if ("error" in split) {
+    expect({
+      that: false,
+      message: `docker inspect pattern fixture operation: ${split.error}`,
+      result: inspected,
+    });
+    return [];
+  }
+  for (const id of split.missing) {
+    const remaining = await checkedDocker({
+      ctx: opts.ctx,
+      args: ["ps", "-aq", "--filter", `id=${id}`],
+    });
+    expect({
+      that: remaining.stdout.trim() === "",
+      message: `container ${id} failed inspection but still exists`,
+      result: inspected,
+    });
+  }
+  if (split.missing.length > 0) {
+    opts.ctx.log(
+      `owned container(s) ${split.missing.join(", ")} were removed between listing and inspection; confirmed absent`
+    );
+  }
+  for (const resource of split.resources) {
     ownedLabels({ ...opts, resource });
   }
-  return resources;
+  return split.resources;
 }
 
 /** Inspect owned named volumes. */
diff --git a/tests/helpers/retained-routing-adoption.ts b/tests/helpers/retained-routing-adoption.ts
index c5e5ff52d..d8d630905 100644
--- a/tests/helpers/retained-routing-adoption.ts
+++ b/tests/helpers/retained-routing-adoption.ts
@@ -10,6 +10,7 @@ import {
 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { DEFAULT_COMPOSE_STARTUP_TIMEOUT_MS } from "../../src/lib/compose-startup-budget.ts";
 import { isRecord } from "../../src/lib/guards.ts";
 import { openLegacyComposeAdoptedGenerationStore } from "../../src/lib/native-compose-adoption-generation.ts";
 import { parseLegacyComposeAdoptionReceipt } from "../../src/lib/native-compose-adoption-receipt.ts";
@@ -24,6 +25,29 @@ import { restoreEnv } from "./env.ts";
 export const ROUTING_CANARY = "synthetic-retained-sql-row";
 /** Closed set: the product's 15 s default proof deadline or its 60 s cap. */
 export type RetainedRoutingStoreTimeoutMs = 15_000 | 60_000;
+/** Closed set of caller deadlines for one `operation()`: the harness's 15 s
+ * default, kept by the deadline-refusal controls, or the product's own default
+ * caller deadline for a retained operation (`hack up`/`down` pass the 90 s
+ * Compose startup budget to `withMutation`). */
+export type RetainedRoutingOperationDeadlineMs =
+  | 15_000
+  | typeof DEFAULT_COMPOSE_STARTUP_TIMEOUT_MS;
+/** Value-free timing of the most recent `operation()` call. A retained mutation
+ * refuses as `E_LEGACY_ADOPTION_CHANGED` both when its observed binding differs
+ * from the recorded one and when its caller deadline expires (the product's
+ * fail-closed deadline guard). `deadlineExpired` and `bindingUnchanged` (whether
+ * every synthetic binding fact except the running state still equals the
+ * fixture's original) tell the two apart without exposing any value. */
+export interface RetainedRoutingOperationTiming {
+  readonly operation: "start" | "stop";
+  readonly preparation: boolean;
+  readonly deadlineMs: RetainedRoutingOperationDeadlineMs;
+  readonly elapsedMs: number;
+  readonly outcome: "returned" | "refused";
+  readonly code?: string;
+  readonly deadlineExpired: boolean;
+  readonly bindingUnchanged: boolean;
+}
 export const ROUTING_IDS = {
   db: "a".repeat(64),
   web: "b".repeat(64),
@@ -531,6 +555,14 @@ else {
     root,
     ".hack/.internal/legacy-compose-adoption-v1/receipt.json"
   );
+  let lastOperation: RetainedRoutingOperationTiming | undefined;
+  /** Every synthetic binding fact except the running state, which lifecycle
+   * operations legitimately change. Compared, never reported. */
+  const bindingFacts = () => {
+    const { running: _running, ...facts } = model;
+    return JSON.stringify(facts);
+  };
+  const originalBinding = bindingFacts();
   return {
     root,
     outer,
@@ -543,6 +575,8 @@ else {
     hooks,
     commands,
     effects,
+    /** Timing of the most recent `operation()` call, for failure attribution. */
+    lastOperation: () => lastOperation,
     receiptPath,
     canRestore: lifetime.canRestore,
     track: lifetime.track,
@@ -577,9 +611,33 @@ else {
         readonly recover?: boolean;
         readonly numeric?: boolean;
         readonly preparation?: boolean;
+        /** The caller deadline for this one operation. Deadline-refusal controls
+         * keep the 15 s default; a compound lifecycle test passes the product's
+         * default caller deadline, so a slow but unchanged operation under suite
+         * load is not refused by a harness deadline shorter than the product's. */
+        readonly deadlineMs?: RetainedRoutingOperationDeadlineMs;
       } = {}
     ) => {
-      const deadline = Date.now() + 15_000;
+      const deadlineMs = opts.deadlineMs ?? 15_000;
+      const started = Date.now();
+      const deadline = started + deadlineMs;
+      const record = (outcome: "returned" | "refused", error?: unknown) => {
+        const now = Date.now();
+        const code =
+          isRecord(error) && typeof error.code === "string"
+            ? error.code
+            : undefined;
+        lastOperation = {
+          operation,
+          preparation: opts.preparation === true,
+          deadlineMs,
+          elapsedMs: now - started,
+          outcome,
+          ...(code ? { code } : {}),
+          deadlineExpired: now >= deadline,
+          bindingUnchanged: bindingFacts() === originalBinding,
+        };
+      };
       const run = async (
         input: Parameters<Parameters<typeof store.withMutation>[0]["run"]>[0]
       ) =>
@@ -590,23 +648,30 @@ else {
               operation,
               deadline,
             });
-      return opts.preparation
-        ? await store.withPreparationStop({
-            generation,
-            binary: compiler,
-            deadline,
-            recover: opts.recover,
-            run,
-          })
-        : await store.withMutation({
-            generation,
-            operation,
-            services: [],
-            binary: compiler,
-            deadline,
-            recover: opts.recover,
-            run,
-          });
+      try {
+        const code = opts.preparation
+          ? await store.withPreparationStop({
+              generation,
+              binary: compiler,
+              deadline,
+              recover: opts.recover,
+              run,
+            })
+          : await store.withMutation({
+              generation,
+              operation,
+              services: [],
+              binary: compiler,
+              deadline,
+              recover: opts.recover,
+              run,
+            });
+        record("returned");
+        return code;
+      } catch (error: unknown) {
+        record("refused", error);
+        throw error;
+      }
     },
     cleanup: async () => {
       if (!lifetime.canRestore()) {
diff --git a/tests/native-compose-adoption-routing-generation.test.ts b/tests/native-compose-adoption-routing-generation.test.ts
index 62a2fcf2d..d6a382ed6 100644
--- a/tests/native-compose-adoption-routing-generation.test.ts
+++ b/tests/native-compose-adoption-routing-generation.test.ts
@@ -2,6 +2,7 @@ import { test as boundedTest, expect, spyOn } from "bun:test";
 import * as fs from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { DEFAULT_COMPOSE_STARTUP_TIMEOUT_MS } from "../src/lib/compose-startup-budget.ts";
 import { isRecord } from "../src/lib/guards.ts";
 import * as admission from "../src/lib/native-compose-adoption-compiler.ts";
 import { LegacyComposeAdoptedGenerationError } from "../src/lib/native-compose-adoption-generation.ts";
@@ -16,16 +17,38 @@ import {
   retainedRoutingFixtureLifetime,
 } from "./helpers/retained-routing-adoption.ts";
 
-/** The compound lifecycle test's per-test budget and its store proof deadline:
- * the product's 60 s cap. */
-const COMPOUND_BUDGET_MS = 60_000;
+/** The compound tests' store proof deadline: the product's 60 s cap. */
+const COMPOUND_STORE_TIMEOUT_MS = 60_000;
+/** The caller deadline of each compound operation: the product's own default
+ * (`hack up`/`down` pass the 90 s Compose startup budget to `withMutation`). */
+const COMPOUND_OPERATION_DEADLINE_MS = DEFAULT_COMPOSE_STARTUP_TIMEOUT_MS;
+/** A compound test's budget: six `COMPOUND_OPERATION_DEADLINE_MS` (540 s), for at
+ * most five caller-bounded operations plus preparation, publication and the
+ * lease or rollback. It must not be shorter than the bounds of the operations it
+ * runs in sequence: a 60 s budget let suite load end a slow but unchanged run
+ * before its operations' own deadlines, and the timed-out fixture then failed every
+ * later test in this file as an unknown lifetime. A hosted run takes about 40 s. */
+const COMPOUND_TEST_BUDGET_MS = 540_000;
+/** A single-operation regression test's budget: two operation deadlines (180 s),
+ * for preparation, the one caller-bounded operation and a publication. */
+const SINGLE_OPERATION_TEST_BUDGET_MS = 180_000;
+/** A synthetic clock advance past the harness's 15 s default operation deadline
+ * but well inside the product's default caller deadline: a slow but unchanged
+ * operation. */
+const SLOW_OPERATION_ADVANCE_MS = 16_000;
 let h: Awaited<ReturnType<typeof retainedRoutingFixture>>;
 let fixtureActive = false;
 let fixtureUncertain = false;
 const test = (
   name: string,
   run: () => Promise<void>,
-  opts: { readonly timeoutMs?: 30_000 | 60_000 } = {}
+  opts: {
+    readonly timeoutMs?:
+      | 30_000
+      | 60_000
+      | typeof SINGLE_OPERATION_TEST_BUDGET_MS
+      | typeof COMPOUND_TEST_BUDGET_MS;
+  } = {}
 ) => {
   const timeoutMs = opts.timeoutMs ?? 30_000;
   return boundedTest(
@@ -214,8 +237,10 @@ test("publication diagnostics distinguish compiler refusal after switching from
 });
 /** Per-phase timing for the compound lifecycle tests. Each marker logs the elapsed
  * and per-phase ms with the probe counts, and `attribute` names the phase in
- * progress when a failure (such as a proof-deadline overrun) surfaces. Only timings
- * and counts are added to the already value-free diagnostic; values stay omitted. */
+ * progress and the last operation's timing (including whether its caller deadline
+ * had expired) when a failure (such as a proof-deadline overrun) surfaces. Only
+ * timings, counts and the refusal code are added to the already value-free
+ * diagnostic; values stay omitted. */
 function compoundPhases(fixture: string) {
   const started = Date.now();
   let lastPhase = "enter";
@@ -249,7 +274,7 @@ function compoundPhases(fixture: string) {
     attribute: (error: unknown) => {
       const now = Date.now();
       return new Error(
-        `${fixture} failed ${now - lastPhaseAt} ms after phase "${lastPhase}" (${now - started} ms elapsed of ${COMPOUND_BUDGET_MS} ms budget): ${String(error)}`,
+        `${fixture} failed ${now - lastPhaseAt} ms after phase "${lastPhase}" (${now - started} ms elapsed of ${COMPOUND_TEST_BUDGET_MS} ms budget; last operation ${JSON.stringify(h.lastOperation() ?? null)}): ${String(error)}`,
         { cause: error }
       );
     },
@@ -264,7 +289,10 @@ async function publishStoppedV14(
   expect(generation.report.adoption_generation_version).toBe(14);
   expect((await h.receipt()).routingHandoff).toBe("held");
   expect(
-    await h.operation(store, generation, "stop", { preparation: true })
+    await h.operation(store, generation, "stop", {
+      preparation: true,
+      deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+    })
   ).toBe(0);
   phase("preparation-stop-return");
   await store.publish({ generation, binary: h.compiler });
@@ -310,7 +338,14 @@ function volumeInspections() {
 // 37999833592). It is split into the two tests below, each on a fresh fixture: the
 // first covers publication, the lifecycle operations and the saved lease; the
 // second covers rollback after a lifecycle cycle. Both open their store at the 60 s
-// product cap. The deadline-refusal controls in this file keep the 15 s default.
+// product cap and give each operation the product's default caller deadline. With
+// the harness's former fixed 15 s operation deadline, the fourth lifecycle operation
+// under suite load expired it and the product's fail-closed deadline guard refused
+// as E_LEGACY_ADOPTION_CHANGED (HACK-1283, run 39289575897); no binding had changed.
+// Each retained routing operation also costs more than the one before it, because
+// every route-claim scan rereads every prior attempt in the fixture's fresh home.
+// Their per-test budget is `COMPOUND_TEST_BUDGET_MS`. The deadline-refusal controls
+// in this file keep the 15 s default.
 test(
   "v14 keeps original resources and data through stop/publication/up/down/up and saved open",
   async () => {
@@ -319,15 +354,21 @@ test(
     );
     phase("prepare-enter");
     const { store, generation } = await prepare({
-      timeoutMs: COMPOUND_BUDGET_MS,
+      timeoutMs: COMPOUND_STORE_TIMEOUT_MS,
     });
     phase("prepare-return");
     try {
       const active = await publishStoppedV14(phase, store, generation);
-      for (const operation of ["start", "stop", "start", "stop"] as const) {
-        expect(await h.operation(store, active, operation)).toBe(0);
+      for (const [index, operation] of (
+        ["start", "stop", "start", "stop"] as const
+      ).entries()) {
+        expect(
+          await h.operation(store, active, operation, {
+            deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+          })
+        ).toBe(0);
+        phase(`lifecycle-${index + 1}-${operation}-return`);
       }
-      phase("four-lifecycle-operations-return");
       await store.withLease({
         generation: active,
         run: async (input) => {
@@ -351,7 +392,7 @@ test(
     // One full cold preparation/publication, four lifecycle operations and a saved lease.
     // Canonical bracketed scans add four probes per stable binding observation.
   },
-  { timeoutMs: COMPOUND_BUDGET_MS }
+  { timeoutMs: COMPOUND_TEST_BUDGET_MS }
 );
 test(
   "v14 rollback after publication and one up/down restores originals and keeps data and the routing hold",
@@ -361,15 +402,19 @@ test(
     );
     phase("prepare-enter");
     const { store, generation } = await prepare({
-      timeoutMs: COMPOUND_BUDGET_MS,
+      timeoutMs: COMPOUND_STORE_TIMEOUT_MS,
     });
     phase("prepare-return");
     try {
       const active = await publishStoppedV14(phase, store, generation);
       for (const operation of ["start", "stop"] as const) {
-        expect(await h.operation(store, active, operation)).toBe(0);
+        expect(
+          await h.operation(store, active, operation, {
+            deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+          })
+        ).toBe(0);
+        phase(`lifecycle-${operation}-return`);
       }
-      phase("lifecycle-cycle-return");
       await store.rollback();
       phase("rollback-return");
       expect(
@@ -393,7 +438,116 @@ test(
     // One full cold preparation/publication, one lifecycle cycle and rollback.
     // Canonical bracketed scans add four probes per stable binding observation.
   },
-  { timeoutMs: COMPOUND_BUDGET_MS }
+  { timeoutMs: COMPOUND_TEST_BUDGET_MS }
+);
+/** Runs one harness operation while a synthetic clock jumps
+ * `SLOW_OPERATION_ADVANCE_MS` ahead after the operation's first probe, so the
+ * operation is slow by the product's own clock but otherwise unchanged. */
+async function slowOperation(run: () => Promise<number>): Promise<number> {
+  const realNow = Date.now;
+  let offset = 0;
+  const clock = spyOn(Date, "now").mockImplementation(() => realNow() + offset);
+  h.hooks.afterProbe = async () => {
+    offset = SLOW_OPERATION_ADVANCE_MS;
+  };
+  try {
+    return await run();
+  } finally {
+    h.hooks.afterProbe = undefined;
+    clock.mockRestore();
+  }
+}
+test(
+  "HACK-1283: an unchanged operation slower than 15 s completes under the product's default caller deadline",
+  async () => {
+    const { store, generation } = await prepare({
+      timeoutMs: COMPOUND_STORE_TIMEOUT_MS,
+    });
+    try {
+      expect(
+        await slowOperation(() =>
+          h.operation(store, generation, "stop", {
+            preparation: true,
+            deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+          })
+        )
+      ).toBe(0);
+      expect(h.lastOperation()).toMatchObject({
+        outcome: "returned",
+        deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+        deadlineExpired: false,
+        bindingUnchanged: true,
+      });
+      expect(h.lastOperation()?.elapsedMs).toBeGreaterThanOrEqual(
+        SLOW_OPERATION_ADVANCE_MS
+      );
+      expect(h.effects).toHaveLength(1);
+      expect((await h.receipt()).pendingOperation).toBeNull();
+      await store.publish({ generation, binary: h.compiler });
+      expect((await h.receipt()).publication?.phase).toBe("active");
+    } finally {
+      await store.close();
+    }
+  },
+  { timeoutMs: SINGLE_OPERATION_TEST_BUDGET_MS }
+);
+test(
+  "HACK-1283: the same slow operation under the 15 s default refuses as CHANGED only because its deadline expired",
+  async () => {
+    const { store, generation } = await prepare({
+      timeoutMs: COMPOUND_STORE_TIMEOUT_MS,
+    });
+    try {
+      await red(
+        slowOperation(() =>
+          h.operation(store, generation, "stop", { preparation: true })
+        )
+      );
+      expect(h.lastOperation()).toMatchObject({
+        outcome: "refused",
+        code: "E_LEGACY_ADOPTION_CHANGED",
+        deadlineMs: 15_000,
+        deadlineExpired: true,
+        // Nothing in the synthetic binding moved: "changed" here is the deadline.
+        bindingUnchanged: true,
+      });
+      expect((await h.receipt()).routingHandoff).toBe("held");
+    } finally {
+      await store.close();
+    }
+  },
+  { timeoutMs: SINGLE_OPERATION_TEST_BUDGET_MS }
+);
+test(
+  "HACK-1283: a real binding change still refuses as CHANGED within the product's default caller deadline",
+  async () => {
+    const { store, generation } = await prepare({
+      timeoutMs: COMPOUND_STORE_TIMEOUT_MS,
+    });
+    try {
+      h.hooks.afterEffect = async () => {
+        h.model.volumeBirth = "2026-02-02T01:02:03Z";
+      };
+      await red(
+        h.operation(store, generation, "stop", {
+          preparation: true,
+          deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+        })
+      );
+      expect(h.lastOperation()).toMatchObject({
+        outcome: "refused",
+        code: "E_LEGACY_ADOPTION_CHANGED",
+        deadlineMs: COMPOUND_OPERATION_DEADLINE_MS,
+        deadlineExpired: false,
+        bindingUnchanged: false,
+      });
+      expect(h.effects).toHaveLength(1);
+    } finally {
+      h.hooks.afterEffect = undefined;
+      await store.close();
+    }
+  },
+  { timeoutMs: SINGLE_OPERATION_TEST_BUDGET_MS }
 );
 test("read-only routing phase refuses volume birth drift at its complete final binding", async () => {
   const { store, generation } = await prepare();
diff --git a/tests/native-plan-cli-wiring.test.ts b/tests/native-plan-cli-wiring.test.ts
new file mode 100644
index 000000000..a96d7db25
--- /dev/null
+++ b/tests/native-plan-cli-wiring.test.ts
@@ -0,0 +1,75 @@
+import { afterEach, expect, test } from "bun:test";
+import { copyFile, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { NATIVE_PLAN_CLI_CHECKS } from "../scripts/check-native-plan-clis.ts";
+
+const root = resolve(import.meta.dir, "..");
+const owned: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    owned.splice(0).map((path) => rm(path, { recursive: true, force: true }))
+  );
+});
+
+/** Compiled-bundle CLI checks that CI runs and the local command must cover. */
+async function discoveredChecks(): Promise<string[]> {
+  const names = await readdir(join(root, "scripts"));
+  return names
+    .filter(
+      (name) =>
+        /^check-native-[a-z-]+-plan-cli\.ts$/.test(name) ||
+        name === "check-native-config-import-cli.ts" ||
+        name === "check-config-compiler-cli.ts"
+    )
+    .map((name) => `scripts/${name}`)
+    .sort();
+}
+
+test("check:native-plan-cli runs every compiled-bundle plan CLI check", async () => {
+  const discovered = await discoveredChecks();
+  expect(discovered.length).toBeGreaterThanOrEqual(8);
+  expect(Array.from(NATIVE_PLAN_CLI_CHECKS, String).sort()).toEqual(discovered);
+
+  const scripts = (await Bun.file(join(root, "package.json")).json()).scripts;
+  expect(scripts["check:native-plan-cli"]).toBe(
+    "bun run check:bun-version && bun scripts/check-native-plan-clis.ts"
+  );
+});
+
+test("every local plan CLI check is also a CI step", async () => {
+  const ci = await Bun.file(join(root, ".github/workflows/ci.yml")).text();
+  for (const script of NATIVE_PLAN_CLI_CHECKS) {
+    expect(ci, `${script} is not run in CI`).toMatch(
+      new RegExp(`^\\s+bun ${script.replaceAll(".", "\\.")}$`, "m")
+    );
+  }
+});
+
+test("the runner refuses to start without the built bundle", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hack-native-plan-cli-"));
+  owned.push(directory);
+  await mkdir(join(directory, "scripts"));
+  await copyFile(
+    join(root, "scripts/check-native-plan-clis.ts"),
+    join(directory, "scripts/check-native-plan-clis.ts")
+  );
+  const child = Bun.spawn(
+    [process.execPath, join(directory, "scripts/check-native-plan-clis.ts")],
+    {
+      cwd: directory,
+      env: { PATH: process.env.PATH ?? "", HOME: directory },
+      stdio: ["ignore", "pipe", "pipe"],
+    }
+  );
+  const [exit, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ]);
+  expect(exit).toBe(1);
+  expect(stdout).toBe("");
+  expect(stderr).toContain("dist/hack is missing");
+  expect(stderr).toContain("bun run build && bun run build:config-compiler");
+});
diff --git a/tests/private-env-file.test.ts b/tests/private-env-file.test.ts
index 798792cae..dabf01520 100644
--- a/tests/private-env-file.test.ts
+++ b/tests/private-env-file.test.ts
@@ -102,8 +102,14 @@ function expectClosedRefusal(error: unknown, paths: readonly string[]): void {
   }
 }
 
-async function caught(promise: Promise<unknown>): Promise<unknown> {
-  return await promise.then(
+/**
+ * Starts `run` and settles it to its rejection (or null). Taking a thunk rather
+ * than a promise keeps every operation started inside the await that observes
+ * it: a promise started earlier can reject while the test awaits something
+ * else, which Bun reports as an unhandled rejection (HACK-1292).
+ */
+async function caught(run: () => Promise<unknown>): Promise<unknown> {
+  return await run().then(
     () => null,
     (error: unknown) => error
   );
@@ -204,13 +210,17 @@ test("negative control: a symlinked .hack/.env is refused without reading or wri
   const project = await createProject();
   await symlink(project.outsideFile, project.envFile);
 
+  // Each attempt starts only inside the caught() that awaits it, so the two
+  // refusals cannot race each other.
   for (const attempt of [
-    upsertDotEnvValue({
-      envFile: project.envFile,
-      key: SENTINEL_KEY,
-      value: SENTINEL_VALUE,
-    }),
-    removeDotEnvKey({ envFile: project.envFile, key: "OUTSIDE_SENTINEL" }),
+    () =>
+      upsertDotEnvValue({
+        envFile: project.envFile,
+        key: SENTINEL_KEY,
+        value: SENTINEL_VALUE,
+      }),
+    () =>
+      removeDotEnvKey({ envFile: project.envFile, key: "OUTSIDE_SENTINEL" }),
   ]) {
     expectClosedRefusal(await caught(attempt), [
       project.envFile,
@@ -229,7 +239,7 @@ test("negative control: a dangling .hack/.env symlink is refused and its target
   await symlink(missingTarget, project.envFile);
 
   expectClosedRefusal(
-    await caught(
+    await caught(() =>
       upsertDotEnvValue({
         envFile: project.envFile,
         key: SENTINEL_KEY,
@@ -248,7 +258,7 @@ test("negative control: an env overlay file that is a symlink is refused", async
   await symlink(project.outsideFile, overlayFile);
 
   expectClosedRefusal(
-    await caught(
+    await caught(() =>
       upsertDotEnvValue({
         envFile: overlayFile,
         key: SENTINEL_KEY,
@@ -273,7 +283,7 @@ test("negative control: a symlinked .hack directory is refused and the linked di
   const envFile = resolve(projectDir, PROJECT_ENV_FILENAME);
 
   expectClosedRefusal(
-    await caught(
+    await caught(() =>
       upsertDotEnvValue({ envFile, key: SENTINEL_KEY, value: SENTINEL_VALUE })
     ),
     [envFile, outsideDir]
@@ -285,7 +295,7 @@ test("a directory at the .hack/.env path is refused with the same closed diagnos
   const project = await createProject();
   await mkdir(project.envFile);
   expectClosedRefusal(
-    await caught(
+    await caught(() =>
       upsertDotEnvValue({
         envFile: project.envFile,
         key: SENTINEL_KEY,
@@ -343,7 +353,7 @@ test("negative control: materializeProjectEnv refuses a symlinked .hack/.env tar
   await symlink(project.outsideFile, project.envFile);
 
   expectClosedRefusal(
-    await caught(
+    await caught(() =>
       materializeProjectEnv({
         projectRoot: project.projectRoot,
         projectDir: project.projectDir,
@@ -373,7 +383,7 @@ test("negative control: replacePrivateFileAtomic itself refuses a symlinked targ
   // cannot mask a missing check in the replace step.
   for (const path of [project.envFile, danglingLink]) {
     expectClosedRefusal(
-      await caught(
+      await caught(() =>
         replacePrivateFileAtomic({
           path,
           directories: [project.projectDir],
diff --git a/turbo.json b/turbo.json
index 0281b3b9a..bc67f558d 100644
--- a/turbo.json
+++ b/turbo.json
@@ -1,5 +1,6 @@
 {
   "$schema": "https://turbo.build/schema.json",
+  "globalPassThroughEnv": ["HACK_ALLOW_BUN_VERSION_MISMATCH"],
   "tasks": {
     "dev": {
       "cache": false,