From 48f9891fc40f7bd94289e7a9e9a03a8fcb7fa6b5 Mon Sep 17 00:00:00 2001
From: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com>
Date: Sun, 1 Nov 2026 14:11:50 +0800
Subject: [PATCH] fix: store rebuildable Windows data in Local

---
 Cargo.lock                                   |   1 +
 crates/ide-host/Cargo.toml                   |   3 +
 crates/ide-host/src/bin/server.rs            |   1 +
 crates/ide-host/src/data_dirs.rs             | 447 +++++++++++++++++++
 crates/ide-host/src/lib.rs                   |  23 +-
 crates/ide-host/src/ops/agent.rs             |   2 +-
 crates/ide-host/src/ops/debug.rs             |   2 +-
 crates/ide-host/src/ops/doc/tests.rs         |   1 +
 crates/ide-host/src/ops/java.rs              |   2 +-
 crates/ide-host/src/ops/tools.rs             |   4 +-
 crates/ide-host/src/project.rs               |  14 +-
 crates/ide-host/tests/data_dirs.rs           |  39 ++
 crates/ide-host/tests/light_edit.rs          |   1 +
 crates/ide-host/tests/properties.rs          |   1 +
 crates/ide-host/tests/proxy.rs               |   1 +
 crates/ide-host/tests/remote_env.rs          |   1 +
 crates/ide-host/tests/rpc.rs                 |   3 +
 crates/ide-host/tests/run_configs.rs         |   1 +
 crates/ide-host/tests/terminal_activation.rs |   1 +
 crates/ide-host/tests/trust.rs               |   1 +
 crates/ide-host/tests/trust_git_binary.rs    |   1 +
 crates/ide-host/tests/vcs_encoding.rs        |   1 +
 crates/ide-host/tests/vcs_roots.rs           |   1 +
 crates/ide-host/tests/workspaces.rs          |   1 +
 crates/ide-workspace/src/caches.rs           |  56 ++-
 perf/compare/apps.toml                       |   2 +-
 src-tauri/src/lib.rs                         |   2 +-
 src-tauri/src/remote_dev.rs                  |  11 +-
 src-tauri/src/state.rs                       |   9 +-
 29 files changed, 603 insertions(+), 30 deletions(-)
 create mode 100644 crates/ide-host/src/data_dirs.rs
 create mode 100644 crates/ide-host/tests/data_dirs.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8c1ab6344..cf9903a94 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4250,6 +4250,7 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "uuid",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/crates/ide-host/Cargo.toml b/crates/ide-host/Cargo.toml
index 4518fa0ff..c2ac796ee 100644
--- a/crates/ide-host/Cargo.toml
+++ b/crates/ide-host/Cargo.toml
@@ -52,3 +52,6 @@ uuid.workspace = true
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "io-util", "test-util"] }
 tempfile.workspace = true
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.61", features = ["Win32_Storage_FileSystem"] }
diff --git a/crates/ide-host/src/bin/server.rs b/crates/ide-host/src/bin/server.rs
index 6f405fcbc..ada210d86 100644
--- a/crates/ide-host/src/bin/server.rs
+++ b/crates/ide-host/src/bin/server.rs
@@ -55,6 +55,7 @@ async fn run(base: PathBuf) -> i32 {
     let sink_peer = peer.clone();
     let host = Arc::new(Host::new(HostConfig {
         config_dir,
+        local_data_dir: data_dir.clone(),
         data_dir,
         languages,
         syntax: Arc::default(),
diff --git a/crates/ide-host/src/data_dirs.rs b/crates/ide-host/src/data_dirs.rs
new file mode 100644
index 000000000..4164212f7
--- /dev/null
+++ b/crates/ide-host/src/data_dirs.rs
@@ -0,0 +1,447 @@
+//! Storage policy and best-effort migration of rebuildable desktop data.
+
+use std::fs;
+use std::io;
+use std::path::{Path, PathBuf};
+
+/// Unknown entries and recovery/user content deliberately stay in roaming data.
+pub fn is_local(entry: &Path) -> bool {
+    ["tools", "language-server-runtimes", "index", "cache", "lsp", "notebook-runtime", "server", "logs"]
+        .iter()
+        .any(|root| entry.starts_with(root))
+        || entry.starts_with("agents/tools")
+        || entry == Path::new("agents/registry.json")
+        || (entry.components().count() == 1
+            && entry.file_name().is_some_and(|name| name.to_string_lossy().starts_with("java-usages-"))
+            && entry.extension().is_some_and(|ext| ext == "jar" || ext == "tmp"))
+}
+
+pub fn data_path(data: &Path, local: &Path, entry: &Path) -> PathBuf {
+    if is_local(entry) { local.join(entry) } else { data.join(entry) }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum Action {
+    Skip,
+    Rename,
+}
+
+fn action(same_root: bool, source_exists: bool, target_exists: bool) -> Action {
+    if same_root || !source_exists || target_exists { Action::Skip } else { Action::Rename }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum RenameFailure {
+    Copy,
+    KeepSource,
+}
+
+fn rename_failure(error: &io::Error) -> RenameFailure {
+    if error.kind() == io::ErrorKind::CrossesDevices { RenameFailure::Copy } else { RenameFailure::KeepSource }
+}
+
+/// Only Windows splits these paths. Renames are cheap; cross-volume copies run in
+/// the background. Consumers always use Local, even when migration fails.
+pub fn migrate(data: &Path, local: &Path) {
+    if cfg!(target_os = "windows") && data != local {
+        migrate_entries(data, local);
+    }
+}
+
+fn migrate_entries(data: &Path, local: &Path) {
+    let mut entries: Vec<PathBuf> = [
+        "language-server-runtimes",
+        "index",
+        "cache",
+        "lsp",
+        "notebook-runtime",
+        "server",
+        "java-usages-1.1.1.jar",
+        "agents/registry.json",
+    ]
+    .into_iter()
+    .map(PathBuf::from)
+    .collect();
+    // Virtual environments contain absolute interpreter paths. Keep the old copy
+    // intact; these tools are installed afresh in Local when requested. Registry
+    // agents also have absolute commands in user config, so leave legacy installs.
+    match fs::read_dir(data.join("tools")) {
+        Ok(tools) => {
+            for entry in tools {
+                let entry = match entry {
+                    Ok(entry) => entry,
+                    Err(error) => {
+                        tracing::warn!(%error, "cannot enumerate legacy tool; keeping old data, using Local");
+                        continue;
+                    }
+                };
+                let name = entry.file_name();
+                let venv = ide_tools::registry::TOOLS.iter().any(|tool| {
+                    name == tool.name && matches!(tool.method, ide_tools::registry::Method::PipVenv { .. })
+                });
+                if venv {
+                    tracing::info!(?name, "leaving non-relocatable legacy tool; reinstall into Local when needed");
+                } else {
+                    entries.push(Path::new("tools").join(name));
+                }
+            }
+        }
+        Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+        Err(error) => tracing::warn!(%error, "cannot enumerate legacy tools; keeping old data, using Local"),
+    }
+    let mut copies = Vec::new();
+    for entry in entries {
+        let source = data.join(&entry);
+        let target = data_path(data, local, &entry);
+        match try_rename(&source, &target) {
+            Ok(true) => copies.push((source, target)),
+            Ok(false) => {}
+            Err(error) => {
+                tracing::warn!(?source, ?target, %error, "data migration failed; keeping old data, using Local")
+            }
+        }
+    }
+    if !copies.is_empty() {
+        let result = std::thread::Builder::new().name("openidea-data-migration".into()).spawn(move || {
+            for (source, target) in copies {
+                tracing::info!(?source, ?target, "copying legacy data in background");
+                if let Err(error) = copy_then_remove(&source, &target) {
+                    tracing::warn!(?source, ?target, %error, "data copy failed; keeping old data, using Local");
+                }
+            }
+        });
+        if let Err(error) = result {
+            tracing::warn!(%error, "cannot start data migration worker; keeping old data, using Local");
+        }
+    }
+}
+
+/// Returns true when a cross-volume copy is needed.
+fn try_rename(source: &Path, target: &Path) -> io::Result<bool> {
+    if action(source == target, source.try_exists()?, target.try_exists()?) == Action::Skip {
+        return Ok(false);
+    }
+    if fs::symlink_metadata(source)?.file_type().is_symlink() {
+        return Err(io::Error::other("refusing to migrate a linked data entry"));
+    }
+    fs::create_dir_all(target.parent().ok_or_else(|| io::Error::other("missing data parent"))?)?;
+    // Relative wrappers work at the old location too, so even a failed rename
+    // leaves the old installation usable and needs no rollback.
+    relocate_shims(source, source)?;
+    match rename_missing(source, target) {
+        Ok(()) => {
+            tracing::info!(?source, ?target, "moved legacy data to Local");
+            Ok(false)
+        }
+        Err(error) if rename_failure(&error) == RenameFailure::Copy => Ok(true),
+        Err(error) => Err(error),
+    }
+}
+
+fn copy_then_remove(source: &Path, target: &Path) -> io::Result<()> {
+    if target.try_exists()? {
+        return Ok(());
+    }
+    let parent = target.parent().ok_or_else(|| io::Error::other("missing data parent"))?;
+    fs::create_dir_all(parent)?;
+    let staging = parent.join(format!(".migration-{}", uuid::Uuid::new_v4()));
+    let result = (|| {
+        copy_tree(source, &staging)?;
+        relocate_shims(&staging, source)?;
+        // A tool may have been installed or a cache rebuilt while copying. Never
+        // merge into or overwrite it, and retain the original for recovery.
+        if target.try_exists()? {
+            tracing::info!(?source, ?target, "Local data created during migration; retaining legacy copy");
+            return Ok(());
+        }
+        rename_missing(&staging, target)?;
+        remove_entry(source)?;
+        tracing::info!(?source, ?target, "copied legacy data to Local");
+        Ok(())
+    })();
+    if staging.exists() {
+        let _ = remove_entry(&staging);
+    }
+    result
+}
+
+// std::fs::rename may replace even an empty directory on modern Windows.
+#[cfg(windows)]
+fn rename_missing(source: &Path, target: &Path) -> io::Result<()> {
+    use std::os::windows::ffi::OsStrExt;
+    use windows_sys::Win32::Storage::FileSystem::MoveFileExW;
+
+    // canonicalize supplies extended-length paths, including redirected UNC roots.
+    let source = fs::canonicalize(source)?;
+    let target = fs::canonicalize(target.parent().ok_or_else(|| io::Error::other("missing data parent"))?)?
+        .join(target.file_name().ok_or_else(|| io::Error::other("missing data name"))?);
+    let wide = |path: &Path| -> io::Result<Vec<u16>> {
+        let mut value: Vec<u16> = path.as_os_str().encode_wide().collect();
+        if value.contains(&0) {
+            return Err(io::Error::new(io::ErrorKind::InvalidInput, "NUL in data path"));
+        }
+        value.push(0);
+        Ok(value)
+    };
+    let source = wide(&source)?;
+    let target = wide(&target)?;
+    // SAFETY: both paths are valid NUL-terminated UTF-16 buffers. No flags means
+    // neither replacement nor implicit cross-volume copying is permitted.
+    if unsafe { MoveFileExW(source.as_ptr(), target.as_ptr(), 0) } == 0 {
+        Err(io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+// Filesystem tests run on Unix too; production migration is Windows-only.
+#[cfg(not(windows))]
+fn rename_missing(source: &Path, target: &Path) -> io::Result<()> {
+    if target.try_exists()? {
+        return Err(io::Error::from(io::ErrorKind::AlreadyExists));
+    }
+    fs::rename(source, target)
+}
+
+fn remove_entry(path: &Path) -> io::Result<()> {
+    if fs::symlink_metadata(path)?.is_dir() { fs::remove_dir_all(path) } else { fs::remove_file(path) }
+}
+
+fn copy_tree(source: &Path, target: &Path) -> io::Result<()> {
+    let metadata = fs::symlink_metadata(source)?;
+    if metadata.file_type().is_symlink() {
+        return Err(io::Error::other("refusing to follow a link during data migration"));
+    }
+    if metadata.is_dir() {
+        fs::create_dir(target)?;
+        for entry in fs::read_dir(source)? {
+            let entry = entry?;
+            copy_tree(&entry.path(), &target.join(entry.file_name()))?;
+        }
+    } else if metadata.is_file() {
+        fs::copy(source, target)?;
+    } else {
+        return Err(io::Error::other("unsupported data entry"));
+    }
+    Ok(())
+}
+
+/// Make our absolute .cmd wrappers relative to their bin directory. They remain
+/// valid in both locations if the move must be rolled back. npm shims already use
+/// relative paths; payloads and user configuration are never rewritten.
+fn relocate_shims(root: &Path, source: &Path) -> io::Result<()> {
+    if source.parent().and_then(Path::file_name).is_none_or(|name| name != "tools") {
+        return Ok(());
+    }
+    let bin = root.join("bin");
+    if !bin.is_dir() {
+        return Ok(());
+    }
+    for entry in fs::read_dir(bin)? {
+        let path = entry?.path();
+        if path.extension().is_none_or(|ext| ext != "cmd") {
+            continue;
+        }
+        let text = fs::read_to_string(&path)?;
+        if text.starts_with("@echo off\r\n") {
+            let updated = text.replace(source.to_string_lossy().as_ref(), "%~dp0..");
+            if updated != text {
+                fs::write(path, updated)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn storage_policy_is_conservative_and_preserves_unix_layout() {
+        for entry in [
+            "tools/jdks",
+            "language-server-runtimes",
+            "lsp/jdtls",
+            "index/x",
+            "cache/x",
+            "notebook-runtime",
+            "server",
+            "logs",
+            "agents/tools",
+            "agents/registry.json",
+            "java-usages-1.1.1.jar",
+        ] {
+            assert!(is_local(Path::new(entry)), "{entry}");
+            assert_eq!(
+                data_path(Path::new("roaming"), Path::new("local"), Path::new(entry)),
+                Path::new("local").join(entry)
+            );
+            assert_eq!(
+                data_path(Path::new("data"), Path::new("data"), Path::new(entry)),
+                Path::new("data").join(entry)
+            );
+        }
+        for entry in [
+            "git-credentials.json",
+            "history",
+            "remote",
+            "scratches",
+            "consoles",
+            "plugins",
+            "workspaces",
+            "agents/models.json",
+            "agents/project",
+            "unknown",
+        ] {
+            assert!(!is_local(Path::new(entry)), "{entry}");
+            assert_eq!(
+                data_path(Path::new("roaming"), Path::new("local"), Path::new(entry)),
+                Path::new("roaming").join(entry)
+            );
+        }
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    #[test]
+    fn unix_startup_does_not_migrate_even_if_given_distinct_roots() {
+        assert_eq!(dirs::data_dir(), dirs::data_local_dir());
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old");
+        let new = tmp.path().join("new");
+        fs::create_dir_all(old.join("index")).unwrap();
+        migrate(&old, &new);
+        assert!(old.join("index").exists());
+        assert!(!new.exists());
+    }
+
+    #[test]
+    fn decisions_cover_missing_existing_and_failed_renames() {
+        assert_eq!(action(true, true, false), Action::Skip);
+        assert_eq!(action(false, false, false), Action::Skip);
+        assert_eq!(action(false, true, true), Action::Skip);
+        assert_eq!(action(false, true, false), Action::Rename);
+        assert_eq!(rename_failure(&io::Error::from(io::ErrorKind::CrossesDevices)), RenameFailure::Copy);
+        for kind in [io::ErrorKind::PermissionDenied, io::ErrorKind::AlreadyExists, io::ErrorKind::NotFound] {
+            assert_eq!(rename_failure(&io::Error::from(kind)), RenameFailure::KeepSource);
+        }
+    }
+
+    #[test]
+    fn same_volume_moves_and_second_start_does_not_overwrite() {
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old");
+        let new = tmp.path().join("new");
+        fs::create_dir_all(old.join("tools/demo/bin")).unwrap();
+        let wrapper = format!("@echo off\r\n\"{}/payload.exe\" %*\r\n", old.join("tools/demo").display());
+        fs::write(old.join("tools/demo/bin/demo.cmd"), wrapper).unwrap();
+        fs::create_dir_all(old.join("tools/ty/venv")).unwrap();
+        fs::write(old.join("git-credentials.json"), "secret").unwrap();
+        fs::create_dir_all(old.join("index")).unwrap();
+        migrate_entries(&old, &new);
+        assert!(!old.join("tools/demo").exists());
+        assert!(old.join("tools/ty/venv").exists());
+        assert!(old.join("git-credentials.json").exists());
+        assert!(fs::read_to_string(new.join("tools/demo/bin/demo.cmd")).unwrap().contains("%~dp0.."));
+        fs::create_dir_all(old.join("index")).unwrap();
+        fs::write(old.join("index/legacy"), "old").unwrap();
+        migrate_entries(&old, &new);
+        assert!(old.join("index/legacy").exists());
+        assert!(!new.join("index/legacy").exists());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn copy_failure_does_not_publish_or_remove_source() {
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old");
+        let new = tmp.path().join("new");
+        fs::create_dir(&old).unwrap();
+        fs::write(old.join("payload"), "old").unwrap();
+        std::os::unix::fs::symlink(old.join("payload"), old.join("link")).unwrap();
+        assert!(copy_then_remove(&old, &new).is_err());
+        assert!(old.join("payload").exists());
+        assert!(!new.exists());
+        assert_eq!(fs::read_dir(tmp.path()).unwrap().count(), 1);
+    }
+
+    #[test]
+    fn staged_copy_publishes_complete_data_and_preserves_existing_target() {
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old");
+        let new = tmp.path().join("new");
+        fs::create_dir_all(old.join("nested")).unwrap();
+        fs::write(old.join("nested/tool.exe"), "payload").unwrap();
+        copy_then_remove(&old, &new).unwrap();
+        assert!(!old.exists());
+        assert_eq!(fs::read_to_string(new.join("nested/tool.exe")).unwrap(), "payload");
+        fs::create_dir(&old).unwrap();
+        fs::write(old.join("legacy"), "old").unwrap();
+        copy_then_remove(&old, &new).unwrap();
+        assert!(old.join("legacy").exists());
+        assert!(!new.join("legacy").exists());
+        let old_file = tmp.path().join("registry-old.json");
+        let new_file = tmp.path().join("registry-new.json");
+        fs::write(&old_file, "cached registry").unwrap();
+        copy_then_remove(&old_file, &new_file).unwrap();
+        assert!(!old_file.exists());
+        assert_eq!(fs::read_to_string(new_file).unwrap(), "cached registry");
+    }
+
+    #[test]
+    fn publication_refuses_existing_files_and_empty_directories() {
+        let tmp = tempfile::tempdir().unwrap();
+        for directory in [false, true] {
+            let old = tmp.path().join(if directory { "old-dir" } else { "old-file" });
+            let new = tmp.path().join(if directory { "new-dir" } else { "new-file" });
+            if directory {
+                fs::create_dir(&old).unwrap();
+                fs::create_dir(&new).unwrap();
+                fs::write(old.join("payload"), "old").unwrap();
+            } else {
+                fs::write(&old, "old").unwrap();
+                fs::write(&new, "new").unwrap();
+            }
+            assert!(rename_missing(&old, &new).is_err());
+            assert!(old.exists() && new.exists());
+            if directory {
+                assert!(!new.join("payload").exists());
+            } else {
+                assert_eq!(fs::read_to_string(new).unwrap(), "new");
+            }
+        }
+    }
+
+    #[test]
+    fn wrapper_failure_keeps_the_old_installation() {
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old/tools/demo");
+        let new = tmp.path().join("new/tools/demo");
+        fs::create_dir_all(old.join("bin")).unwrap();
+        fs::write(old.join("bin/demo.cmd"), [0xff, 0xfe]).unwrap();
+        assert!(try_rename(&old, &new).is_err());
+        assert!(old.join("bin/demo.cmd").exists());
+        assert!(!new.exists());
+    }
+
+    #[test]
+    fn failures_keep_source_without_publishing_partial_data() {
+        let tmp = tempfile::tempdir().unwrap();
+        let old = tmp.path().join("old");
+        let blocker = tmp.path().join("blocker");
+        fs::create_dir(&old).unwrap();
+        fs::write(old.join("payload"), "old").unwrap();
+        fs::write(&blocker, "file").unwrap();
+        assert!(try_rename(&old, &blocker.join("target")).is_err());
+        assert!(copy_then_remove(&old, &blocker.join("target")).is_err());
+        assert!(old.join("payload").exists());
+        assert!(copy_then_remove(&tmp.path().join("missing"), &tmp.path().join("new")).is_err());
+        assert!(!tmp.path().join("new").exists());
+        assert!(
+            !fs::read_dir(tmp.path())
+                .unwrap()
+                .flatten()
+                .any(|e| e.file_name().to_string_lossy().starts_with(".migration-"))
+        );
+    }
+}
diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rs
index ccb01db4a..4b6837bac 100644
--- a/crates/ide-host/src/lib.rs
+++ b/crates/ide-host/src/lib.rs
@@ -3,6 +3,7 @@
 //! wraps one [`Host`] and adds windows, menus and plugins; `openidea-server`
 //! runs one on a remote machine and serves it over JSON-RPC ([`rpc`]).
 
+pub mod data_dirs;
 pub mod environment;
 mod java_runtime;
 pub mod notebook;
@@ -31,7 +32,10 @@ pub type SinkFactory = Box<dyn Fn(&str) -> SharedSink + Send + Sync>;
 
 pub struct HostConfig {
     pub config_dir: PathBuf,
+    /// Persistent user state, including credentials and recovery history.
     pub data_dir: PathBuf,
+    /// Machine-local tools and rebuildable caches.
+    pub local_data_dir: PathBuf,
     pub languages: Arc<LanguageRegistry>,
     /// Grammars, possibly still being built on another thread.
     pub syntax: Arc<OnceLock<Arc<Syntax>>>,
@@ -47,7 +51,10 @@ pub struct HostConfig {
 pub struct Host {
     pub trust: trust::TrustStore,
     pub config_dir: PathBuf,
+    /// Persistent user state, including credentials and recovery history.
     pub data_dir: PathBuf,
+    /// Machine-local tools and rebuildable caches.
+    pub local_data_dir: PathBuf,
     pub languages: Arc<LanguageRegistry>,
     syntax: Arc<OnceLock<Arc<Syntax>>>,
     pub global_settings: SettingsStore,
@@ -74,8 +81,17 @@ pub struct Host {
 
 impl Host {
     pub fn new(config: HostConfig) -> Self {
-        let HostConfig { config_dir, data_dir, languages, syntax, sink_for, owner, runtime, project_environment } =
-            config;
+        let HostConfig {
+            config_dir,
+            data_dir,
+            local_data_dir,
+            languages,
+            syntax,
+            sink_for,
+            owner,
+            runtime,
+            project_environment,
+        } = config;
         let global_settings = SettingsStore::load(&config_dir, None);
         let ssh = Arc::new(ide_ssh::SshManager::new(data_dir.join("ssh-passwords.json")));
         ssh.set_configs(global_settings.effective().ssh.configs);
@@ -84,7 +100,7 @@ impl Host {
             proxy_password: ide_ssh::secrets::SecretFile::new(data_dir.join("proxy-password.json")),
             remote: Arc::new(ide_remote::RemoteService::new(ssh.clone(), data_dir.join("remote"))),
             ssh,
-            environment: environment::Environment::new(project_environment, data_dir.clone()),
+            environment: environment::Environment::new(project_environment, local_data_dir.clone()),
             global_settings,
             // Sessions, runs and terminals report to the window that started them (`window_sink`).
             terminals: TerminalManager::new(),
@@ -94,6 +110,7 @@ impl Host {
             syntax,
             config_dir,
             data_dir,
+            local_data_dir,
             sink_for,
             owner,
             runtime,
diff --git a/crates/ide-host/src/ops/agent.rs b/crates/ide-host/src/ops/agent.rs
index 47f089f92..f72d603cb 100644
--- a/crates/ide-host/src/ops/agent.rs
+++ b/crates/ide-host/src/ops/agent.rs
@@ -25,7 +25,7 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
 
 /// Where ACP Registry agents are saved (`<config>/agents`, like the user's own) and installed.
 pub(crate) fn registry_paths(host: &Host) -> RegistryPaths {
-    RegistryPaths::new(&host.config_dir, &host.data_dir)
+    RegistryPaths::new(&host.config_dir, &host.local_data_dir)
 }
 
 fn join_err(e: impl std::fmt::Display) -> IdeError {
diff --git a/crates/ide-host/src/ops/debug.rs b/crates/ide-host/src/ops/debug.rs
index 492ce8425..e02f35230 100644
--- a/crates/ide-host/src/ops/debug.rs
+++ b/crates/ide-host/src/ops/debug.rs
@@ -39,7 +39,7 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
             .await?;
     }
     if config.adapter == ide_dap::kotlin::ADAPTER {
-        let data_dir = host.data_dir.clone();
+        let data_dir = host.local_data_dir.clone();
         let runtime_root = config.cwd.clone().map(PathBuf::from).unwrap_or_default();
         let runtime_settings = settings.clone();
         let runtime = host
diff --git a/crates/ide-host/src/ops/doc/tests.rs b/crates/ide-host/src/ops/doc/tests.rs
index 2f8d8bda2..6c649bed6 100644
--- a/crates/ide-host/src/ops/doc/tests.rs
+++ b/crates/ide-host/src/ops/doc/tests.rs
@@ -30,6 +30,7 @@ impl Fixture {
         let host = Host::new(HostConfig {
             config_dir: base.join("config"),
             data_dir: base.join("data"),
+            local_data_dir: base.join("data"),
             languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
             syntax: Arc::default(),
             sink_for: Box::new(move |_| {
diff --git a/crates/ide-host/src/ops/java.rs b/crates/ide-host/src/ops/java.rs
index 4eccfb01f..e08b04092 100644
--- a/crates/ide-host/src/ops/java.rs
+++ b/crates/ide-host/src/ops/java.rs
@@ -42,7 +42,7 @@ async fn resolve_launch(
     // Let jdtls finish its build before the external compiler writes Kotlin/Scala classes.
     let mut info = project.lsp.java_launch(&module, test, build, cancel).await?;
     let lsp_ms = started.elapsed().as_millis();
-    let data_dir = host.data_dir.clone();
+    let data_dir = host.local_data_dir.clone();
     let cancel = cancel.clone();
     tokio::task::spawn_blocking(move || {
         let built = if build && compile::has_non_java_sources(&module) {
diff --git a/crates/ide-host/src/ops/tools.rs b/crates/ide-host/src/ops/tools.rs
index f87b5799c..f2a84d73b 100644
--- a/crates/ide-host/src/ops/tools.rs
+++ b/crates/ide-host/src/ops/tools.rs
@@ -12,7 +12,7 @@ use std::path::PathBuf;
 /// The installer, reporting the executables chosen in the window's settings.
 fn tools(host: &Host, window: &str) -> IdeResult<Tools> {
     host.require_trust(window)?;
-    let data = host.data_dir.clone();
+    let data = host.local_data_dir.clone();
     let (settings, root) = match host.project(window) {
         Ok(project) => (project.settings.effective(), project.root.clone()),
         Err(_) => (host.global_settings.effective(), Default::default()),
@@ -113,7 +113,7 @@ pub async fn jdk_download_releases(
 
 /// Where Download JDK puts JDKs unless told otherwise.
 pub fn jdk_download_location(host: &Host, _window: &str) -> IdeResult<ide_core::IpcPath> {
-    Ok(ide_tools::jdk::jdks_dir(&host.data_dir).into())
+    Ok(ide_tools::jdk::jdks_dir(&host.local_data_dir).into())
 }
 
 /// Downloads the latest `vendor` JDK of Java `version` into `location` (default:
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index 24cc4aa34..9af77d203 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -109,7 +109,7 @@ impl Host {
         let project_key = project_key(&root);
         let index = ProjectIndex::open(
             &root,
-            &self.data_dir.join("index").join(&project_key),
+            &self.local_data_dir.join("index").join(&project_key),
             index_roots(&root, extra_roots.clone()),
             excludes.clone(),
             languages.clone(),
@@ -124,7 +124,7 @@ impl Host {
         {
             let settings = settings.clone();
             let root = root.clone();
-            let data_dir = self.data_dir.clone();
+            let data_dir = self.local_data_dir.clone();
             let config_dir = self.config_dir.clone();
             lsp.set_config_hook(Box::new(move |cfg, server_root| {
                 let member = ide_workspace::workspace::Workspace::load(&root).ok().flatten().and_then(|w| {
@@ -187,7 +187,7 @@ impl Host {
         {
             let settings = settings.clone();
             let root = root.clone();
-            let data_dir = self.data_dir.clone();
+            let data_dir = self.local_data_dir.clone();
             let sink = sink.clone();
             lsp.set_prepare_hook(Box::new(move |cfg, _, cancel| {
                 let effective = settings.effective();
@@ -346,7 +346,7 @@ impl Host {
 
         let (db, http_history, agents) = self.project_services(&root, &project_key);
         let notebooks = crate::notebook::NotebookService::new(
-            self.data_dir.join("notebook-runtime").join(uuid::Uuid::new_v4().to_string()),
+            self.local_data_dir.join("notebook-runtime").join(uuid::Uuid::new_v4().to_string()),
             sink.clone(),
         );
         ide_agent::registry::maintain(crate::ops::agent::registry_paths(self));
@@ -365,7 +365,7 @@ impl Host {
             structure: Arc::new(StructureService::new(syntax.clone())),
             syntax,
             detected_roots,
-            cache_dir: self.data_dir.join("cache").join(&project_key),
+            cache_dir: self.local_data_dir.join("cache").join(&project_key),
             db,
             http_history,
             agents,
@@ -463,7 +463,7 @@ impl Host {
         let project_key = project_key(&dir);
         let (db, http_history, agents) = self.project_services(&dir, &project_key);
         let notebooks = crate::notebook::NotebookService::new(
-            self.data_dir.join("notebook-runtime").join(uuid::Uuid::new_v4().to_string()),
+            self.local_data_dir.join("notebook-runtime").join(uuid::Uuid::new_v4().to_string()),
             sink.clone(),
         );
         let project = Arc::new(Project {
@@ -480,7 +480,7 @@ impl Host {
             structure: Arc::new(StructureService::new(syntax.clone())),
             syntax,
             detected_roots: Arc::default(),
-            cache_dir: self.data_dir.join("cache").join(&project_key),
+            cache_dir: self.local_data_dir.join("cache").join(&project_key),
             db,
             http_history,
             agents,
diff --git a/crates/ide-host/tests/data_dirs.rs b/crates/ide-host/tests/data_dirs.rs
new file mode 100644
index 000000000..557a2b7dd
--- /dev/null
+++ b/crates/ide-host/tests/data_dirs.rs
@@ -0,0 +1,39 @@
+use ide_core::NullSink;
+use ide_host::{Host, HostConfig, ops};
+use std::sync::Arc;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn split_storage_keeps_user_history_and_uses_local_tools_and_caches() {
+    let tmp = tempfile::tempdir().unwrap();
+    let base = dunce::canonicalize(tmp.path()).unwrap();
+    let data = base.join("roaming");
+    let local = base.join("local");
+    let root = base.join("project");
+    std::fs::create_dir(&root).unwrap();
+    std::fs::write(root.join("notes.txt"), "hello\n").unwrap();
+    let host = Host::new(HostConfig {
+        config_dir: base.join("config"),
+        data_dir: data.clone(),
+        local_data_dir: local.clone(),
+        languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
+        syntax: Arc::default(),
+        sink_for: Box::new(|_| Arc::new(NullSink)),
+        owner: |w| w,
+        runtime: tokio::runtime::Handle::current(),
+        project_environment: false,
+    });
+    assert_eq!(
+        std::path::PathBuf::from(ops::tools::jdk_download_location(&host, "main").unwrap()),
+        local.join("tools/jdks")
+    );
+    let light = host.open_light("main", &root.join("notes.txt")).unwrap();
+    assert!(light.cache_dir.starts_with(&local));
+    assert!(data.join("history").exists());
+    assert!(!local.join("history").exists());
+    let project = host.open_project("main", &root).unwrap();
+    assert!(project.cache_dir.starts_with(&local));
+    assert!(local.join("index").exists());
+    assert!(!data.join("index").exists());
+    assert!(!data.join("tools").exists());
+    host.shutdown().await;
+}
diff --git a/crates/ide-host/tests/light_edit.rs b/crates/ide-host/tests/light_edit.rs
index d3732431b..1eff9e388 100644
--- a/crates/ide-host/tests/light_edit.rs
+++ b/crates/ide-host/tests/light_edit.rs
@@ -9,6 +9,7 @@ fn host(base: &std::path::Path) -> Arc<Host> {
     Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/properties.rs b/crates/ide-host/tests/properties.rs
index 097d92a63..d43323984 100644
--- a/crates/ide-host/tests/properties.rs
+++ b/crates/ide-host/tests/properties.rs
@@ -20,6 +20,7 @@ fn host(base: &Path) -> Host {
     Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/proxy.rs b/crates/ide-host/tests/proxy.rs
index cef7910dd..cf74d5dd5 100644
--- a/crates/ide-host/tests/proxy.rs
+++ b/crates/ide-host/tests/proxy.rs
@@ -10,6 +10,7 @@ fn host(base: &std::path::Path) -> Arc<Host> {
     Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/remote_env.rs b/crates/ide-host/tests/remote_env.rs
index 5f1fbf7cd..121f3beda 100644
--- a/crates/ide-host/tests/remote_env.rs
+++ b/crates/ide-host/tests/remote_env.rs
@@ -79,6 +79,7 @@ fn server_environment_from_login_shell_and_devcontainer() {
     let host = Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(move |_| sink_events.clone() as SharedSink),
diff --git a/crates/ide-host/tests/rpc.rs b/crates/ide-host/tests/rpc.rs
index d16f408fc..1b7d63e44 100644
--- a/crates/ide-host/tests/rpc.rs
+++ b/crates/ide-host/tests/rpc.rs
@@ -56,6 +56,7 @@ async fn serves_projects_files_documents_search_and_runs() {
     let host = Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(move |w| rpc::event_sink(sink_peer.clone(), Some(w.to_owned()))),
@@ -228,6 +229,7 @@ async fn local_deployment_runs_on_the_project_host() {
     let host = Arc::new(Host::new(HostConfig {
         config_dir: tmp.path().join("config"),
         data_dir: tmp.path().join("data"),
+        local_data_dir: tmp.path().join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(move |w| rpc::event_sink(sink_slot.clone(), Some(w.to_owned()))),
@@ -295,6 +297,7 @@ async fn properties_conversion_through_remote_dispatch_without_a_remote_host() {
     let host = Arc::new(Host::new(HostConfig {
         config_dir: tmp.path().join("config"),
         data_dir: tmp.path().join("data"),
+        local_data_dir: tmp.path().join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
diff --git a/crates/ide-host/tests/run_configs.rs b/crates/ide-host/tests/run_configs.rs
index 339121f78..9313c7569 100644
--- a/crates/ide-host/tests/run_configs.rs
+++ b/crates/ide-host/tests/run_configs.rs
@@ -6,6 +6,7 @@ fn host(base: &std::path::Path) -> Arc<Host> {
     Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/terminal_activation.rs b/crates/ide-host/tests/terminal_activation.rs
index 9561a23eb..3678ffdbf 100644
--- a/crates/ide-host/tests/terminal_activation.rs
+++ b/crates/ide-host/tests/terminal_activation.rs
@@ -24,6 +24,7 @@ fn terminal_activation_uses_the_resolved_default_shell() {
         let host = Arc::new(Host::new(HostConfig {
             config_dir: tmp.path().join("config"),
             data_dir: tmp.path().join("data"),
+            local_data_dir: tmp.path().join("data"),
             languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
             syntax: Arc::default(),
             sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/trust.rs b/crates/ide-host/tests/trust.rs
index bf6a0a057..256505e7c 100644
--- a/crates/ide-host/tests/trust.rs
+++ b/crates/ide-host/tests/trust.rs
@@ -11,6 +11,7 @@ fn host(base: &Path, environment: bool) -> Arc<Host> {
     Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/trust_git_binary.rs b/crates/ide-host/tests/trust_git_binary.rs
index 0002b46b7..d4f278209 100644
--- a/crates/ide-host/tests/trust_git_binary.rs
+++ b/crates/ide-host/tests/trust_git_binary.rs
@@ -12,6 +12,7 @@ async fn restricted_status_does_not_select_the_project_git_for_other_windows() {
     let host = Arc::new(Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/vcs_encoding.rs b/crates/ide-host/tests/vcs_encoding.rs
index 71b8e6a4d..7da472b8c 100644
--- a/crates/ide-host/tests/vcs_encoding.rs
+++ b/crates/ide-host/tests/vcs_encoding.rs
@@ -28,6 +28,7 @@ async fn gbk_document_gutter_diff_stage_and_rollback_share_encoding() {
     let host = Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/vcs_roots.rs b/crates/ide-host/tests/vcs_roots.rs
index d0431a1a2..b833e8ed5 100644
--- a/crates/ide-host/tests/vcs_roots.rs
+++ b/crates/ide-host/tests/vcs_roots.rs
@@ -31,6 +31,7 @@ async fn patches_read_and_write_the_requested_repository() {
     let host = Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-host/tests/workspaces.rs b/crates/ide-host/tests/workspaces.rs
index 86a8d9cd2..cfa225427 100644
--- a/crates/ide-host/tests/workspaces.rs
+++ b/crates/ide-host/tests/workspaces.rs
@@ -22,6 +22,7 @@ async fn linked_projects_share_navigation_but_keep_files_repositories_and_run_di
     let host = Host::new(HostConfig {
         config_dir: base.join("config"),
         data_dir: base.join("data"),
+        local_data_dir: base.join("data"),
         languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
         syntax: Arc::default(),
         sink_for: Box::new(|_| Arc::new(NullSink)),
diff --git a/crates/ide-workspace/src/caches.rs b/crates/ide-workspace/src/caches.rs
index 65dc16031..b1ff5ca91 100644
--- a/crates/ide-workspace/src/caches.rs
+++ b/crates/ide-workspace/src/caches.rs
@@ -23,16 +23,26 @@ pub struct InvalidateCachesOptions {
 const MARKER: &str = "invalidate-caches.json";
 
 /// Data-directory folders removed for `options`.
-pub fn cache_dirs(data_dir: &Path, options: &InvalidateCachesOptions) -> Vec<PathBuf> {
-    let mut dirs = vec![data_dir.join("index")];
+pub fn cache_dirs(data_dir: &Path, local_data_dir: &Path, options: &InvalidateCachesOptions) -> Vec<PathBuf> {
+    let mut dirs = vec![local_data_dir.join("index")];
     if options.local_history {
         dirs.push(data_dir.join("history"));
     }
     if options.language_servers {
-        dirs.push(data_dir.join("lsp"));
+        dirs.push(local_data_dir.join("lsp"));
     }
     if options.build_caches {
-        dirs.push(data_dir.join("cache"));
+        dirs.push(local_data_dir.join("cache"));
+    }
+    // Also invalidate pre-migration caches so a later start cannot revive them.
+    if data_dir != local_data_dir {
+        dirs.push(data_dir.join("index"));
+        if options.language_servers {
+            dirs.push(data_dir.join("lsp"));
+        }
+        if options.build_caches {
+            dirs.push(data_dir.join("cache"));
+        }
     }
     dirs
 }
@@ -57,11 +67,11 @@ pub fn cancel(data_dir: &Path) {
 
 /// Carries out a scheduled invalidation (call at start-up, before projects
 /// open). Returns the folders removed.
-pub fn apply_pending(data_dir: &Path) -> Vec<PathBuf> {
+pub fn apply_pending(data_dir: &Path, local_data_dir: &Path) -> Vec<PathBuf> {
     let Some(options) = pending(data_dir) else { return Vec::new() };
     cancel(data_dir);
     let mut removed = Vec::new();
-    for dir in cache_dirs(data_dir, &options) {
+    for dir in cache_dirs(data_dir, local_data_dir, &options) {
         match fs::remove_dir_all(&dir) {
             Ok(()) => removed.push(dir),
             Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
@@ -75,6 +85,34 @@ pub fn apply_pending(data_dir: &Path) -> Vec<PathBuf> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn split_roots_invalidate_local_caches_and_roaming_history() {
+        let tmp = tempfile::tempdir().unwrap();
+        let data = tmp.path().join("roaming");
+        let local = tmp.path().join("local");
+        let options = InvalidateCachesOptions { local_history: true, language_servers: true, build_caches: true };
+        assert_eq!(
+            cache_dirs(&data, &local, &options),
+            vec![
+                local.join("index"),
+                data.join("history"),
+                local.join("lsp"),
+                local.join("cache"),
+                data.join("index"),
+                data.join("lsp"),
+                data.join("cache")
+            ]
+        );
+        for path in cache_dirs(&data, &local, &options) {
+            fs::create_dir_all(path).unwrap();
+        }
+        fs::create_dir_all(local.join("tools")).unwrap();
+        schedule(&data, &options).unwrap();
+        assert_eq!(apply_pending(&data, &local).len(), 7);
+        assert!(local.join("tools").exists());
+        assert_eq!(pending(&data), None);
+    }
+
     #[test]
     fn scheduled_invalidation_runs_once() {
         let tmp = tempfile::tempdir().unwrap();
@@ -82,16 +120,16 @@ mod tests {
         for d in ["index/p1", "history/p1", "lsp/jdtls/x", "cache/p1/build", "tools/jdk"] {
             fs::create_dir_all(data.join(d)).unwrap();
         }
-        assert!(apply_pending(data).is_empty());
+        assert!(apply_pending(data, data).is_empty());
 
         let opts = InvalidateCachesOptions { local_history: true, language_servers: false, build_caches: true };
         schedule(data, &opts).unwrap();
         assert_eq!(pending(data), Some(opts));
-        let removed = apply_pending(data);
+        let removed = apply_pending(data, data);
         assert_eq!(removed, vec![data.join("index"), data.join("history"), data.join("cache")]);
         assert!(data.join("lsp/jdtls/x").exists() && data.join("tools/jdk").exists());
         assert_eq!(pending(data), None);
-        assert!(apply_pending(data).is_empty());
+        assert!(apply_pending(data, data).is_empty());
 
         schedule(data, &InvalidateCachesOptions::default()).unwrap();
         cancel(data);
diff --git a/perf/compare/apps.toml b/perf/compare/apps.toml
index 30c01d252..5ebb48b3f 100644
--- a/perf/compare/apps.toml
+++ b/perf/compare/apps.toml
@@ -22,7 +22,7 @@ install_dir = { windows = "%LOCALAPPDATA%/OpenIDEA", macos = "/Applications/Open
 logs = { windows = "%LOCALAPPDATA%/ai.l0ng.openidea/logs/openidea*.log", macos = "~/Library/Logs/ai.l0ng.openidea/openidea*.log", linux = "~/.local/share/ai.l0ng.openidea/logs/openidea*.log" }
 # The index and build caches. jdtls keeps its own workspace under lsp/jdtls,
 # next to the jdtls install, so a cold Java run still reuses jdtls's build state.
-cache_dirs = { windows = ["%APPDATA%/ai.l0ng.openidea/index", "%APPDATA%/ai.l0ng.openidea/cache"], macos = ["~/Library/Application Support/ai.l0ng.openidea/index", "~/Library/Application Support/ai.l0ng.openidea/cache"], linux = ["~/.local/share/ai.l0ng.openidea/index", "~/.local/share/ai.l0ng.openidea/cache"] }
+cache_dirs = { windows = ["%LOCALAPPDATA%/ai.l0ng.openidea/index", "%LOCALAPPDATA%/ai.l0ng.openidea/cache"], macos = ["~/Library/Application Support/ai.l0ng.openidea/index", "~/Library/Application Support/ai.l0ng.openidea/cache"], linux = ["~/.local/share/ai.l0ng.openidea/index", "~/.local/share/ai.l0ng.openidea/cache"] }
 
 [apps.openidea.markers]
 project_opened = 'opened .* in window'
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 4cfeb1ff0..439fed64b 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -51,7 +51,7 @@ pub fn run() {
 
     let refresh_shell_path = ide_host::shell_env::inherit_login_shell_path(&context.config().identifier);
     // Managed LSP/DAP installs; must run before other threads start and before PATH is cached.
-    if let Some(data) = dirs::data_dir() {
+    if let Some(data) = dirs::data_local_dir() {
         ide_tools::extend_process_path(&data.join(&context.config().identifier));
         ide_dap::adapter::set_tools_root(ide_tools::tools_dir(&data.join(&context.config().identifier)));
         ide_sdk::java::add_jdk_root(&ide_tools::jdk::jdks_dir(&data.join(&context.config().identifier)));
diff --git a/src-tauri/src/remote_dev.rs b/src-tauri/src/remote_dev.rs
index 5bcf0cb58..e45f7eef7 100644
--- a/src-tauri/src/remote_dev.rs
+++ b/src-tauri/src/remote_dev.rs
@@ -182,7 +182,7 @@ fn local_server_binary(state: &AppState, os: &str, arch: &str) -> Option<std::pa
     if let Some(p) = std::env::var_os("OPENIDEA_SERVER_BINARY").map(std::path::PathBuf::from).filter(|p| p.is_file()) {
         return Some(p);
     }
-    let bundled = state.data_dir.join("server").join(format!("{os}-{arch}")).join("openidea-server");
+    let bundled = state.local_data_dir.join("server").join(format!("{os}-{arch}")).join("openidea-server");
     if bundled.is_file() {
         return Some(bundled);
     }
@@ -205,7 +205,7 @@ async fn download_server(
     arch: &str,
     progress: Arc<Progress>,
 ) -> IdeResult<std::path::PathBuf> {
-    let (data, version, os, arch) = (state.data_dir.clone(), version.to_owned(), os.to_owned(), arch.to_owned());
+    let (data, version, os, arch) = (state.local_data_dir.clone(), version.to_owned(), os.to_owned(), arch.to_owned());
     tokio::task::spawn_blocking(move || {
         ide_tools::server::fetch(&data, &version, &os, &arch, &ide_core::CancellationToken::new(), &|e| match e {
             ide_tools::InstallEvent::Line { text } => tracing::info!("openidea-server download: {text}"),
@@ -259,7 +259,12 @@ async fn ensure_server(state: &AppState, session: &ide_ssh::Session, progress: A
                          `cargo build --release -p ide-host --bin openidea-server` for that platform and put it at {} \
                          (or set OPENIDEA_SERVER_BINARY)",
                         e.message,
-                        state.data_dir.join("server").join(format!("{os}-{arch}")).join("openidea-server").display()
+                        state
+                            .local_data_dir
+                            .join("server")
+                            .join(format!("{os}-{arch}"))
+                            .join("openidea-server")
+                            .display()
                     ))
                 });
             }
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index 674135699..e3ad4ea39 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -64,21 +64,28 @@ impl AppState {
         }
         let config_dir = app.path().app_config_dir()?;
         let data_dir = app.path().app_data_dir()?;
+        let local_data_dir = app.path().app_local_data_dir()?;
         std::fs::create_dir_all(&config_dir)?;
         std::fs::create_dir_all(&data_dir)?;
+        if let Err(error) = std::fs::create_dir_all(&local_data_dir) {
+            tracing::warn!(?local_data_dir, %error, "cannot create local data directory");
+        }
+        tracing::info!(?data_dir, ?local_data_dir, "application data directories");
         // Saved git HTTPS credentials (askpass answers them silently).
         ide_ssh::git_creds::init(data_dir.join("git-credentials.json"));
         // File › Invalidate Caches… requested at the last run.
-        let removed = ide_workspace::caches::apply_pending(&data_dir);
+        let removed = ide_workspace::caches::apply_pending(&data_dir, &local_data_dir);
         if !removed.is_empty() {
             tracing::info!("invalidated caches: {removed:?}");
         }
+        ide_host::data_dirs::migrate(&data_dir, &local_data_dir);
         let global_sink: SharedSink = Arc::new(TauriSink { app: app.clone(), window: None });
         let languages = Arc::new(LanguageRegistry::load(Some(&config_dir.join("languages")))?);
         let sink_app = app.clone();
         let host = Arc::new(Host::new(ide_host::HostConfig {
             config_dir: config_dir.clone(),
             data_dir: data_dir.clone(),
+            local_data_dir,
             languages: languages.clone(),
             syntax,
             sink_for: Box::new(move |window| {