fix(prune): skip remote version resolution for tracked configs

src/cli/install.rs

@@ -233,6 +233,7 @@ impl Install {
                 use_locked_version: true,
                 latest_versions: true,
                 before_date: self.get_before_date()?,
+                offline: false,
             },
             dry_run: self.is_dry_run(),
             locked: Settings::get().locked,

src/cli/prune.rs

@@ -109,7 +109,7 @@ pub async fn prunable_tools(
     }
 
     // Remove versions that are still needed by tracked configs
-    let needed_versions = get_versions_needed_by_tracked_configs(config, true).await?;
+    let needed_versions = get_versions_needed_by_tracked_configs(config, true, true).await?;
     for key in needed_versions {
         to_delete.remove(&key);
     }

src/cli/upgrade.rs

@@ -117,6 +117,7 @@ impl Upgrade {
             use_locked_version: false,
             latest_versions: true,
             before_date,
+            offline: false,
         };
         // Filter tools to check before doing expensive version lookups
         let filter_tools = if !self.interactive && !self.tool.is_empty() {
@@ -260,6 +261,7 @@ impl Upgrade {
                 use_locked_version: false,
                 latest_versions: true,
                 before_date,
+                offline: false,
             },
             ..Default::default()
         };
@@ -338,7 +340,7 @@ impl Upgrade {
         // Get versions needed by tracked configs AFTER upgrade
         // This ensures we don't uninstall versions still needed by other projects
         let versions_needed_by_tracked =
-            get_versions_needed_by_tracked_configs(config, false).await?;
+            get_versions_needed_by_tracked_configs(config, false, false).await?;
 
         // Only uninstall old versions of tools that were successfully upgraded
         // and are not needed by any tracked config

src/cli/use.rs

@@ -144,6 +144,7 @@ impl Use {
             latest_versions: false,
             use_locked_version: true,
             before_date: self.get_before_date()?,
+            offline: false,
         };
         let versions: Vec<_> = self
             .tool

src/toolset/mod.rs

@@ -602,13 +602,17 @@ impl From<ToolRequestSet> for Toolset {
 pub async fn get_versions_needed_by_tracked_configs(
     config: &Arc<Config>,
     use_locked_version: bool,
+    offline: bool,
 ) -> Result<std::collections::HashSet<(String, String)>> {
     let mut needed = std::collections::HashSet::new();
     // `mise prune` should keep versions pinned by lockfiles. `mise upgrade`
     // passes false because it checks what tracked configs resolve to after an
     // upgrade, before their lockfiles have been updated.
+    // Prune also passes offline=true: it only protects installed versions, so
+    // remote resolution can never affect the outcome and just adds latency.
     let opts = ResolveOptions {
         use_locked_version,
+        offline,
         ..Default::default()
     };
     for (path, cf) in config.get_tracked_config_files().await? {

src/toolset/tool_version.rs

@@ -227,6 +227,7 @@ impl ToolVersion {
             latest_versions: true,
             use_locked_version: false,
             before_date: base_opts.before_date,
+            offline: base_opts.offline,
         };
         let tv = self.request.resolve(config, &opts).await?;
         // map cargo backend specific prefixes to ref
@@ -339,7 +340,7 @@ impl ToolVersion {
         }
 
         let settings = Settings::get();
-        let is_offline = settings.offline();
+        let is_offline = settings.offline() || opts.offline;
 
         if v == "latest" {
             if !opts.latest_versions
@@ -362,6 +363,13 @@ impl ToolVersion {
                     return build(v);
                 }
             }
+            // Prune-style offline (opts.offline) wants a non-erroring no-op
+            // when nothing is installed — the literal "latest" can't match
+            // any installed pathname so it's safe. Global MISE_OFFLINE keeps
+            // the original error to avoid surprising upgrade/outdated callers.
+            if opts.offline {
+                return build(v);
+            }
             return Err(Self::no_versions_found(&backend, opts.before_date));
         }
         if !opts.latest_versions {
@@ -449,6 +457,21 @@ impl ToolVersion {
         opts: &ResolveOptions,
     ) -> Result<Self> {
         let backend = request.backend()?;
+        if v == "latest" && opts.offline {
+            // Use the latest installed version as the basis for the sub
+            // computation so the resolved concrete version still matches an
+            // installed pathname (and gets protected from prune). Falling
+            // straight to the raw "sub-N:latest" string would never match
+            // anything in `to_delete`.
+            if !opts.latest_versions
+                && let Some(latest) = backend.latest_installed_version(None)?
+            {
+                let v = tool_request::version_sub(&latest, sub);
+                return Box::pin(Self::resolve_version(config, request, &v, opts)).await;
+            }
+            let version = request.version();
+            return Ok(Self::new(request, version));
+        }
         let v = match v {
             "latest" => backend
                 .latest_version(config, None, opts.before_date)
@@ -472,6 +495,9 @@ impl ToolVersion {
         {
             return Ok(Self::new(request, v.to_string()));
         }
+        if opts.offline {
+            return Ok(Self::new(request, prefix.to_string()));
+        }
         let matches = backend
             .list_versions_matching_with_opts(config, prefix, opts.before_date)
             .await?;
@@ -553,6 +579,8 @@ pub struct ResolveOptions {
     pub use_locked_version: bool,
     /// Only consider versions released before this timestamp
     pub before_date: Option<Timestamp>,
+    /// Additive to `Settings::offline()` — either being true skips remote version listing.
+    pub offline: bool,
 }
 
 impl Default for ResolveOptions {
@@ -561,6 +589,7 @@ impl Default for ResolveOptions {
             latest_versions: false,
             use_locked_version: true,
             before_date: None,
+            offline: false,
         }
     }
 }
@@ -598,6 +627,9 @@ impl Display for ResolveOptions {
         if let Some(ts) = &self.before_date {
             opts.push(format!("before_date={ts}"));
         }
+        if self.offline {
+            opts.push("offline".to_string());
+        }
         write!(f, "({})", opts.join(", "))
     }
 }