Environment isn't updated when changes are made to watch_files returned by plugins

[rpendleton]

Problem

When an environment plugin returns watch_files, changes to those watched files don't trigger an environment update in the current shell. You have to cd away and back for the changes to take effect. If you have env_cache enabled, you also have to run mise cache clear before leaving and returning to the current directory.

In my case, I'm seeing this behavior with mise-env-fnox. Given that the plugin relies on fnox config-files to determine its watch_files and that the output of that command looks correct, I'd assume the correct files are making it back to mise. However, after modifying a value via fnox set KEY VALUE, the new value isn't reflected in the shell environment until I leave and re-enter the directory.

By contrast, changes made using mise set KEY=VALUE are reflected immediately.

Output from `mise doctor`

version: 2026.3.9 macos-arm64 (2026-03-13)
activated: yes
shims_on_path: yes
self_update_available: no

build_info:
  Target: aarch64-apple-darwin
  Features: DEFAULT, NATIVE_TLS, SELF_UPDATE
  Built: Fri, 13 Mar 2026 18:39:53 +0000
  Rust Version: rustc 1.94.0 (4a4ef493e 2026-03-02) (Homebrew)
  Profile: release

shell:
  /opt/homebrew/bin/zsh
  zsh 5.9 (arm-apple-darwin21.3.0)

aqua:
  baked in registry tools: 2259

dirs:
  cache: ~/Library/Caches/mise
  config: ~/.config/mise
  data: ~/.local/share/mise
  shims: ~/.local/share/mise/shims
  state: ~/.local/state/mise

config_files:
  ~/.config/mise/config.toml

ignored_config_files: (none)

backends:
  aqua
  asdf
  cargo
  conda
  core
  dotnet
  forgejo
  gem
  github
  gitlab
  go
  npm
  pipx
  spm
  http
  s3
  ubi
  vfox

plugins:

toolset:
  core:dotnet@10.0.201
  core:node@24.14.0
  github:todbot/hidapitester@0.5
  npm:@devcontainers/cli@0.84.0
  npm:ccusage@18.0.10
  npm:degit@2.8.4
  npm:gulp-cli@3.1.0
  npm:happy-coder@0.13.0
  npm:npm-check-updates@19.6.3
  pipx:basic-memory@0.20.2

path:
  ~/.go/bin
  /opt/homebrew/sbin
  ~/.bin
  ~/.local/bin
  /opt/homebrew/opt/grep/libexec/gnubin
  /opt/homebrew/opt/findutils/libexec/gnubin
  /opt/homebrew/opt/coreutils/libexec/gnubin
  ~/.rd/bin
  /Applications/Wireshark.app/Contents/MacOS/extcap
  ~/.local/share/mise/dotnet-root
  ~/.local/share/mise/installs/github-todbot-hidapitester/0.5
  ~/.local/share/mise/installs/node/24.14.0/bin
  ~/.local/share/mise/installs/npm-devcontainers-cli/0.84.0/bin
  ~/.local/share/mise/installs/npm-ccusage/18.0.10/bin
  ~/.local/share/mise/installs/npm-degit/2.8.4/bin
  ~/.local/share/mise/installs/npm-gulp-cli/3.1.0/bin
  ~/.local/share/mise/installs/npm-happy-coder/0.13.0/bin
  ~/.local/share/mise/installs/npm-npm-check-updates/19.6.3/bin
  ~/.local/share/mise/installs/pipx-basic-memory/0.20.2/bin
  ~/.local/share/mise/shims
  ~/.bin/oss-cad-suite/bin
  ~/Library/Application Support/JetBrains/Toolbox/scripts
  /opt/homebrew/bin
  /usr/local/bin
  /System/Cryptexes/App/usr/bin
  /usr/bin
  /bin
  /usr/sbin
  /sbin
  /var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin
  /var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin
  /var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin
  /opt/pmk/env/global/bin
  /opt/X11/bin
  /Library/Apple/usr/bin
  /Applications/Wireshark.app/Contents/MacOS
  /usr/local/share/dotnet
  ~/.dotnet/tools
  ~/.cargo/bin
  /Applications/iTerm.app/Contents/Resources/utilities
  ~/Library/Application Support/JetBrains/Toolbox/scripts
  ~/.orbstack/bin
  ~/.dotnet/tools
  /opt/homebrew/opt/fzf/bin
  ~/.local/bin

env_vars:
  MISE_DEFAULT_CONFIG_FILENAME=.mise.toml
  MISE_SHELL=zsh

settings:
  experimental                         true     ~/.config/mise/config.toml
  idiomatic_version_file_enable_tools  ["ruby"] ~/.config/mise/config.toml

No problems found

Analysis

hook-env runs on each prompt. The relevant steps are:

1. Fast path (should_exit_early_fast) — runs before anything is loaded. Compares mtimes of file paths in PREV_SESSION.watch_files against the session's latest_update timestamp. Exits early if nothing changed.
2. tools=false plugins execute — as a side effect of config loading / assembling watch_files for the slow path.
3. Slow path (should_exit_early) — checks watch_files from config.watch_files(). Exits early if nothing changed.
4. tools=true plugins execute — during load_post_env() inside final_env().
5. Session and env cache are saved — watch_files are persisted for the next prompt's fast-path check, and the env cache stores watch_files for cache invalidation.

When considering plugin-returned watch_files, there's a few problems in that process:

• Fast path: PREV_SESSION.watch_files never includes plugin watch_files, because they were never stored in the session. It exits early and plugins never run. This is true regardless of whether the plugin is tools=true or tools=false.
• Slow path: config.watch_files() chains env_files, env_scripts, and tera files — but not env_results.watch_files. Technically, though, that would only cover the tools=false case, since it hasn't executed tools=true yet.
• Session: env_with_path_and_split() doesn't return watch_files to the caller, so HookEnv::run() can't include them when building the session.
• Env cache: save_env_cache_split() only receives EnvResults from load_post_env() (ToolsOnly), so tools=false plugin watch_files aren't included in CachedEnv. The non-tool cache (CachedNonToolEnv) does track them and properly invalidates — causing the plugin to re-execute — but CachedEnv still considers itself valid and returns the stale full environment, discarding the fresh plugin results.

Potential fixes

There are two related problems to solve: (1) getting plugin watch_files into the session so the fast and slow paths can detect changes, and (2) getting tools=false plugin watch_files into CachedEnv so it properly invalidates. Several changes are needed for complete coverage:

• config.watch_files() could chain env_results.watch_files alongside env_files and env_scripts. Since config.watch_files() uses NonToolsOnly env_results, this covers tools=false plugins only. However, config.watch_files() feeds both the slow-path check and build_session(), so this single change gets tools=false plugin watch_files into both the slow path and the session (and thus the next prompt's fast path).

• env_with_path_and_split() could return the post-env env_results.watch_files so that HookEnv::run() can merge them into the session's watch_files. On the non-cached path, these come from final_env() which runs load_post_env() with ToolsOnly, so this covers tools=true plugins. On a cache hit, CachedEnv.watch_files already has them from the previous run. Since tools=true watch_files aren't available until after env computation, they can't help with the slow-path check on the current prompt — but once in the session, they'll be checked by the fast path on the next prompt.

• The slow-path check could extend its watch_files with PREV_SESSION.watch_files before checking. This bridges the gap for tools=true plugins: their watch_files from the previous session would be checked in the slow path even before load_post_env runs in the current prompt. The fast path already reads PREV_SESSION.watch_files, so this makes the slow path consistent. Requires making HookEnvSession.watch_files pub and passing it to should_exit_early().

• final_env() could merge the NonToolsOnly watch_files into the ToolsOnly env_results before returning. This ensures save_env_cache_split() includes tools=false watch_files in CachedEnv, so changes to those files properly invalidate the full env cache. The NonToolsOnly results are available via config.env_results_cached(), though care is needed to ensure they've been populated before this point (i.e., config.env_results() must have been called first).

From my testing, all of these might be needed for complete coverage, but I'm not very familiar with how mise works so I figured I'd open a discussion instead of a PR.

Potential Patch

I'm not familiar with mise or Rust, but working through this issue with Claude Code led to the following.

Potential patch

diff --git a/src/cli/hook_env.rs b/src/cli/hook_env.rs
index 32e01cae5..1a535550c 100644
--- a/src/cli/hook_env.rs
+++ b/src/cli/hook_env.rs
@@ -72,6 +72,13 @@ impl HookEnv {
             config.watch_files().await?
         };
 
+        // Extend with previously-tracked watch files so the slow-path check covers files
+        // from tools=true env plugins, which aren't included in config.watch_files().
+        let watch_files: BTreeSet<WatchFilePattern> = watch_files
+            .into_iter()
+            .chain(PREV_SESSION.watch_files.iter().map(|p| p.as_path().into()))
+            .collect();
+
         if !self.force && hook_env::should_exit_early(watch_files.clone(), self.reason) {
             trace!("should_exit_early true");
             return Ok(());
@@ -81,7 +88,8 @@ impl HookEnv {
         miseprint!("{}", hook_env::clear_old_env(&*shell))?;
 
         // Use env_with_path_and_split which handles caching internally
-        let (mut mise_env, user_paths, tool_paths) = ts.env_with_path_and_split(&config).await?;
+        let (mut mise_env, user_paths, tool_paths, tool_watch_files) =
+            ts.env_with_path_and_split(&config).await?;
         mise_env.remove(&*PATH_KEY);
 
         // Create config_paths from user_paths for display_status and build_session
@@ -117,6 +125,13 @@ impl HookEnv {
             .map(|(k, (v, _))| (k.clone(), v.clone()))
             .collect();
 
+        // Merge env plugin watch_files (from both tools=true and tools=false directives)
+        // so they are stored in the session for the next prompt's fast-path check.
+        let watch_files: BTreeSet<WatchFilePattern> = watch_files
+            .into_iter()
+            .chain(tool_watch_files.iter().map(|p| p.as_path().into()))
+            .collect();
+
         patches.extend(self.build_path_operations(&user_paths, &tool_paths, &__MISE_DIFF.path)?);
         patches.push(self.build_diff_operation(&diff)?);
         patches.push(
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 99ee20bbe..519af2df8 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -807,6 +807,7 @@ impl Config {
             .flatten()
             .chain(env_results.env_files.iter().map(|p| p.as_path().into()))
             .chain(env_results.env_scripts.iter().map(|p| p.as_path().into()))
+            .chain(env_results.watch_files.iter().map(|p| p.as_path().into()))
             .chain(
                 Settings::get()
                     .env_files()
diff --git a/src/hook_env.rs b/src/hook_env.rs
index 7450f79c5..e9d34f926 100644
--- a/src/hook_env.rs
+++ b/src/hook_env.rs
@@ -350,10 +350,10 @@ pub struct HookEnvSession {
     /// that should be watched for changes.
     #[serde(default)]
     pub tera_files: Vec<PathBuf>,
-    /// Resolved file paths from [[watch_files]] config patterns.
+    /// Resolved file paths from [[watch_files]] config patterns and env plugin watch_files.
     /// Stored so the fast-path can detect changes without loading config.
     #[serde(default)]
-    watch_files: Vec<PathBuf>,
+    pub watch_files: Vec<PathBuf>,
     dir: Option<PathBuf>,
     env_var_hash: String,
     latest_update: u128,
diff --git a/src/toolset/toolset_env.rs b/src/toolset/toolset_env.rs
index aad70eeeb..ffe6796b1 100644
--- a/src/toolset/toolset_env.rs
+++ b/src/toolset/toolset_env.rs
@@ -89,7 +89,7 @@ impl Toolset {
     pub async fn env_with_path_and_split(
         &self,
         config: &Arc<Config>,
-    ) -> Result<(EnvMap, Vec<PathBuf>, Vec<PathBuf>)> {
+    ) -> Result<(EnvMap, Vec<PathBuf>, Vec<PathBuf>, Vec<PathBuf>)> {
         // Try to load from cache if enabled
         if CachedEnv::is_enabled()
             && let Some(cached) = self.try_load_env_cache_full(config)?
@@ -102,7 +102,7 @@ impl Toolset {
                 path_env.add(p.clone());
             }
             env.insert(PATH_KEY.to_string(), path_env.to_string());
-            return Ok((env, cached.user_paths, cached.tool_paths));
+            return Ok((env, cached.user_paths, cached.tool_paths, cached.watch_files));
         }
 
         // Compute fresh
@@ -127,7 +127,7 @@ impl Toolset {
             debug!("env_cache: failed to save: {}", e);
         }
 
-        Ok((env, user_paths, tool_paths))
+        Ok((env, user_paths, tool_paths, env_results.watch_files))
     }
 
     /// Try to load environment from cache (returns full CachedEnv)
@@ -330,6 +330,14 @@ impl Toolset {
         ctx.insert("tools", &self.build_tools_tera_map(config));
         let mut env_results = self.load_post_env(config, ctx, &tera_env).await?;
 
+        // Include NonToolsOnly watch_files (from tools=false plugins) so they are
+        // tracked in the env cache and session alongside ToolsOnly watch_files.
+        if let Some(non_tool_env) = config.env_results_cached() {
+            env_results
+                .watch_files
+                .extend(non_tool_env.watch_files.clone());
+        }
+
         // Store add_paths separately to maintain consistent PATH ordering
         env_results.tool_add_paths = add_paths;