fix(vcs): show feedback for explicit Git commands

Only compose.yml / docker-compose.yml were recognised as Compose files, so custom-named or content-only Compose YAML had no Docker icon, no gutter run markers and no Compose support, and running a docker-compose configuration from the gutter added a duplicate top-level Docker Compose group in Services. Compose files are now detected by filename (*compose*.yml/yaml) and by a bounded content scan that excludes Kubernetes, OpenAPI, GitHub Actions, Helm values and mkdocs files; content-detected files show a banner to confirm or reject, and the choice is stored in project settings and follows IDE renames. Detected files get the Docker icon in the tree and tabs, run markers on services: (whole stack) and on each service, and docker runs stay under the Docker node in Services.

Co-authored-by: dengliu <[email protected]>

Cargo.lock

@@ -4261,6 +4261,7 @@ dependencies = [
 name = "ide-clipboard"
 version = "0.1.40"
 dependencies = [
+ "gtk",
  "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",

README.md

@@ -76,4 +76,6 @@ the [official plugins](plugins/official). The plugin API is still a preview.
 
 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
 
+
+
 <sub>Not affiliated with JetBrains. IntelliJ IDEA is a trademark of JetBrains s.r.o.</sub>

crates/ide-agent/src/tests.rs

@@ -366,6 +366,35 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentMan
     )
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn saved_conversation_reads_do_not_start_or_load_the_agent() {
+    let tmp = tempfile::tempdir().unwrap();
+    let agent = Arc::new(FakeAgent::default());
+    let mgr = manager(tmp.path(), agent.clone());
+    let task = mgr
+        .create(NewAgentTask {
+            project_root: None,
+            prompt: text("Review the saved conversation"),
+            provider: "claude".into(),
+            config: Vec::new(),
+            isolation: Isolation::Local,
+            base: None,
+        })
+        .await
+        .unwrap();
+    wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
+    mgr.shutdown();
+    let restored_agent = Arc::new(FakeAgent::default());
+    let restored = manager(tmp.path(), restored_agent.clone());
+    assert!(!restored.entries(&task.id, None).unwrap().is_empty());
+    assert!(restored_agent.calls.lock().is_empty());
+    assert!(restored.entries("missing-task", None).is_err());
+    assert!(restored.entries(&task.id, Some("missing-subagent".into())).is_err());
+    restored.task(&task.id).unwrap().state.lock().conversation = Conversation::default();
+    assert!(restored.entries(&task.id, None).unwrap().is_empty());
+    restored.shutdown();
+}
+
 #[cfg(unix)]
 #[tokio::test(flavor = "multi_thread")]
 async fn claude_commands_before_session_are_fetched_once_and_saved() {

crates/ide-build/src/maven.rs

@@ -16,6 +16,8 @@ use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};
 
+pub mod sources;
+
 /// Phases shown under "Lifecycle" (IDEA's default list).
 pub const LIFECYCLE: &[&str] =
     &["clean", "validate", "compile", "test", "package", "verify", "install", "site", "deploy"];

crates/ide-build/src/maven/sources.rs

@@ -0,0 +1,124 @@
+//! On-demand sources resolution using the project's Maven launcher and repositories.
+
+use super::MavenProject;
+use crate::process;
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use std::path::{Component, Path, PathBuf};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Artifact {
+    pub group: String,
+    pub name: String,
+    pub version: String,
+    pub sources: PathBuf,
+}
+
+/// Resolve only jars inside the selected local repository, including custom repositories.
+pub fn artifact(jar: &Path, repository: &Path) -> Option<Artifact> {
+    let relative = jar.strip_prefix(repository).ok()?;
+    let parts: Vec<&str> = relative
+        .components()
+        .map(|c| match c {
+            Component::Normal(s) => s.to_str(),
+            _ => None,
+        })
+        .collect::<Option<_>>()?;
+    if parts.len() < 4 {
+        return None;
+    }
+    let n = parts.len();
+    let (name, version, file) = (parts[n - 3], parts[n - 2], parts[n - 1]);
+    let valid = |s: &str| {
+        !s.is_empty() && s != "." && s != ".." && s.chars().all(|c| c.is_ascii_alphanumeric() || "_.-".contains(c))
+    };
+    if !parts[..n - 1].iter().all(|s| valid(s)) || file != format!("{name}-{version}.jar") {
+        return None;
+    }
+    Some(Artifact {
+        group: parts[..n - 3].join("."),
+        name: name.into(),
+        version: version.into(),
+        sources: jar.with_file_name(format!("{name}-{version}-sources.jar")),
+    })
+}
+
+pub fn download(
+    root: &Path,
+    project: &MavenProject,
+    artifact: &Artifact,
+    repository: &Path,
+    cancel: &CancellationToken,
+) -> IdeResult<Option<PathBuf>> {
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    if artifact.sources.is_file() {
+        return Ok(Some(artifact.sources.clone()));
+    }
+    let mut args = vec!["-B".into(), "-N".into(), "-Dstyle.color=never".into()];
+    args.extend(project.options.clone());
+    args.extend([
+        format!("-Dmaven.repo.local={}", repository.display()),
+        "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:get".into(),
+        format!("-Dartifact={}:{}:{}:jar:sources", artifact.group, artifact.name, artifact.version),
+        "-Dtransitive=false".into(),
+    ]);
+    let output = process::run(&project.command, &args, &root.join(&project.dir), &project.env, cancel, |_, _| {})?;
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
+    if artifact.sources.is_file() {
+        return Ok(Some(artifact.sources.clone()));
+    }
+    let coordinate = format!("{}:{}:jar:sources:{}", artifact.group, artifact.name, artifact.version);
+    if output.success
+        || output.text.lines().any(|line| {
+            line.contains(&coordinate) && (line.contains("Could not find artifact") || line.contains("was not found"))
+        })
+    {
+        return Ok(None);
+    }
+    Err(IdeError::unavailable(
+        output.text.lines().rev().take(20).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>().join("\n"),
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolves_sources_coordinates_from_maven_layouts() {
+        for repository in ["/home/me/.m2/repository", "/tmp/project repo", "C:/Users/me/.m2/repository"] {
+            for (group, name, version) in [
+                ("org/apache/commons", "commons-lang3", "3.17.0"),
+                ("com/example", "example-lib", "1.0-SNAPSHOT"),
+                ("single", "lib", "1.0.0-rc.1"),
+            ] {
+                let repository = Path::new(repository);
+                let dir = repository.join(group).join(name).join(version);
+                let found = artifact(&dir.join(format!("{name}-{version}.jar")), repository).unwrap();
+                assert_eq!(found.group, group.replace('/', "."));
+                assert_eq!(found.name, name);
+                assert_eq!(found.version, version);
+                assert_eq!(found.sources, dir.join(format!("{name}-{version}-sources.jar")));
+            }
+        }
+    }
+
+    #[test]
+    fn rejects_non_artifacts_and_paths_outside_the_repository() {
+        let repository = Path::new("/m2/repository");
+        for path in [
+            "/m2/repository-other/g/a/1/a-1.jar",
+            "/m2/repository/g/a/1/a-1-sources.jar",
+            "/m2/repository/g/a/1/other.jar",
+            "/m2/repository/g/a/../a-1.jar",
+            "/m2/repository/g/a/1/a-1.pom",
+            "/m2/repository/g/a-1.jar",
+            "/gradle/caches/modules-2/files-2.1/g/a/1/hash/a-1.jar",
+        ] {
+            assert_eq!(artifact(Path::new(path), repository), None, "{path}");
+        }
+    }
+}

crates/ide-clipboard/Cargo.toml

@@ -11,3 +11,6 @@ license.workspace = true
 objc2 = { version = "0.6", default-features = false, features = ["std"] }
 objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSDictionary", "NSEnumerator", "NSObject", "NSString", "NSURL", "NSValue"] }
 objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSPasteboard"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+gtk = "0.18"

crates/ide-clipboard/src/lib.rs

@@ -21,6 +21,12 @@
 
 use std::path::PathBuf;
 
+/// Replaces every clipboard flavor with plain text. `owner` is the calling window
+/// handle on Windows, ignored elsewhere. Call on the main thread on macOS and Linux.
+pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
+    imp::set_text(text, owner)
+}
+
 /// Size of `DROPFILES`: `pFiles`, `pt` (two `LONG`s), `fNC`, `fWide`.
 const HEADER: usize = 20;
 
@@ -165,8 +171,12 @@ mod imp {
     /// Opens the clipboard as its owner: the list is written in full, so no
     /// owning window is needed.
     fn open() -> bool {
+        open_for(ptr::null_mut())
+    }
+
+    fn open_for(owner: Handle) -> bool {
         for _ in 0..OPEN_ATTEMPTS {
-            if unsafe { OpenClipboard(ptr::null_mut()) } != 0 {
+            if unsafe { OpenClipboard(owner) } != 0 {
                 return true;
             }
             std::thread::sleep(OPEN_RETRY);
@@ -230,6 +240,29 @@ mod imp {
         }
     }
 
+    pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
+        let (memory, _) = global_text(text);
+        if memory.is_null() {
+            return Err(std::io::Error::last_os_error());
+        }
+        // SAFETY: ownership transfers only on success; otherwise we free the allocation.
+        unsafe {
+            if !open_for(owner as Handle) {
+                GlobalFree(memory);
+                return Err(std::io::Error::last_os_error());
+            }
+            let taken = EmptyClipboard() != 0 && !SetClipboardData(CF_UNICODETEXT, memory).is_null();
+            let error = std::io::Error::last_os_error();
+            CloseClipboard();
+            if taken {
+                Ok(())
+            } else {
+                GlobalFree(memory);
+                Err(error)
+            }
+        }
+    }
+
     pub fn set_files(paths: &[PathBuf]) -> bool {
         let bytes = encode(paths);
         if bytes.len() <= HEADER {
@@ -340,6 +373,19 @@ mod imp {
         })
     }
 
+    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
+        debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
+        autoreleasepool(|_| {
+            let board = NSPasteboard::generalPasteboard();
+            board.clearContents();
+            if board.setString_forType(&NSString::from_str(text), unsafe { NSPasteboardTypeString }) {
+                Ok(())
+            } else {
+                Err(std::io::Error::other("Cannot write clipboard text"))
+            }
+        })
+    }
+
     pub fn set_files(paths: &[PathBuf]) -> bool {
         debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
         autoreleasepool(|_| {
@@ -370,6 +416,19 @@ mod imp {
 mod imp {
     use std::path::PathBuf;
 
+    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
+        #[cfg(target_os = "linux")]
+        {
+            gtk::Clipboard::get(&gtk::gdk::SELECTION_CLIPBOARD).set_text(text);
+            Ok(())
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            let _ = text;
+            Err(std::io::Error::other("Clipboard text is unavailable on this platform"))
+        }
+    }
+
     pub fn has_files() -> bool {
         false
     }

crates/ide-core/Cargo.toml

@@ -23,4 +23,4 @@ tempfile.workspace = true
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Globalization", "Win32_Security", "Win32_System_Diagnostics_ToolHelp", "Win32_System_IO", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Globalization", "Win32_Security", "Win32_System_Diagnostics_ToolHelp", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_Threading"] }

crates/ide-core/src/event.rs

@@ -42,6 +42,10 @@ pub enum IdeEvent {
         created: Vec<crate::IpcPath>,
         modified: Vec<crate::IpcPath>,
         removed: Vec<crate::IpcPath>,
+        /// Subtrees whose ignore rules changed, after the matchers were rebuilt.
+        #[serde(default)]
+        #[specta(optional)]
+        ignore_rules: Vec<crate::IpcPath>,
     },
     /// Excluded or ignored folders whose contents changed; they stay out of `FsChanged`.
     ExcludedDirsChanged {

crates/ide-core/src/process.rs

@@ -104,6 +104,8 @@ fn signal_group(child: &Child, signal: libc::c_int) {
 #[cfg(windows)]
 const TREE_EXIT_WAIT: Duration = Duration::from_secs(5);
 
+#[cfg(windows)]
+pub use windows_job::Job;
 #[cfg(windows)]
 pub use windows_tree::ProcessTree;
 
@@ -251,6 +253,167 @@ mod windows_tree {
     }
 }
 
+/// A kernel job object over one launched process tree. Everything a launch starts joins
+/// the job by inheritance, so [`Job::terminate`] ends the whole tree — also processes
+/// started after the launch's snapshot was taken, orphans of a launcher that already
+/// exited (where a `taskkill /T /F` from the tracked pid no longer finds them), and
+/// processes born in the window a process-enumeration kill would miss. Spawns assign
+/// their root right after it starts; when the assignment fails (an enclosing job that
+/// disallows nesting, an already-exited pid), callers fall back to `taskkill /T /F`.
+#[cfg(windows)]
+mod windows_job {
+    use std::mem::size_of;
+    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
+    use windows_sys::Win32::Foundation::{ERROR_MORE_DATA, INVALID_HANDLE_VALUE};
+    use windows_sys::Win32::System::JobObjects::{
+        AssignProcessToJobObject, CreateJobObjectW, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
+        JOBOBJECT_BASIC_LIMIT_INFORMATION, JOBOBJECT_BASIC_PROCESS_ID_LIST, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
+        JobObjectBasicProcessIdList, JobObjectExtendedLimitInformation, QueryInformationJobObject,
+        SetInformationJobObject, TerminateJobObject,
+    };
+    use windows_sys::Win32::System::Threading::{IO_COUNTERS, OpenProcess, PROCESS_SET_QUOTA, PROCESS_TERMINATE};
+
+    /// A job object holding one launch's processes. The handle is kept open for the
+    /// launch's lifetime: `KILL_ON_JOB_CLOSE` ends anything still in the job when the
+    /// launch record (a run entry, a debug session) is finally dropped.
+    pub struct Job(OwnedHandle);
+
+    impl Job {
+        /// Takes the just-started `child` into a new job, so everything it starts is in
+        /// there too. `None` when the job could not be made or the process rejected the
+        /// assignment (callers fall back to `taskkill /T /F` from the child's pid).
+        pub fn for_child(child: &std::process::Child) -> Option<Job> {
+            // SAFETY: the child's own handle is a live process handle.
+            Self::from_handle(child.as_raw_handle())
+        }
+
+        /// [`Job::for_child`] for a process known by its id (a PTY child, a follow-up run,
+        /// a `tokio` child). `None` when the id no longer names an openable process — a
+        /// caller that holds the child cannot have had it reaped, so this is a dead or
+        /// already-gone launch.
+        pub fn for_pid(pid: u32) -> Option<Job> {
+            // SAFETY: plain call; a non-null result is a process handle owned by the caller.
+            // Assignment needs `SET_QUOTA | TERMINATE` on the process.
+            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
+            if handle.is_null() {
+                return None;
+            }
+            // SAFETY: the handle was just opened and is owned here.
+            let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
+            Self::from_handle(handle.as_raw_handle())
+        }
+
+        fn from_handle(handle: RawHandle) -> Option<Job> {
+            // SAFETY: plain calls; a non-null result is a job handle owned by the caller.
+            let job = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) };
+            if job.is_null() || job == INVALID_HANDLE_VALUE {
+                return None;
+            }
+            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
+            let job = unsafe { OwnedHandle::from_raw_handle(job) };
+            let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+                BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION {
+                    PerProcessUserTimeLimit: 0,
+                    PerJobUserTimeLimit: 0,
+                    LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
+                    MinimumWorkingSetSize: 0,
+                    MaximumWorkingSetSize: 0,
+                    ActiveProcessLimit: 0,
+                    Affinity: 0,
+                    PriorityClass: 0,
+                    SchedulingClass: 0,
+                },
+                IoInfo: IO_COUNTERS {
+                    ReadOperationCount: 0,
+                    WriteOperationCount: 0,
+                    OtherOperationCount: 0,
+                    ReadTransferCount: 0,
+                    WriteTransferCount: 0,
+                    OtherTransferCount: 0,
+                },
+                ProcessMemoryLimit: 0,
+                JobMemoryLimit: 0,
+                PeakProcessMemoryUsed: 0,
+                PeakJobMemoryUsed: 0,
+            };
+            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
+            let ok = unsafe {
+                SetInformationJobObject(
+                    job.as_raw_handle(),
+                    JobObjectExtendedLimitInformation,
+                    &mut limits as *mut _ as *const _,
+                    size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
+                )
+            };
+            if ok == 0 {
+                return None;
+            }
+            // SAFETY: the process handle belongs to the just-spawned child and outlives
+            // this call; the job handle is owned here.
+            let ok = unsafe { AssignProcessToJobObject(job.as_raw_handle(), handle) };
+            if ok == 0 {
+                return None;
+            }
+            Some(Job(job))
+        }
+
+        /// Adds another just-started root of the same launch to the job (a Go build's
+        /// follow-up run, a JVM a debug session starts itself). `false` when it did not
+        /// take; the process then relies on its own kill.
+        pub fn assign_pid(&self, pid: u32) -> bool {
+            // SAFETY: plain call; the handle is opened only to assign it, and the job
+            // handle is owned and valid.
+            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
+            if handle.is_null() {
+                return false;
+            }
+            // SAFETY: both handles are valid for the duration of the call.
+            let ok = unsafe { AssignProcessToJobObject(self.0.as_raw_handle(), handle) };
+            // SAFETY: the process handle was opened above and is owned here.
+            unsafe { drop(OwnedHandle::from_raw_handle(handle)) };
+            ok != 0
+        }
+
+        /// Terminates every process in the job. `false` when the call failed (the job
+        /// handle is invalid): callers then fall back to `taskkill /T /F`. Termination is
+        /// asynchronous; poll [`Job::is_running`] (bounded by [`TREE_EXIT_WAIT`]) until
+        /// the tree is gone.
+        pub fn terminate(&self) -> bool {
+            // SAFETY: a job handle owned here.
+            unsafe { TerminateJobObject(self.0.as_raw_handle(), 1) != 0 }
+        }
+
+        /// Whether any process of the launch is still in the job. When the job's state
+        /// cannot be read, reports gone: waits on this must not wedge, and a kill via
+        /// [`Job::terminate`] does not depend on the answer.
+        pub fn is_running(&self) -> bool {
+            // A list of one is the common case; `ERROR_MORE_DATA` says the real list is
+            // longer, which means there are processes.
+            let mut list = JOBOBJECT_BASIC_PROCESS_ID_LIST {
+                NumberOfAssignedProcesses: 0,
+                NumberOfProcessIdsInList: 0,
+                ProcessIdList: [0],
+            };
+            let mut returned = 0u32;
+            // SAFETY: the job handle is owned here and `list` is sized as the API requires.
+            let ok = unsafe {
+                QueryInformationJobObject(
+                    self.0.as_raw_handle(),
+                    JobObjectBasicProcessIdList,
+                    &mut list as *mut _ as *mut _,
+                    size_of::<JOBOBJECT_BASIC_PROCESS_ID_LIST>() as u32,
+                    &mut returned,
+                )
+            };
+            if ok != 0 {
+                list.NumberOfProcessIdsInList > 0
+            } else {
+                std::io::Error::last_os_error().raw_os_error() == Some(ERROR_MORE_DATA as i32)
+            }
+        }
+    }
+}
+
 /// Gives `cmd` the host's environment back when the IDE runs from an AppImage. `AppRun` and
 /// its hooks point `LD_LIBRARY_PATH`, `PATH`, `XDG_DATA_DIRS`, `GIO_MODULE_DIR`, `GTK_PATH`,
 /// `GST_PLUGIN_*`, ... into the mounted image for the IDE itself; a host program that
@@ -956,3 +1119,66 @@ mod kill_tests {
         assert!(started.elapsed() < Duration::from_secs(5));
     }
 }
+
+#[cfg(all(test, windows))]
+mod job_tests {
+    use super::*;
+    use std::os::windows::process::CommandExt;
+    use std::process::Stdio;
+    use std::time::Instant;
+
+    /// `cmd` that keeps a `ping` grandchild for a minute, like a launcher that started an
+    /// application: the job must reach both.
+    fn launch_tree() -> (std::process::Child, Job, ProcessTree) {
+        let mut cmd = Command::new("cmd");
+        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
+        let child = cmd.spawn().unwrap();
+        let job = Job::for_child(&child).expect("the job takes the launch");
+        let tree = ProcessTree::capture(child.id());
+        assert!(tree.is_running(), "cmd started a grandchild the job inherits");
+        (child, job, tree)
+    }
+
+    /// Termination is asynchronous: the job reports its processes gone while their
+    /// handles still wait, so wait on the handles (the reused-pid-proof oracle).
+    fn assert_gone(tree: &ProcessTree) {
+        let until = Instant::now() + Duration::from_secs(10);
+        while tree.is_running() {
+            assert!(Instant::now() < until, "the tree survived the job");
+            std::thread::sleep(Duration::from_millis(20));
+        }
+    }
+
+    #[test]
+    fn job_terminates_the_tree_the_root_started() {
+        let (mut child, job, tree) = launch_tree();
+        assert!(job.is_running());
+        assert!(job.terminate(), "TerminateJobObject succeeds");
+        // The captured tree's handles survive the root's death, so the wait below is the
+        // grandchild's, not a reused pid's.
+        assert_gone(&tree);
+        assert!(!job.is_running());
+        let _ = child.wait();
+    }
+
+    #[test]
+    fn a_later_spawned_root_joins_the_job() {
+        let (mut first, job, _) = launch_tree();
+        let mut cmd = Command::new("cmd");
+        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
+        let mut second = cmd.spawn().unwrap();
+        let second_tree = ProcessTree::capture(second.id());
+        assert!(job.assign_pid(second.id()), "the follow-up run joins the job");
+        assert!(job.terminate());
+        assert_gone(&second_tree);
+        let _ = first.wait();
+        let _ = second.wait();
+    }
+
+    #[test]
+    fn a_dead_pid_makes_no_job() {
+        // An id of a process this test cannot open (or that does not exist) gives no job,
+        // which is the callers' cue for the `taskkill /T /F` fallback.
+        assert!(Job::for_pid(u32::MAX).is_none());
+    }
+}

crates/ide-core/src/remote_settings.rs

@@ -201,7 +201,18 @@ pub struct PluginRunTarget {
     pub args: Vec<String>,
     pub workdir_args: Vec<String>,
     pub container_root: Option<String>,
-    pub commands: Vec<(String, Vec<String>)>,
+    pub commands: Vec<PluginCommandOverride>,
+}
+
+/// Per-command argv prefix and optional replacement working-directory arguments.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct PluginCommandOverride {
+    pub name: String,
+    pub args: Vec<String>,
+    /// None inherits the target's list; Some([]) suppresses it.
+    #[serde(default)]
+    pub workdir_args: Option<Vec<String>>,
 }
 
 #[cfg(test)]

crates/ide-core/src/settings.rs

@@ -277,6 +277,10 @@ pub struct CustomKeymap {
 pub struct GeneralSettings {
     pub reopen_last_project: bool,
     pub confirm_exit: bool,
+    /// When on, the last window closes instead of showing the Welcome screen.
+    pub close_without_welcome: bool,
+    /// When on, closing a window drops its saved editor tabs, so they are not restored next time.
+    pub close_tabs_with_window: bool,
     /// Where Open… puts a project while one is open: `ask` | `new` | `same` | `attach`.
     pub open_project_in: String,
     /// Initial folder of the Open / Clone dialogs; empty = the OS default.
@@ -300,6 +304,8 @@ impl Default for GeneralSettings {
         Self {
             reopen_last_project: true,
             confirm_exit: true,
+            close_without_welcome: false,
+            close_tabs_with_window: false,
             open_project_in: "ask".into(),
             default_project_directory: String::new(),
             save_on_idle: false,
@@ -363,6 +369,21 @@ impl Default for NotificationGroupSettings {
     }
 }
 
+/// Where the Navigation Bar (the file path breadcrumbs) is shown. Mirrors
+/// IDEA's `View | Appearance | Navigation Bar` (Top / Status Bar / Don't show).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum NavigationBarPosition {
+    /// Above the editor, below the main menu / toolbar.
+    Top,
+    /// In the footer, next to the status bar widgets — the default, matching
+    /// where the bar lived before the three-state choice existed.
+    #[default]
+    StatusBar,
+    /// Not shown at all.
+    Hidden,
+}
+
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct AppearanceSettings {
@@ -411,6 +432,9 @@ pub struct AppearanceSettings {
     /// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
     pub show_main_toolbar: bool,
     pub show_status_bar: bool,
+    /// View › Appearance › Navigation Bar: the file path breadcrumbs, shown in
+    /// the status bar by default, above the editor, or not at all.
+    pub navigation_bar: NavigationBarPosition,
     /// Status bar widgets shown (`true`) or hidden (`false`) by the user
     /// (status bar context menu); widgets not listed use their default.
     pub status_bar_widgets: BTreeMap<String, bool>,
@@ -483,6 +507,7 @@ impl Default for AppearanceSettings {
             widescreen_tool_windows: false,
             show_main_toolbar: true,
             show_status_bar: true,
+            navigation_bar: NavigationBarPosition::StatusBar,
             status_bar_widgets: BTreeMap::new(),
             main_toolbar: None,
         }
@@ -520,6 +545,9 @@ pub struct EditorSettings {
     /// Color Scheme › Language Defaults › Semantic highlighting: local variables and
     /// parameters get a colour derived from their name (IDEA's rainbow identifiers).
     pub semantic_highlighting: bool,
+    /// Docstring markup format whose tags and keywords the Python editor highlights
+    /// (`plain`, `rest`, `epytext`, `google`, `numpy`).
+    pub docstring_format: String,
     /// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
     pub rainbow_brackets: bool,
     pub ligatures: bool,
@@ -564,6 +592,7 @@ impl Default for EditorSettings {
             color_overrides: BTreeMap::new(),
             custom_schemes: BTreeMap::new(),
             semantic_highlighting: false,
+            docstring_format: "rest".into(),
             rainbow_brackets: false,
             ligatures: false,
             fallback_font: String::new(),
@@ -608,6 +637,15 @@ pub struct FileSettings {
     pub file_types: BTreeMap<String, FileTypeAssociation>,
     /// Override File Type: file (project-relative and `/`-separated, or absolute) → language id.
     pub file_type_overrides: BTreeMap<String, String>,
+    /// Compose detection choices, keyed by project-relative file path.
+    pub compose_file_overrides: BTreeMap<String, ComposeFileOverride>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum ComposeFileOverride {
+    Kept,
+    Excluded,
 }
 
 /// One language's file name and hashbang patterns on top of its definition.
@@ -635,6 +673,7 @@ impl Default for FileSettings {
             local_history_max_mb: 512,
             file_types: BTreeMap::new(),
             file_type_overrides: BTreeMap::new(),
+            compose_file_overrides: BTreeMap::new(),
         }
     }
 }
@@ -656,6 +695,7 @@ pub struct LanguagesSettings {
     pub java: JavaSettings,
     pub ruby: RubySettings,
     pub markdown: MarkdownSettings,
+    pub arduino: ArduinoSettings,
 }
 
 impl Default for LanguagesSettings {
@@ -677,10 +717,22 @@ impl Default for LanguagesSettings {
             java: JavaSettings::default(),
             ruby: RubySettings::default(),
             markdown: MarkdownSettings::default(),
+            arduino: ArduinoSettings::default(),
         }
     }
 }
 
+/// Arduino tool discovery paths and default board FQBN, configured in `settings.toml`.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ArduinoSettings {
+    pub cli: String,
+    pub clangd: String,
+    pub language_server: String,
+    pub cli_config: String,
+    pub fqbn: String,
+}
+
 /// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
@@ -1183,6 +1235,26 @@ impl Settings {
 mod tests {
     use super::*;
 
+    #[test]
+    fn window_close_settings_default_off_and_round_trip() {
+        for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
+            let settings: Settings = serde_json::from_str(old).unwrap();
+            assert!(!settings.general.close_without_welcome);
+            assert!(!settings.general.close_tabs_with_window);
+        }
+        for close_window in [false, true] {
+            for close_tabs in [false, true] {
+                let mut settings = Settings::default();
+                settings.general.close_without_welcome = close_window;
+                settings.general.close_tabs_with_window = close_tabs;
+                let json = serde_json::to_value(&settings).unwrap();
+                assert_eq!(json["general"]["closeWithoutWelcome"], close_window);
+                assert_eq!(json["general"]["closeTabsWithWindow"], close_tabs);
+                assert_eq!(serde_json::from_value::<Settings>(json).unwrap().general, settings.general);
+            }
+        }
+    }
+
     #[test]
     fn cmake_profile_argument_arrays_round_trip() {
         let mut settings = Settings::default();
@@ -1245,6 +1317,21 @@ mod tests {
         }
     }
 
+    #[test]
+    fn docstring_format_defaults_and_round_trips() {
+        let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
+        assert_eq!(old.editor.docstring_format, "rest");
+        assert_eq!(Settings::default().editor.docstring_format, "rest");
+        for format in ["plain", "rest", "epytext", "google", "numpy"] {
+            let mut settings = Settings::default();
+            settings.editor.docstring_format = format.into();
+            let json = serde_json::to_value(&settings).unwrap();
+            assert_eq!(json["editor"]["docstringFormat"], format);
+            let restored: Settings = serde_json::from_value(json).unwrap();
+            assert_eq!(restored.editor.docstring_format, format);
+        }
+    }
+
     #[test]
     fn tool_window_badges_default_on_and_round_trip() {
         let old: Settings = serde_json::from_str(r#"{"appearance":{"showToolWindowNames":true}}"#).unwrap();

crates/ide-dap/src/adapter.rs

@@ -525,9 +525,10 @@ async fn spawn_adapter(
         cmd.env("PATH", path);
     }
     ide_core::process::prepare(cmd.as_std_mut());
-    if spec.adapter == "rdbg" {
-        ide_core::process::own_group(cmd.as_std_mut());
-    }
+    // Every adapter leads its own process group: the program an adapter launches itself
+    // (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
+    // one `kill(-pgid)`. On Windows the same coverage comes from the session's job object.
+    ide_core::process::own_group(cmd.as_std_mut());
     cmd.args(args)
         .envs(spec.env.iter().map(|(k, v)| (k, v)))
         .current_dir(&spec.cwd)

crates/ide-dap/src/lib.rs

@@ -1160,7 +1160,7 @@ impl DebugManager {
         if own_terminate && !graceful {
             // Signal before anything else: waiting on a request the adapter may not answer
             // would delay the shutdown the console is supposed to show.
-            crate::session::signal_debuggee(s, false);
+            crate::session::signal_debuggee(s, false).await;
         }
         if graceful {
             // java-debug sends `terminated` only after it has drained the program's console

crates/ide-dap/src/session.rs

@@ -45,6 +45,13 @@ pub(crate) struct Session {
     pub debuggees: Mutex<Vec<Child>>,
     /// The terminal a `runInTerminal` program runs in: typed input goes to it.
     pub program: Mutex<Option<ProgramTerminal>>,
+    /// The job object over the adapter and everything it started: the program an adapter
+    /// like java-debug launches is its child, so a forced stop (and the session's
+    /// cleanup) ends the whole tree even when the adapter exited first and the reported
+    /// pid no longer names it. `None` when the assignment failed; the kill then falls
+    /// back to the captured process tree.
+    #[cfg(windows)]
+    pub job: Mutex<Option<ide_core::process::Job>>,
     /// Set once `configurationDone` was sent; breakpoint updates go out live after that.
     pub configured: AtomicBool,
     pub initialized: watch::Sender<bool>,
@@ -91,6 +98,10 @@ impl Session {
         port: Option<u16>,
         child: Option<Child>,
     ) -> Self {
+        // Before `child` moves into the session: the adapter is the root of the job, so
+        // everything it starts (java-debug's JVM) is in there by inheritance.
+        #[cfg(windows)]
+        let job = child.as_ref().and_then(tokio::process::Child::id).and_then(ide_core::process::Job::for_pid);
         Self {
             id,
             owner,
@@ -105,6 +116,8 @@ impl Session {
             adapter_process: Mutex::new(child),
             debuggees: Mutex::new(Vec::new()),
             program: Mutex::new(None),
+            #[cfg(windows)]
+            job: Mutex::new(job),
             configured: AtomicBool::new(false),
             initialized: watch::channel(false).0,
             startup_cancel: ide_core::CancellationToken::new(),
@@ -282,6 +295,24 @@ impl Session {
     /// Kills the adapter and every debuggee we started.
     pub fn kill_processes(&self) {
         self.kotlin_relay.lock().take();
+        #[cfg(unix)]
+        if self.request == "launch" {
+            for group in launch_groups(self) {
+                ide_core::process::kill_tree_of(group as u32);
+            }
+        }
+        // The job first: it ends the adapter and everything it started (the program
+        // java-debug launched is its child), members included that the stop's captured
+        // tree never saw. An empty job is unaffected, and whatever survives this session
+        // dies when the handle closes (`KILL_ON_JOB_CLOSE`).
+        #[cfg(windows)]
+        if let Some(job) = self.job.lock().as_ref() {
+            job.terminate();
+        }
+        #[cfg(windows)]
+        if let Some(tree) = self.stop_tree.lock().as_ref() {
+            tree.terminate();
+        }
         if let Some(mut c) = self.adapter_process.lock().take() {
             if self.adapter == "rdbg"
                 && let Some(pid) = c.id()
@@ -295,6 +326,9 @@ impl Session {
         }
         if let Some(mut program) = self.program.lock().take() {
             let _ = program.child.kill();
+            let _ = std::thread::Builder::new().name("openidea-debug-reap".into()).spawn(move || {
+                let _ = program.child.wait();
+            });
         }
     }
 }
@@ -346,18 +380,36 @@ fn process_tree(pid: i32) -> Vec<i32> {
 /// Asks the program itself to exit (`force` = SIGKILL) without ending the adapter session:
 /// its output keeps flowing over DAP while it shuts down. The first call remembers the pid
 /// tree, because the reported pid may die before its program does.
-pub(crate) fn signal_debuggee(s: &Arc<Session>, force: bool) {
-    let pid = s.debuggee_pid.load(Ordering::Acquire);
-    if pid <= 0 {
+pub(crate) async fn signal_debuggee(s: &Arc<Session>, force: bool) {
+    if s.request != "launch" {
         return;
     }
+    #[cfg(not(windows))]
+    let pid = s.debuggee_pid.load(Ordering::Acquire);
     #[cfg(unix)]
     {
-        let mut known = s.stop_pids.lock();
-        if known.is_empty() {
-            *known = process_tree(pid as i32);
+        let needs_tree = pid > 0 && s.stop_pids.lock().is_empty();
+        if needs_tree {
+            let tree = tokio::task::spawn_blocking(move || process_tree(pid as i32)).await.unwrap_or_default();
+            *s.stop_pids.lock() = tree;
         }
+        let known = s.stop_pids.lock();
         let signal = if force { libc::SIGKILL } else { libc::SIGTERM };
+        if force {
+            // A forced stop kills the launch: every root the session spawned leads its own
+            // process group (`own_group` at spawn), so one signal reaches the program and
+            // everything it started, even processes born after the snapshot below was
+            // taken — the adapter's program is in the adapter's group. The session's own
+            // JVM roots (Kotlin) and `runInTerminal` programs lead groups of their own.
+            // The roots are unreaped until the session drops them, so their ids (and the
+            // groups named by them) cannot have been reused yet.
+            for group in launch_groups(s) {
+                // SAFETY: plain syscalls on the processes this session started.
+                if unsafe { libc::kill(-group, libc::SIGKILL) } != 0 {
+                    unsafe { libc::kill(group, libc::SIGKILL) };
+                }
+            }
+        }
         // Children first: the shell that started the program would otherwise reparent it.
         for p in known.iter().rev() {
             // SAFETY: plain syscall on the processes this session started.
@@ -368,15 +420,53 @@ pub(crate) fn signal_debuggee(s: &Arc<Session>, force: bool) {
     }
     #[cfg(windows)]
     {
-        // Console programs have no external graceful signal; the adapter gets its chance first.
-        if force && let Some(tree) = s.stop_tree.lock().as_ref() {
-            tree.terminate();
+        // Console programs have no external graceful signal; the adapter gets its chance
+        // first. The job ends the program and everything it started, members included
+        // that the captured tree never saw.
+        if force {
+            if let Some(job) = s.job.lock().as_ref() {
+                job.terminate();
+            }
+            // A separately spawned program may have rejected assignment to the adapter's job.
+            if let Some(tree) = s.stop_tree.lock().as_ref() {
+                tree.terminate();
+            }
         }
     }
     #[cfg(not(any(unix, windows)))]
     let _ = (pid, force);
 }
 
+/// The process groups the session spawned roots for: the adapter's (the program it
+/// launched is in it), the JVMs the session started itself, the `runInTerminal` program.
+#[cfg(unix)]
+fn launch_groups(s: &Session) -> Vec<libc::pid_t> {
+    let mut groups = Vec::new();
+    let mut push = |id: Option<u32>| {
+        if let Ok(pid) = libc::pid_t::try_from(id.unwrap_or(0)) {
+            groups.push(pid);
+        }
+    };
+    push(s.adapter_process.lock().as_ref().and_then(tokio::process::Child::id));
+    for child in s.debuggees.lock().iter() {
+        push(child.id());
+    }
+    push(s.program.lock().as_ref().and_then(|p| p.child.process_id()));
+    groups.retain(|g| *g > 0);
+    groups
+}
+
+/// Whether the launch is still running: the stop's captured tree when there is one,
+/// otherwise the session's job (the adapter and everything it started).
+#[cfg(windows)]
+fn launch_running(s: &Arc<Session>) -> bool {
+    if let Some(tree) = s.stop_tree.lock().as_ref() {
+        tree.is_running()
+    } else {
+        s.job.lock().as_ref().is_some_and(|job| job.is_running())
+    }
+}
+
 /// Waits until the program a `launch` session started is gone; a second Stop kills it.
 pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     if !terminate || s.request != "launch" {
@@ -390,19 +480,19 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     #[cfg(unix)]
     {
         use std::time::Instant;
-        let targets = {
-            let known = s.stop_pids.lock();
-            if known.is_empty() { process_tree(pid as i32) } else { known.clone() }
-        };
+        let mut targets = s.stop_pids.lock().clone();
+        if targets.is_empty() {
+            targets = tokio::task::spawn_blocking(move || process_tree(pid as i32)).await.unwrap_or_default();
+        }
         let alive = || targets.iter().any(|p| unsafe { libc::kill(*p, 0) } == 0);
         let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
         while alive() {
             if s.stop_force.swap(false, Ordering::AcqRel) {
-                signal_debuggee(s, true);
+                signal_debuggee(s, true).await;
             }
             if Instant::now() >= deadline {
                 // The program ignored the terminate: do not leave it running.
-                signal_debuggee(s, true);
+                signal_debuggee(s, true).await;
                 break;
             }
             tokio::time::sleep(Duration::from_millis(50)).await;
@@ -412,9 +502,12 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     {
         remember_debuggee(s).await;
         let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
-        while s.stop_tree.lock().as_ref().is_some_and(|tree| tree.is_running()) {
+        // The captured tree is the oracle when it was captured; otherwise the job (every
+        // process the launch started) is, so a failed capture can no longer end the wait
+        // while the program still holds its port.
+        while launch_running(s) {
             if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
-                signal_debuggee(s, true);
+                signal_debuggee(s, true).await;
             }
             tokio::time::sleep(Duration::from_millis(50)).await;
         }
@@ -697,6 +790,14 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
         }
     }
     let mut child = pair.slave.spawn_command(cmd).map_err(|e| format!("failed to start {program}: {e}"))?;
+    // The program joins the session's job, so Stop reaches what it starts (its children),
+    // though only the program itself is the session's child.
+    #[cfg(windows)]
+    if let Some(pid) = child.process_id()
+        && let Some(job) = s.job.lock().as_ref()
+    {
+        job.assign_pid(pid);
+    }
     drop(pair.slave);
     let reader = pair.master.try_clone_reader().map_err(|e| format!("terminal of {program}: {e}"))?;
     let writer = pair.master.take_writer().map_err(|e| format!("terminal of {program}: {e}"))?;
@@ -864,7 +965,16 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
             }
         }
     }
+    // A root the session spawns itself: its own process group on Unix (`kill(-pgid)` in a
+    // forced stop), the session's job on Windows, so a stop reaches what it forks.
+    ide_core::process::own_group(cmd.as_std_mut());
     let mut child = cmd.spawn()?;
+    #[cfg(windows)]
+    if let Some(pid) = child.id()
+        && let Some(job) = s.job.lock().as_ref()
+    {
+        job.assign_pid(pid);
+    }
     if let Some(err) = child.stderr.take() {
         forward_output(s, err, "stderr");
     }

crates/ide-dap/src/tests.rs

@@ -1963,3 +1963,55 @@ async fn rdbg_drains_test_output_after_dap_closes_before_killing_the_process() {
         IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } if output == "test summary\n"
     )));
 }
+
+#[cfg(unix)]
+#[tokio::test]
+async fn cleanup_ends_the_adapter_tree_without_a_process_event() {
+    use tokio::io::AsyncBufReadExt;
+
+    let h = harness(Script::default());
+    let id = h.start(config()).await.unwrap();
+    let session = h.manager.session(id).unwrap();
+    let mut command = tokio::process::Command::new("python3");
+    ide_core::process::own_group(command.as_std_mut());
+    command
+        .args([
+            "-u",
+            "-c",
+            "import subprocess,sys,time; subprocess.Popen([sys.executable, '-u', '-c', \
+             \"import socket,time; s=socket.socket(); s.bind(('127.0.0.1',0)); s.listen(); \
+             print(s.getsockname()[1],flush=True); time.sleep(60)\"]); time.sleep(60)",
+        ])
+        .stdout(std::process::Stdio::piped());
+    let mut child = command.spawn().unwrap();
+    let mut lines = BufReader::new(child.stdout.take().unwrap()).lines();
+    let port: u16 = lines.next_line().await.unwrap().unwrap().parse().unwrap();
+    assert!(std::net::TcpListener::bind(("127.0.0.1", port)).is_err(), "the descendant holds the port");
+    let pid = child.id().unwrap();
+    *session.adapter_process.lock() = Some(child);
+    session.kill_processes();
+    let deadline = Instant::now() + Duration::from_secs(3);
+    while std::net::TcpListener::bind(("127.0.0.1", port)).is_err() {
+        if Instant::now() >= deadline {
+            ide_core::process::kill_tree_of(pid);
+            panic!("adapter cleanup left its descendant holding the port");
+        }
+        tokio::time::sleep(Duration::from_millis(20)).await;
+    }
+    h.manager.stop(id).await.unwrap();
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn stop_detaches_from_an_attached_program() {
+    let mut child = std::process::Command::new("sleep").arg("60").spawn().unwrap();
+    let h = harness(Script { debuggee_pid: Some(child.id()), ..Default::default() });
+    let id = h.start(LaunchConfig { request: "attach".into(), ..config() }).await.unwrap();
+    h.manager.stop(id).await.unwrap();
+    let alive = child.try_wait().unwrap().is_none();
+    let _ = child.kill();
+    let _ = child.wait();
+    assert!(alive, "Stop killed the attached program");
+    assert!(!h.commands().contains(&"terminate".to_owned()));
+    assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
+}

crates/ide-github/src/model.rs

@@ -627,8 +627,8 @@ mod tests {
     #[test]
     fn finds_remote_by_repo() {
         let remotes = vec![
-            ide_vcs::Remote { name: "origin".into(), url: "[email protected]:me/App.git".into() },
-            ide_vcs::Remote { name: "upstream".into(), url: "https://github.com/org/app/".into() },
+            ide_vcs::Remote { name: "origin".into(), url: "[email protected]:me/App.git".into(), resolved_url: None },
+            ide_vcs::Remote { name: "upstream".into(), url: "https://github.com/org/app/".into(), resolved_url: None },
         ];
         assert_eq!(remote_for(&remotes, "me/app").map(|r| r.name.as_str()), Some("origin"));
         assert_eq!(remote_for(&remotes, "org/app").map(|r| r.name.as_str()), Some("upstream"));

crates/ide-host/src/data_dirs.rs

@@ -26,10 +26,8 @@ fn resolve_local(var: Option<OsString>, os: Option<PathBuf>, identifier: &str) -
         return Err(format!("{LOCAL_DATA_ENV} must be an absolute path: {}", root.display()));
     }
     let dir = root.join(identifier);
-    let probe = dir.join(".openidea-write-check");
     fs::create_dir_all(&dir)
-        .and_then(|()| fs::write(&probe, b""))
-        .and_then(|()| fs::remove_file(&probe))
+        .and_then(|()| tempfile::NamedTempFile::new_in(&dir).map(drop))
         .map_err(|error| format!("{LOCAL_DATA_ENV}: cannot write to {}: {error}", dir.display()))?;
     Ok(dir)
 }
@@ -327,6 +325,53 @@ mod tests {
         assert_ne!(resolve_local(Some(root.clone().into()), None, "dev-a").unwrap(), dir);
     }
 
+    #[test]
+    fn local_dir_preserves_an_existing_probe_file() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().join("id");
+        fs::create_dir(&dir).unwrap();
+        let probe = dir.join(".openidea-write-check");
+        fs::write(&probe, "keep").unwrap();
+        assert_eq!(resolve_local(Some(tmp.path().into()), None, "id").unwrap(), dir);
+        assert_eq!(fs::read_to_string(probe).unwrap(), "keep");
+        assert_eq!(fs::read_dir(dir).unwrap().count(), 1);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn local_dir_preserves_an_existing_probe_symlink_and_its_target() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().join("id");
+        fs::create_dir(&dir).unwrap();
+        let target = tmp.path().join("target");
+        fs::write(&target, "keep").unwrap();
+        let probe = dir.join(".openidea-write-check");
+        std::os::unix::fs::symlink(&target, &probe).unwrap();
+        assert_eq!(resolve_local(Some(tmp.path().into()), None, "id").unwrap(), dir);
+        assert_eq!(fs::read_to_string(target).unwrap(), "keep");
+        assert!(fs::symlink_metadata(probe).unwrap().file_type().is_symlink());
+        assert_eq!(fs::read_dir(dir).unwrap().count(), 1);
+    }
+
+    #[test]
+    fn local_dir_allows_concurrent_probes_for_the_same_identifier() {
+        let tmp = tempfile::tempdir().unwrap();
+        let barrier = std::sync::Barrier::new(8);
+        std::thread::scope(|scope| {
+            for _ in 0..8 {
+                let barrier = &barrier;
+                let root = tmp.path();
+                scope.spawn(move || {
+                    barrier.wait();
+                    for _ in 0..16 {
+                        assert_eq!(resolve_local(Some(root.into()), None, "id").unwrap(), root.join("id"));
+                    }
+                });
+            }
+        });
+        assert_eq!(fs::read_dir(tmp.path().join("id")).unwrap().count(), 0);
+    }
+
     #[test]
     fn local_dir_rejects_relative_and_unwritable_paths() {
         for relative in ["local", "./local", "../local"] {

crates/ide-host/src/ops/debug.rs

@@ -9,6 +9,32 @@ use std::path::PathBuf;
 
 /// Starts a session owned by this window: its events (and those of child sessions) go here only.
 pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
+    debug_start_request(host, window, config, None).await
+}
+
+pub async fn debug_start_request(
+    host: &Host,
+    window: &str,
+    config: LaunchConfig,
+    request: Option<ide_core::RequestId>,
+) -> IdeResult<DebugSessionId> {
+    let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
+    let result = debug_start_inner(host, window, config, &cancel).await;
+    if let Some(id) = request {
+        host.end_request(id);
+    }
+    result
+}
+
+async fn debug_start_inner(
+    host: &Host,
+    window: &str,
+    config: LaunchConfig,
+    cancel: &ide_core::CancellationToken,
+) -> IdeResult<DebugSessionId> {
+    if cancel.is_cancelled() {
+        return Err(ide_core::IdeError::cancelled());
+    }
     host.require_trust(window)?;
     let target_id = config
         .extra_json
@@ -17,7 +43,7 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
         .and_then(|v| v.get("__runTarget").and_then(|v| v.as_str()).map(str::to_owned));
     if let Some(id) = target_id {
         let owner = SessionOwner::new(host.owner_window(window), host.window_sink(window));
-        return target::start(host, window, config, owner, id).await;
+        return target::start(host, window, config, owner, id, cancel).await;
     }
     let mut config = match_java_debug_encoding(config, cfg!(windows));
     if config.adapter == "debugpy"
@@ -392,7 +418,9 @@ pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSe
 
 /// Commands of this module the remote server answers.
 pub(crate) fn register(d: &mut Dispatcher) {
-    d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
+    d.add("debug_start", |c| async move {
+        debug_start_request(&c.host, &c.window, c.arg("config")?, c.arg("request")?).await
+    });
     d.add("debug_set_breakpoints", |c| async move {
         debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
     });

crates/ide-host/src/ops/debug/target.rs

@@ -12,6 +12,7 @@ pub(super) async fn start(
     mut config: LaunchConfig,
     owner: SessionOwner,
     id: String,
+    cancel: &ide_core::CancellationToken,
 ) -> IdeResult<ide_core::DebugSessionId> {
     let project = host.project(window)?;
     let plugins =
@@ -33,6 +34,23 @@ pub(super) async fn start(
     {
         return Err(IdeError::invalid("This debugger does not support plugin run targets"));
     }
+    let program = config
+        .extra_json
+        .as_deref()
+        .and_then(|s| serde_json::from_str::<serde_json::Value>(s).ok())
+        .and_then(|v| v.get("__runTargetProgram").and_then(|p| p.as_str()).map(str::to_owned))
+        .or_else(|| config.program.clone())
+        .unwrap_or_else(|| dbg.command.clone());
+    let metadata = serde_json::from_value(json!({"id":"debug", "name":config.name, "kind":"shell", "command":program, "args":[], "cwd":config.cwd, "env":{}, "detected":false, "isTest":false}))
+        .map_err(|e| IdeError::invalid(e.to_string()))?;
+    let (validator, root, target, token) = (plugins.clone(), project.root.clone(), id.clone(), cancel.clone());
+    host.blocking(move || {
+        validator.prepare_run_target_launch(&root, &target, &metadata, ide_plugin::RunTargetOperation::Debug, &token)
+    })
+    .await?;
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
     let mapping = TargetMapping {
         paths: PathMapping::new(&project.root.to_string_lossy(), &container),
         external_prefix: format!(
@@ -48,6 +66,7 @@ pub(super) async fn start(
         .map_err(|e| IdeError::invalid(e.to_string()))?
         .unwrap_or(json!({}));
     extra.as_object_mut().ok_or_else(|| IdeError::invalid("invalid debug launch arguments"))?.remove("__runTarget");
+    extra.as_object_mut().unwrap().remove("__runTargetProgram");
     // DAP paths already use target coordinates; adapter-native mappings stay identity.
     if placement == "connect-back" {
         config.program = None;

crates/ide-host/src/ops/lsp.rs

@@ -197,6 +197,7 @@ fn plugin_completion(item: ide_plugin::CompletionItem) -> CompletionItem {
     CompletionItem {
         label: item.label,
         label_detail: None,
+        label_description: None,
         detail: item.detail,
         kind,
         documentation: item.documentation.map(|value| Markup { kind: "markdown".into(), value }),
@@ -584,6 +585,82 @@ pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> Ide
     host.project(window)?.lsp.virtual_document(&uri).await
 }
 
+/// Whether this class belongs to the project's Maven local repository.
+pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) -> IdeResult<bool> {
+    let project = host.project(window)?;
+    if !project.is_trusted() {
+        return Ok(false);
+    }
+    let Some(jar) = ide_lsp::LspManager::library_archive(&uri) else { return Ok(false) };
+    host.blocking(move || {
+        let settings = project.settings.effective();
+        let repository = ide_sdk::apply::maven_local_repository(&project.root, &settings)
+            .or_else(ide_build::maven::default_local_repo);
+        Ok(repository.is_some_and(|repo| ide_build::maven::sources::artifact(&jar, &repo).is_some())
+            && ide_build::maven::has_projects(&project.root, &settings.languages.java.maven))
+    })
+    .await
+}
+
+/// Download with the project's Maven configuration, or attach an archive selected by the user.
+pub async fn lsp_library_sources(
+    host: &Host,
+    window: &str,
+    request: RequestId,
+    uri: String,
+    pos: Pos,
+    sources: Option<std::path::PathBuf>,
+) -> IdeResult<Option<Location>> {
+    host.require_trust(window)?;
+    let project = host.project(window)?;
+    let cancel = host.begin_project_request(window, request);
+    let result = async {
+        let sources = match sources {
+            Some(sources) => Some(sources),
+            None => {
+                let jar = ide_lsp::LspManager::library_archive(&uri)
+                    .ok_or_else(|| IdeError::invalid("not a library class"))?;
+                let project = project.clone();
+                let cancel = cancel.clone();
+                host.blocking(move || {
+                    let settings = project.settings.effective();
+                    let repository = ide_sdk::apply::maven_local_repository(&project.root, &settings)
+                        .or_else(ide_build::maven::default_local_repo)
+                        .ok_or_else(|| IdeError::unavailable("Maven local repository is unavailable"))?;
+                    let artifact = ide_build::maven::sources::artifact(&jar, &repository)
+                        .ok_or_else(|| IdeError::invalid("not an artifact in the Maven local repository"))?;
+                    let model = super::build::load(&project.root, &project.build_cache_dir(), &settings);
+                    let maven = model.maven.ok_or_else(|| IdeError::unavailable("no Maven project"))?;
+                    let owns = |p: &&ide_build::maven::MavenProject| {
+                        p.dependencies.iter().any(|d| d.group_id == artifact.group && d.artifact_id == artifact.name)
+                    };
+                    let mut owner = maven
+                        .projects
+                        .iter()
+                        .find(owns)
+                        .or_else(|| maven.projects.first())
+                        .cloned()
+                        .ok_or_else(|| IdeError::unavailable("no Maven project"))?;
+                    let profiles =
+                        settings.languages.java.maven.profiles(&ide_build::maven_profiles(&project.build_cache_dir()));
+                    if !profiles.is_empty() {
+                        owner.options.push(format!("-P{}", profiles.join(",")));
+                    }
+                    ide_build::maven::sources::download(&project.root, &owner, &artifact, &repository, &cancel)
+                })
+                .await?
+            }
+        };
+        match sources {
+            Some(sources) => project.lsp.library_source_location(&uri, sources, pos, &cancel).await,
+            None => Ok(None),
+        }
+    }
+    .await;
+    host.end_request(request);
+    result
+}
+
 /// Opens compiled classes through JDT, with project source taking priority on disk.
 pub async fn lsp_resolve_class_file(host: &Host, window: &str, path: std::path::PathBuf) -> IdeResult<String> {
     let archive = ide_vfs::split_archive_path(&path);
@@ -822,6 +899,8 @@ fn plugin_code_action(plugin: &str, root: &Path, a: ide_plugin::CodeAction) -> C
         .and_then(|r| serde_json::to_value(r).ok());
     CodeAction {
         title: a.title,
+        diagnostics: Vec::new(),
+        original_diagnostics: None,
         kind: a.kind,
         is_preferred: a.preferred,
         disabled_reason,
@@ -1646,6 +1725,14 @@ pub(crate) fn register(d: &mut Dispatcher) {
         |c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
     );
     d.add("lsp_virtual_document", |c| async move { lsp_virtual_document(&c.host, &c.window, c.arg("uri")?).await });
+    d.add(
+        "lsp_can_download_sources",
+        |c| async move { lsp_can_download_sources(&c.host, &c.window, c.arg("uri")?).await },
+    );
+    d.add("lsp_library_sources", |c| async move {
+        lsp_library_sources(&c.host, &c.window, c.arg("request")?, c.arg("uri")?, c.arg("pos")?, c.arg("sources")?)
+            .await
+    });
     d.add("lsp_references", |c| async move {
         let on_partial = c.sender("onPartial")?;
         lsp_references(

crates/ide-host/src/ops/run.rs

@@ -203,8 +203,22 @@ pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> Ide
 }
 
 pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit<OutputChunk>) -> IdeResult<RunInfo> {
+    start_request(host, window, config, on_output, None).await
+}
+
+pub async fn start_request(
+    host: &Host,
+    window: &str,
+    config: RunConfig,
+    on_output: Emit<OutputChunk>,
+    request: Option<ide_core::RequestId>,
+) -> IdeResult<RunInfo> {
+    let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
     let operation = config.extras.params.get("plugin.operation").cloned();
-    let result = start_inner(host, window, config, on_output).await;
+    let result = start_inner(host, window, config, on_output, &cancel).await;
+    if let Some(id) = request {
+        host.end_request(id);
+    }
     if let (Ok(info), Some(operation), Some(plugins)) = (&result, operation, host.plugin_host()) {
         plugins.run_operation_started(window, &operation, info.id);
     }
@@ -216,7 +230,11 @@ async fn start_inner(
     window: &str,
     mut config: RunConfig,
     on_output: Emit<OutputChunk>,
+    cancel: &ide_core::CancellationToken,
 ) -> IdeResult<RunInfo> {
+    if cancel.is_cancelled() {
+        return Err(IdeError::cancelled());
+    }
     host.require_trust(window)?;
     let project = host.project(window)?;
     if config.extras.target.is_none() {
@@ -259,7 +277,23 @@ async fn start_inner(
                 host.plugin_host().ok_or_else(|| IdeError::not_found("plugin run target is no longer available"))?;
             let root = project.root.clone();
             let id = id.to_owned();
-            let config = host.blocking(move || plugins.prepare_run_target(&root, &id, &config)).await?;
+            let token = cancel.clone();
+            let config = host
+                .blocking(move || {
+                    let operation =
+                        if config.extras.params.get("plugin.targetOperation").is_some_and(|op| op == "debug") {
+                            ide_plugin::RunTargetOperation::Debug
+                        } else if config.is_test {
+                            ide_plugin::RunTargetOperation::Test
+                        } else {
+                            ide_plugin::RunTargetOperation::Run
+                        };
+                    plugins.prepare_run_target_launch(&root, &id, &config, operation, &token)
+                })
+                .await?;
+            if cancel.is_cancelled() {
+                return Err(IdeError::cancelled());
+            }
             project.require_trust()?;
             return host.processes.start(
                 &project.root,

crates/ide-host/src/ops/vcs/commands.rs

@@ -673,10 +673,11 @@ pub async fn vcs_rename_branch(
     repo: Option<PathBuf>,
     from: String,
     to: String,
+    unset_upstream: bool,
 ) -> IdeResult<()> {
     host.require_trust(window)?;
     let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to))).await
+    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to, unset_upstream))).await
 }
 
 pub async fn vcs_merge(host: &Host, window: &str, repo: Option<PathBuf>, branch: String) -> IdeResult<()> {
@@ -995,7 +996,17 @@ pub async fn vcs_rebase_with(
 
 pub async fn vcs_remotes(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<Remote>> {
     let project = LogAccess::new(host, window, repo.as_deref());
-    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.remotes())).await
+    blocking(move || {
+        let mut remotes = project.with_log_repo_at(repo.as_deref(), |r| r.remotes())?;
+        for r in &mut remotes {
+            let resolved = ide_ssh::resolve_ssh_remote_url(&r.url);
+            if resolved != r.url {
+                r.resolved_url = Some(resolved);
+            }
+        }
+        Ok(remotes)
+    })
+    .await
 }
 
 pub async fn vcs_edit_remote(host: &Host, window: &str, repo: Option<PathBuf>, edit: RemoteEdit) -> IdeResult<()> {
@@ -1379,7 +1390,8 @@ pub(crate) fn register(d: &mut Dispatcher) {
         vcs_restore_branch(&c.host, &c.window, c.arg("repo")?, c.arg("deleted")?).await
     });
     d.add("vcs_rename_branch", |c| async move {
-        vcs_rename_branch(&c.host, &c.window, c.arg("repo")?, c.arg("from")?, c.arg("to")?).await
+        vcs_rename_branch(&c.host, &c.window, c.arg("repo")?, c.arg("from")?, c.arg("to")?, c.arg("unset_upstream")?)
+            .await
     });
     d.add("vcs_merge", |c| async move { vcs_merge(&c.host, &c.window, c.arg("repo")?, c.arg("branch")?).await });
     d.add("vcs_rebase", |c| async move { vcs_rebase(&c.host, &c.window, c.arg("repo")?, c.arg("onto")?).await });

crates/ide-host/src/plugins/intellij.rs

@@ -78,6 +78,25 @@ pub fn read_source(path: &Path) -> IdeResult<IntellijThemeSource> {
 /// The theme plugins of the JetBrains IDEs (and Android Studio) of this user,
 /// the themes their IDEs are set to first.
 pub fn installed_themes() -> Vec<InstalledIntellijTheme> {
+    find_installed(&latest_product_versions(local_ide_dirs()))
+}
+
+/// The settings folder of a JetBrains IDE (or Android Studio) of this user.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct InstalledIdeSettings {
+    /// The IDE and its version: `IntelliJ IDEA 2025.2`.
+    pub ide: String,
+    /// What Import Settings reads.
+    pub path: IpcPath,
+}
+
+/// The settings folders of the JetBrains IDEs of this user, most recently used first.
+pub fn installed_ide_settings() -> Vec<InstalledIdeSettings> {
+    settings_folders(&local_ide_dirs())
+}
+
+fn local_ide_dirs() -> Vec<IdeDir> {
     let Some(home) = dirs::home_dir() else { return Vec::new() };
     let layout = if cfg!(target_os = "macos") {
         Layout::Mac
@@ -86,7 +105,65 @@ pub fn installed_themes() -> Vec<InstalledIntellijTheme> {
     } else {
         Layout::Xdg
     };
-    find_installed(&ide_dirs(layout, &home, |key| std::env::var_os(key)))
+    ide_dirs(layout, &home, |key| std::env::var_os(key))
+}
+
+fn settings_folders(ides: &[IdeDir]) -> Vec<InstalledIdeSettings> {
+    let mut used: Vec<_> =
+        ides.iter().filter_map(|ide| settings_modified(&ide.config).map(|time| (ide, time))).collect();
+    used.sort_by(|(a, at), (b, bt)| {
+        bt.cmp(at).then_with(|| a.label.cmp(&b.label)).then_with(|| a.config.cmp(&b.config))
+    });
+    used.into_iter()
+        .map(|(ide, _)| InstalledIdeSettings { ide: ide.label.clone(), path: ide.config.clone().into() })
+        .collect()
+}
+
+fn settings_modified(config: &Path) -> Option<std::time::SystemTime> {
+    let options = config.join("options");
+    // Match the folder reader: never count links or walk below the settings directories.
+    if !config.symlink_metadata().ok()?.is_dir() || !options.symlink_metadata().ok()?.is_dir() {
+        return None;
+    }
+    let mut modified = None;
+    let mut customised = false;
+    for entry in std::fs::read_dir(&options).ok()?.flatten() {
+        let path = entry.path();
+        if !entry.file_type().is_ok_and(|t| t.is_file())
+            || !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("xml"))
+        {
+            continue;
+        }
+        let Ok(meta) = entry.metadata() else { continue };
+        modified = modified.max(meta.modified().ok());
+        // Startup bookkeeping can exist before the user has changed any settings.
+        let name = entry.file_name();
+        customised |= meta.len() > 0
+            && !matches!(
+                name.to_str(),
+                Some(
+                    "other.xml"
+                        | "nonRoamable.xml"
+                        | "early-access-registry.xml"
+                        | "applicationInfo.xml"
+                        | "updates.xml"
+                        | "usage.statistics.xml"
+                )
+            );
+    }
+    customised |= ["keymaps", "codestyles", "colors", "templates", "inspection"].iter().any(|sub| {
+        let dir = config.join(sub);
+        dir.symlink_metadata().is_ok_and(|m| m.is_dir())
+            && std::fs::read_dir(dir).into_iter().flatten().flatten().any(|entry| {
+                entry.file_type().is_ok_and(|t| t.is_file())
+                    && entry.metadata().is_ok_and(|m| m.len() > 0)
+                    && entry
+                        .path()
+                        .extension()
+                        .is_some_and(|e| e.eq_ignore_ascii_case("xml") || e.eq_ignore_ascii_case("icls"))
+            })
+    });
+    customised.then(|| modified.or_else(|| options.metadata().ok()?.modified().ok()).unwrap_or(std::time::UNIX_EPOCH))
 }
 
 fn read(path: &Path) -> Result<IntellijThemeSource, String> {
@@ -422,8 +499,7 @@ struct IdeDir {
     plugins: PathBuf,
 }
 
-/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first, one
-/// per product: its newest version's (an upgrade leaves the older ones behind).
+/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest version first.
 fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>) -> Vec<IdeDir> {
     let var = |key: &str| env(key).filter(|v| !v.is_empty()).map(PathBuf::from);
     let (config_root, data_root) = match layout {
@@ -463,11 +539,16 @@ fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>)
         }
     }
     out.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| a.label.cmp(&b.label)));
-    let mut products = std::collections::HashSet::new();
-    out.retain(|ide| products.insert(ide.product.clone()));
     out
 }
 
+/// Theme discovery only uses the newest version of each product.
+fn latest_product_versions(mut ides: Vec<IdeDir>) -> Vec<IdeDir> {
+    let mut products = std::collections::HashSet::new();
+    ides.retain(|ide| products.insert(ide.product.clone()));
+    ides
+}
+
 /// `IntelliJIdea2025.2` → (`IntelliJIdea`, (2025, 2), `2025.2`).
 fn product_dir(name: &str) -> Option<(&str, (u32, u32), &str)> {
     let at = name.find(|c: char| c.is_ascii_digit())?;
@@ -787,15 +868,16 @@ mod tests {
         };
         let mac = mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.2"));
         mk(home.join("Library/Application Support/JetBrains/Toolbox"));
-        // An upgrade leaves the older version's folder behind: only the newest of a product counts.
+        // Settings import keeps every version; theme discovery uses only the newest.
         mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2024.3"));
         mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10"));
         let dirs = ide_dirs(Layout::Mac, home, |_| None);
-        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs.len(), 3);
         assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.10");
+        assert_eq!(latest_product_versions(dirs).len(), 1);
         std::fs::remove_dir(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10")).unwrap();
         let dirs = ide_dirs(Layout::Mac, home, |_| None);
-        assert_eq!(dirs.len(), 1);
+        assert_eq!(dirs.len(), 2);
         assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.2");
         assert_eq!((dirs[0].config.clone(), dirs[0].plugins.clone()), (mac.clone(), mac.join("plugins")));
 
@@ -881,4 +963,107 @@ mod tests {
         assert_eq!(found, [theme("shallow-id", "Shallow", false, true), theme("deep-sea-id", "Deep Sea", true, false)]);
         assert!(find_installed(&[]).is_empty());
     }
+
+    #[test]
+    fn unused_newer_versions_do_not_hide_settings() {
+        let tmp = tempfile::tempdir().unwrap();
+        for (layout, root) in [
+            (Layout::Mac, "Library/Application Support"),
+            (Layout::Windows, "AppData/Roaming"),
+            (Layout::Xdg, ".config"),
+        ] {
+            let root = tmp.path().join(root).join("JetBrains");
+            let used = root.join("IntelliJIdea2024.3");
+            let fresh = root.join("IntelliJIdea2025.2");
+            write(&used.join("options/editor.xml"), b"<application><component name=\"EditorSettings\"/></application>");
+            std::fs::create_dir_all(&fresh).unwrap();
+            let expected = vec![InstalledIdeSettings { ide: "IntelliJ IDEA 2024.3".into(), path: used.into() }];
+            assert_eq!(settings_folders(&ide_dirs(layout, tmp.path(), |_| None)), expected);
+            write(&fresh.join("options/other.xml"), b"<application/>");
+            write(&fresh.join("options/early-access-registry.xml"), b"<application/>");
+            assert_eq!(settings_folders(&ide_dirs(layout, tmp.path(), |_| None)), expected);
+        }
+    }
+
+    #[test]
+    fn settings_candidates_keep_used_versions_and_sort_by_options_modification() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().join("Library/Application Support/JetBrains");
+        let put = |product: &str, file: &str, seconds| {
+            let path = root.join(product).join(file);
+            write(&path, b"<application/>");
+            std::fs::File::open(path)
+                .unwrap()
+                .set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(seconds))
+                .unwrap();
+        };
+        put("IntelliJIdea2025.2", "options/editor.xml", 100);
+        put("IntelliJIdea2024.3", "options/editor.xml", 200);
+        put("IntelliJIdea2024.3", "options/editor-font.xml", 400);
+        put("PyCharm2025.1", "options/editor.xml", 300);
+        // Directory times and unrelated files do not change options-file ordering.
+        write(&root.join("IntelliJIdea2025.2/options/README.txt"), b"recent");
+        let dirs = ide_dirs(Layout::Mac, tmp.path(), |_| None);
+        let found = settings_folders(&dirs);
+        assert_eq!(
+            found.iter().map(|s| s.ide.as_str()).collect::<Vec<_>>(),
+            ["IntelliJ IDEA 2024.3", "PyCharm 2025.1", "IntelliJ IDEA 2025.2"]
+        );
+        assert_eq!(found[0].path, root.join("IntelliJIdea2024.3"));
+        assert_eq!(latest_product_versions(dirs).len(), 2);
+    }
+
+    #[test]
+    fn skips_empty_and_startup_only_settings_but_keeps_custom_schemes() {
+        let tmp = tempfile::tempdir().unwrap();
+        let config = tmp.path();
+        assert!(settings_modified(config).is_none());
+        std::fs::create_dir(config.join("options")).unwrap();
+        assert!(settings_modified(config).is_none());
+        for file in ["other", "nonRoamable", "early-access-registry", "applicationInfo", "updates", "usage.statistics"]
+        {
+            write(
+                &config.join(format!("options/{file}.xml")),
+                b"<application><component name=\"Startup\"/></application>",
+            );
+        }
+        write(&config.join("options/editor.xml"), b"");
+        write(&config.join("options/nested/editor.xml"), b"<application/>");
+        for sub in ["keymaps", "codestyles", "colors", "templates", "inspection"] {
+            std::fs::create_dir(config.join(sub)).unwrap();
+            write(&config.join(sub).join("README.txt"), b"not settings");
+        }
+        assert!(settings_modified(config).is_none());
+        for (sub, file) in [
+            ("keymaps", "custom.xml"),
+            ("codestyles", "custom.xml"),
+            ("colors", "custom.icls"),
+            ("templates", "custom.xml"),
+            ("inspection", "custom.xml"),
+        ] {
+            let path = config.join(sub).join(file);
+            write(&path, b"<custom/>");
+            assert!(settings_modified(config).is_some(), "{sub} is a user setting");
+            std::fs::remove_file(path).unwrap();
+        }
+    }
+
+    #[test]
+    fn lists_the_settings_folders_of_ides_that_have_been_run() {
+        let tmp = tempfile::tempdir().unwrap();
+        let ide = |label: &str, product: &str, version: (u32, u32)| {
+            let config = tmp.path().join(format!("{product}{}.{}", version.0, version.1));
+            IdeDir { label: label.into(), product: product.into(), version, config: config.clone(), plugins: config }
+        };
+        let used = ide("IntelliJ IDEA 2025.2", "IntelliJIdea", (2025, 2));
+        let fresh = ide("PyCharm 2025.1", "PyCharm", (2025, 1));
+        let used_config = used.config.clone();
+        write(&used_config.join("options/editor.xml"), b"<application/>");
+        std::fs::create_dir_all(&fresh.config).unwrap();
+        assert_eq!(
+            settings_folders(&[used, fresh]),
+            [InstalledIdeSettings { ide: "IntelliJ IDEA 2025.2".into(), path: used_config.into() }]
+        );
+        assert!(settings_folders(&[]).is_empty());
+    }
 }

crates/ide-host/src/plugins/mod.rs

@@ -143,6 +143,8 @@ struct Meta {
     retry_at: Option<Instant>,
     /// The component exports `syntax-provider` (known once activated).
     has_syntax: bool,
+    /// Known before activation can publish target registrations.
+    has_run_target_validation: bool,
     /// Next `on-schedule` activation.
     next_schedule: Option<Instant>,
     /// The trusted publisher of a signed installed package.
@@ -164,6 +166,7 @@ impl Meta {
             failures: 0,
             retry_at: None,
             has_syntax: false,
+            has_run_target_validation: false,
             publisher: None,
             next_schedule: None,
         }
@@ -1432,6 +1435,20 @@ impl PluginHost {
         cancel: Option<&ide_core::CancellationToken>,
         f: impl Fn(&mut Runtime, Invocation) -> Result<R, CallError> + Clone + Send + 'static,
     ) -> IdeResult<R> {
+        self.code_call_with_budget(id, invocation, what, cancel, None, f)
+    }
+
+    fn code_call_with_budget<R: Send + 'static>(
+        &self,
+        id: &str,
+        invocation: Invocation,
+        what: &str,
+        cancel: Option<&ide_core::CancellationToken>,
+        budget: Option<Duration>,
+        f: impl Fn(&mut Runtime, Invocation) -> Result<R, CallError> + Clone + Send + 'static,
+    ) -> IdeResult<R> {
+        let deadline = budget.map(|budget| Instant::now() + budget);
+        let fallback = ide_core::CancellationToken::new();
         let plugin = self.get(id)?;
         let client = invocation.client.clone();
         {
@@ -1472,10 +1489,25 @@ impl PluginHost {
             }
             let started = Instant::now();
             let (call, inv) = (f.clone(), invocation.clone());
-            let result = match cancel {
-                Some(cancel) => actor.call_cancellable(cancel, Duration::from_millis(50), move |rt| call(rt, inv)),
-                None => actor.call(None, move |rt| call(rt, inv)),
+            let result = match (deadline, cancel) {
+                (Some(deadline), cancel) => actor.call_bounded(
+                    cancel.unwrap_or(&fallback),
+                    Duration::from_millis(50),
+                    deadline.saturating_duration_since(Instant::now()),
+                    move |rt| call(rt, inv),
+                ),
+                (None, Some(cancel)) => {
+                    actor.call_cancellable(cancel, Duration::from_millis(50), move |rt| call(rt, inv))
+                }
+                (None, None) => actor.call(None, move |rt| call(rt, inv)),
             };
+            if deadline.is_some() && matches!(result, Err(ActorError::SoftTimeout)) {
+                self.reap(&plugin, &actor, client.as_deref());
+                return Err(IdeError::new(
+                    ide_core::error::ErrorKind::TimedOut,
+                    format!("plugin {id:?} timed out while {what}"),
+                ));
+            }
             if matches!(result, Err(ActorError::Cancelled)) {
                 self.reap(&plugin, &actor, client.as_deref());
                 return Err(IdeError::cancelled());
@@ -2523,6 +2555,7 @@ impl PluginHost {
                 return Err(IdeError::internal(format!("plugin {:?} {e}", plugin.id())));
             }
         };
+        plugin.meta.lock().has_run_target_validation = rt.has_run_target_validation();
         let crash = match rt.activate() {
             Ok(_) => None,
             Err(CallError::Trap(e)) => Some(format!("activation {e}")),

crates/ide-host/src/plugins/run_targets.rs

@@ -101,6 +101,28 @@ impl PluginHost {
         root: &Path,
         id: &str,
         config: &ide_run::RunConfig,
+    ) -> IdeResult<ide_run::RunConfig> {
+        self.prepare_target(root, id, config, None)
+    }
+
+    /// Prepares a user launch, including the optional plugin validation gate.
+    pub fn prepare_run_target_launch(
+        &self,
+        root: &Path,
+        id: &str,
+        config: &ide_run::RunConfig,
+        operation: ide_plugin::RunTargetOperation,
+        cancel: &ide_core::CancellationToken,
+    ) -> IdeResult<ide_run::RunConfig> {
+        self.prepare_target(root, id, config, Some((operation, cancel)))
+    }
+
+    fn prepare_target(
+        &self,
+        root: &Path,
+        id: &str,
+        config: &ide_run::RunConfig,
+        launch: Option<(ide_plugin::RunTargetOperation, &ide_core::CancellationToken)>,
     ) -> IdeResult<ide_run::RunConfig> {
         if !self.shared.workspace().is_some_and(|w| w.trusted(root)) {
             return Err(IdeError::new(ide_core::error::ErrorKind::PermissionDenied, "project is not trusted"));
@@ -113,7 +135,50 @@ impl PluginHost {
             .cloned()
             .ok_or_else(|| IdeError::not_found("plugin run target is no longer available"))?;
         let program = self.program_for_project(&target.plugin_id, &target.target.program, Some(root))?;
-        ide_remote::plugin_target::prepare(root, &target.target, &program, config)
+        let wrapped = ide_remote::plugin_target::prepare(root, &target.target, &program, config)?;
+        let validates = self.get(&target.plugin_id)?.meta.lock().has_run_target_validation;
+        if let Some((operation, cancel)) = launch
+            && validates
+        {
+            if cancel.is_cancelled() {
+                return Err(IdeError::cancelled());
+            }
+            let info = ide_plugin::RunTargetLaunch {
+                operation,
+                program: ide_run::wrap::program_name(&config.command),
+                cwd: wrapped.cwd.as_ref().unwrap().to_string_lossy().into_owned(),
+            };
+            let project_root = root.to_path_buf();
+            let invocation =
+                ide_plugin::Invocation { workspace_root: Some(project_root.clone()), ..Default::default() };
+            let (target_id, timeout) = (target.target.id.clone(), self.limits.timeout);
+            let result = self.code_call_with_budget(
+                &target.plugin_id,
+                invocation,
+                "validating the run target",
+                Some(cancel),
+                Some(timeout),
+                move |rt, _| {
+                    rt.validate_run_target(
+                        project_root.to_string_lossy().into_owned(),
+                        target_id.clone(),
+                        info.clone(),
+                        timeout,
+                    )
+                },
+            );
+            match result {
+                Ok(Ok(())) => {}
+                Ok(Err(message)) => return Err(IdeError::invalid(format!("{}: {message}", target.plugin_name))),
+                Err(error) if error.kind == ide_core::error::ErrorKind::Cancelled => return Err(error),
+                Err(error) => return Err(IdeError::unavailable(format!("{}: {error}", target.plugin_name))),
+            }
+            if cancel.is_cancelled() {
+                return Err(IdeError::cancelled());
+            }
+            self.program_for_project(&target.plugin_id, &target.target.program, Some(root))?;
+        }
+        Ok(wrapped)
     }
 }
 

crates/ide-host/src/project.rs

@@ -412,6 +412,7 @@ impl Host {
                 Box::new(move |batch| {
                     let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
                     let (ignored, ignored_gone) = ignored_changes(batch);
+                    index.ignore_rules_changed(&batch.ignore_rules);
                     index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
                     kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));
                     phpstan.files_removed(batch.removed.iter());
@@ -1309,6 +1310,7 @@ fn content_root_watcher(
         Box::new(move |batch| {
             let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
             let (ignored, ignored_gone) = ignored_changes(batch);
+            index.ignore_rules_changed(&batch.ignore_rules);
             index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
             // A workspace member's PHP language level follows its own composer.json.
             if composer_changed(&root, changed.iter().chain(&batch.removed)) {

crates/ide-host/src/rpc.rs

@@ -262,7 +262,7 @@ impl Dispatcher {
         .add("run_system_env", |_| async move { Ok(ide_run::system_env()) })
         .add("run_start", |c| async move {
             let on_output = c.channel("onOutput")?;
-            ops::run::start(&c.host, &c.window, c.arg("config")?, on_output).await
+            ops::run::start_request(&c.host, &c.window, c.arg("config")?, on_output, c.arg("request")?).await
         })
         .add("run_stop", |c| async move { ops::run::stop(&c.host, &c.window, c.arg("id")?) })
         .add("run_stdin", |c| async move { ops::run::stdin(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })

crates/ide-host/src/trust.rs

@@ -247,6 +247,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
             | "clipboard_has_files"
             | "clipboard_image"
             | "clipboard_set_file_list"
+            | "clipboard_write_text"
             | "jdk_download_vendors"
             | "jdk_download_releases"
             | "jdk_download_location"
@@ -454,3 +455,11 @@ impl TrustStore {
         Ok(TrustStatus { decided: trusted || state.restricted.contains(&root), root: root.into(), trusted })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn restricted_mode_allows_clipboard_write_text() {
+        assert!(super::restricted_command_allowed("clipboard_write_text"));
+    }
+}

crates/ide-host/tests/plugin_workbench.rs

@@ -352,3 +352,203 @@ async fn plugin_run_targets_register_prompt_route_revalidate_and_withdraw() {
     assert!(plugins.run_targets(&f.root).is_empty());
     plugins.shutdown();
 }
+
+#[cfg(unix)]
+#[tokio::test(flavor = "multi_thread")]
+async fn run_target_api15_overrides_and_frozen_api14_registration() {
+    use ide_host::plugins::{Consent, PluginHost};
+    use ide_plugin::{Invocation, Limits, PluginEngine};
+    use std::os::unix::fs::PermissionsExt;
+    let f = Harness::new();
+    f.host.set_project_trust(&f.root, true, false).await.unwrap();
+    let plugins = Arc::new(
+        PluginHost::new(f._tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
+    );
+    plugins.set_workspace(Some(Arc::new(f.workspace())));
+    f.host.set_plugin_host(&plugins);
+    let fixtures = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures");
+    let engine = PluginEngine::new().unwrap();
+    let legacy = engine.compile(&fixtures.join("run-target-api14/dist/plugin.wasm")).unwrap();
+    assert_eq!(engine.check_component(&legacy).unwrap().unwrap().to_string(), "1.4.0");
+    let tool = f._tmp.path().join("wrapper");
+    std::fs::write(&tool, "#!/bin/sh\nexit 0\n").unwrap();
+    std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
+    let invocation =
+        || Invocation { client: Some("main".into()), workspace_root: Some(f.root.clone()), ..Default::default() };
+    let config: ide_run::RunConfig = serde_json::from_value(serde_json::json!({
+        "id":"composer", "name":"Composer", "kind":"shell", "command":"composer", "args":["install"],
+        "env":{}, "detected":false, "isTest":false,
+    }))
+    .unwrap();
+    for (plugin, command) in [("run-target-api14", "target"), ("execution", "target-overrides")] {
+        plugins.install_from_dir(&fixtures.join(plugin), &Consent::all()).unwrap();
+        assert!(plugins.run_command(plugin, command, Some("empty"), invocation()).is_err());
+        plugins.choose_program(plugin, "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
+        let cases = if plugin == "execution" {
+            vec![
+                ("empty", vec!["composer", "install"]),
+                ("own", vec!["composer", "--working-dir=/container", "install"]),
+                ("inherit", vec!["composer", "--cwd=/container", "install"]),
+            ]
+        } else {
+            vec![("inherit", vec!["composer", "--cwd=/container", "install"])]
+        };
+        for (arg, expected) in cases {
+            plugins.run_command(plugin, command, Some(arg), invocation()).unwrap();
+            let target = plugins.run_targets(&f.root).into_iter().find(|t| t.plugin_id == plugin).unwrap();
+            let wrapped = plugins
+                .prepare_run_target_launch(
+                    &f.root,
+                    &target.id,
+                    &config,
+                    ide_plugin::RunTargetOperation::Run,
+                    &Default::default(),
+                )
+                .unwrap();
+            assert_eq!(wrapped.args, expected);
+            assert_eq!(PathBuf::from(wrapped.command), tool);
+            assert_eq!(wrapped.cwd.unwrap(), f.root);
+            let php = ide_run::RunConfig { command: "php".into(), args: vec!["x.php".into()], ..config.clone() };
+            assert_eq!(
+                plugins.prepare_run_target(&f.root, &target.id, &php).unwrap().args,
+                ["wrapped", "--cwd=/container", "php", "x.php"]
+            );
+        }
+        if plugin == "execution" {
+            assert!(plugins.run_command(plugin, command, Some("invalid"), invocation()).is_err());
+            // A failed replacement retains the previous valid registration.
+            assert_eq!(plugins.run_targets(&f.root).iter().filter(|t| t.plugin_id == plugin).count(), 1);
+        }
+        plugins.set_capability(plugin, "process:execution-tool", false).unwrap();
+        assert!(plugins.run_targets(&f.root).iter().all(|t| t.plugin_id != plugin));
+        assert!(plugins.run_command(plugin, command, None, invocation()).is_err());
+        plugins.choose_program(plugin, "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
+        f.host.set_project_trust(&f.root, false, false).await.unwrap();
+        assert!(plugins.run_command(plugin, command, None, invocation()).unwrap_err().to_string().contains("trusted"));
+        f.host.set_project_trust(&f.root, true, false).await.unwrap();
+    }
+    plugins.shutdown();
+}
+
+#[cfg(unix)]
+#[tokio::test(flavor = "multi_thread")]
+async fn run_target_validation_gates_launches_and_preserves_selection() {
+    use ide_host::plugins::{Consent, PluginHost};
+    use ide_plugin::{Invocation, Limits, RunTargetOperation};
+    use std::os::unix::fs::PermissionsExt;
+    use std::time::Duration;
+    let f = Harness::new();
+    f.host.set_project_trust(&f.root, true, false).await.unwrap();
+    let plugins = Arc::new(
+        PluginHost::new(
+            f._tmp.path().join("plugins"),
+            Arc::new(|_: Option<&str>, _| {}),
+            Limits {
+                timeout: Duration::from_millis(200),
+                idle_timeout: Some(Duration::from_millis(20)),
+                restart_backoff: Duration::ZERO,
+                ..Default::default()
+            },
+        )
+        .unwrap(),
+    );
+    plugins.set_workspace(Some(Arc::new(f.workspace())));
+    f.host.set_plugin_host(&plugins);
+    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/execution");
+    plugins.install_from_dir(&fixture, &Consent::all()).unwrap();
+    let tool = f._tmp.path().join("wrapper");
+    std::fs::write(&tool, "#!/bin/sh\ntouch spawned\n").unwrap();
+    std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
+    plugins.choose_program("execution", "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
+    let invocation =
+        || Invocation { client: Some("main".into()), workspace_root: Some(f.root.clone()), ..Default::default() };
+    let config: ide_run::RunConfig = serde_json::from_value(serde_json::json!({
+        "id":"composer", "name":"Composer", "kind":"shell", "command":"/tools/composer", "args":["install"],
+        "env":{"SECRET":"not sent"}, "detected":false, "isTest":false,
+    }))
+    .unwrap();
+    for id in ["allow", "refuse", "long-refusal", "timeout", "trap"] {
+        plugins.run_command("execution", "target", Some(id), invocation()).unwrap();
+    }
+    let targets = plugins.run_targets(&f.root);
+    let id = |name: &str| targets.iter().find(|t| t.target.id == name).unwrap().id.clone();
+    for operation in [RunTargetOperation::Run, RunTargetOperation::Test, RunTargetOperation::Debug] {
+        plugins.prepare_run_target_launch(&f.root, &id("allow"), &config, operation, &Default::default()).unwrap();
+        let snapshot = plugins.run_command("execution", "validation", None, invocation()).unwrap().unwrap();
+        assert_eq!(snapshot, format!("{}|allow|{operation:?}|composer|{}", f.root.display(), f.root.display()));
+    }
+    tokio::time::sleep(Duration::from_millis(30)).await;
+    plugins.tick();
+    assert_eq!(plugins.info_of("execution").unwrap().status, ide_host::plugins::PluginStatus::Inactive);
+    plugins
+        .prepare_run_target_launch(&f.root, &id("allow"), &config, RunTargetOperation::Run, &Default::default())
+        .unwrap();
+    assert!(plugins.info_of("execution").unwrap().stats.reclaims > 0);
+    // Non-launch consumers (LSP and document reads) do not invoke validation.
+    assert!(plugins.prepare_run_target(&f.root, &id("refuse"), &config).is_ok());
+    let selected = id("refuse");
+    ide_host::plugins::run_targets::answer(&f.host, &plugins, "main", &selected, true).unwrap();
+    for is_test in [false, true] {
+        let mut config = config.clone();
+        config.is_test = is_test;
+        config.extras.target = Some(selected.clone());
+        let error = ide_host::ops::run::start(&f.host, "main", config, Arc::new(|_| {})).await.unwrap_err();
+        assert!(error.message.contains("Plugin execution tests: Project runtime is stopped"), "{error}");
+        assert!(f.host.processes.list().is_empty());
+        assert!(!f.root.join("spawned").exists());
+        assert_eq!(f.host.project("main").unwrap().settings.effective().run.default_target, selected);
+        assert_eq!(plugins.run_targets(&f.root).len(), targets.len());
+    }
+    for adapter in ["php-debug", "debugpy"] {
+        let launch = ide_dap::LaunchConfig {
+            name: "Refused debug".into(),
+            adapter: adapter.into(),
+            request: "launch".into(),
+            program: Some("app.php".into()),
+            args: Vec::new(),
+            cwd: Some(f.root.clone().into()),
+            env: Default::default(),
+            extra_json: Some(serde_json::json!({"__runTarget":selected, "__runTargetProgram":"php"}).to_string()),
+        };
+        let error = ide_host::ops::debug::debug_start(&f.host, "main", launch).await.unwrap_err();
+        assert!(error.message.contains("Project runtime is stopped"), "{adapter}: {error}");
+        assert!(f.host.debugger.sessions(None).is_empty());
+    }
+    let error = plugins
+        .prepare_run_target_launch(&f.root, &id("long-refusal"), &config, RunTargetOperation::Run, &Default::default())
+        .unwrap_err();
+    assert!(error.message.len() < 4200);
+    let request = ide_core::RequestId(2408);
+    let mut cfg = config.clone();
+    cfg.extras.target = Some(id("timeout"));
+    let worker = f.host.clone();
+    let pending = tokio::spawn(async move {
+        ide_host::ops::run::start_request(&worker, "main", cfg, Arc::new(|_| {}), Some(request)).await
+    });
+    tokio::time::sleep(Duration::from_millis(30)).await;
+    f.host.cancel_request(request);
+    assert_eq!(pending.await.unwrap().unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);
+    for name in ["timeout", "trap"] {
+        let started = std::time::Instant::now();
+        let error = plugins
+            .prepare_run_target_launch(&f.root, &id(name), &config, RunTargetOperation::Run, &Default::default())
+            .unwrap_err();
+        assert!(error.message.contains("Plugin execution tests"), "{error}");
+        if name == "timeout" {
+            assert!(error.message.contains("timed out"), "{error}");
+            assert!(started.elapsed() < Duration::from_secs(2), "background tasks must not extend validation");
+        }
+        assert!(f.host.processes.list().is_empty());
+    }
+    // A cancelled launch never enters the wrapper.
+    let cancel = ide_core::CancellationToken::new();
+    cancel.cancel();
+    assert_eq!(
+        plugins
+            .prepare_run_target_launch(&f.root, &id("allow"), &config, RunTargetOperation::Run, &cancel)
+            .unwrap_err()
+            .kind,
+        ide_core::error::ErrorKind::Cancelled
+    );
+    plugins.shutdown();
+}

crates/ide-host/tests/plugins.rs

@@ -3694,31 +3694,6 @@ fn listing_while_projects_change_does_not_deadlock() {
     }
 }
 
-/// Excalidraw: a web custom editor beside the text editor, with its fonts,
-/// file icon, template and language — no code.
-#[test]
-fn official_excalidraw_installs_and_serves_its_page() {
-    let tmp = tempfile::tempdir().unwrap();
-    let pkg = with_stand_in_page(&official("excalidraw"), tmp.path());
-    let f = fixture(Limits::default());
-    let info = f.install(&pkg);
-    assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
-    let page = f.host.web_page("openidea.excalidraw", "canvas").unwrap();
-    let (rev, entry) = page.path.strip_prefix("openidea.excalidraw/").unwrap().split_once('/').unwrap();
-    assert_eq!(entry, "web/index.html");
-    let html = f.host.web_file("openidea.excalidraw", &format!("{rev}/{entry}")).unwrap();
-    let html = String::from_utf8(html.bytes).unwrap();
-    // Relative URLs only: the page is served from the package.
-    let script = html.split("src=\"").nth(1).unwrap().split('"').next().unwrap();
-    assert!(script.starts_with("./assets/"), "{script}");
-    assert!(f.host.web_file("openidea.excalidraw", &format!("{rev}/web/{}", &script[2..])).is_ok());
-    let font = f.host.web_file("openidea.excalidraw", &format!("{rev}/web/fonts/Virgil/Virgil-Regular.woff2")).unwrap();
-    assert_eq!(font.mime, "font/woff2");
-    assert_eq!(f.host.ui_items("customEditors")[0].decl["layout"], "preview");
-    assert!(f.host.languages().iter().any(|l| l.id.as_str() == "excalidraw"));
-    assert_eq!(f.host.assets("openidea.excalidraw", "fileIcon/excalidraw/").unwrap().len(), 2);
-}
-
 /// A copy of the official plugin at `src` in `dir`, with a stand-in for its
 /// built page (`web/` is built by plugins/build.sh, not checked in; build.sh
 /// checks what the build produces): an entry loading a script and a font by
@@ -3760,7 +3735,18 @@ fn official_graphviz_turns_its_pages_reports_into_problems() {
     assert_eq!(info.status, PluginStatus::Inactive, "{:?}", info.error);
     assert_eq!(f.host.ui_items("customEditors")[0].decl["layout"], "split");
     assert!(f.host.languages().iter().any(|l| l.id.as_str() == "dot"));
-    assert!(f.host.web_page("openidea.graphviz", "preview").is_ok());
+    assert_eq!(f.host.assets("openidea.graphviz", "fileIcon/graphviz/").unwrap().len(), 2);
+    let page = f.host.web_page("openidea.graphviz", "preview").unwrap();
+    let (rev, entry) = page.path.strip_prefix("openidea.graphviz/").unwrap().split_once('/').unwrap();
+    assert_eq!(entry, "web/index.html");
+    let html = f.host.web_file("openidea.graphviz", &format!("{rev}/{entry}")).unwrap();
+    let html = String::from_utf8(html.bytes).unwrap();
+    // Relative URLs only: the page is served from the package.
+    let script = html.split("src=\"").nth(1).unwrap().split('"').next().unwrap();
+    assert!(script.starts_with("./assets/"), "{script}");
+    assert!(f.host.web_file("openidea.graphviz", &format!("{rev}/web/{}", &script[2..])).is_ok());
+    let font = f.host.web_file("openidea.graphviz", &format!("{rev}/web/fonts/Virgil/Virgil-Regular.woff2")).unwrap();
+    assert_eq!(font.mime, "font/woff2");
 
     std::fs::write(f.project.join("flow.dot"), "digraph {\n  a -> \n}\n").unwrap();
     let editor = f.workspace.open("flow.dot", &[]);

crates/ide-host/tests/remote_plugins.rs

@@ -548,7 +548,7 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     let bin = tmp.path().join("bin");
     std::fs::create_dir(&bin).unwrap();
     let executable = bin.join("execution-tool");
-    std::fs::write(&executable, "#!/bin/sh\nif [ \"$1\" = wrapped ]; then printf '<%s>\\n' \"$@\" > \"$PWD/wrapped.txt\"; exit; fi\nread line\nprintf '%s\\n' \"$line\"\n").unwrap();
+    std::fs::write(&executable, "#!/bin/sh\nif [ \"$1\" = wrapped ]; then printf '<%s>\\n' \"$@\" > \"$PWD/wrapped.txt\"; exit; fi\nif [ \"$1\" = composer ]; then printf '<%s>\\n' \"$@\" > \"$PWD/composer.txt\"; exit; fi\nread line\nprintf '%s\\n' \"$line\"\n").unwrap();
     std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755)).unwrap();
     let path_var = {
         let bin = bin.clone();
@@ -599,9 +599,17 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     )
     .await
     .unwrap();
+    invoke(
+        &peer,
+        "plugin_run_command",
+        json!({"pluginId":"execution", "commandId":"target-overrides", "arg":"empty", "editor":null}),
+    )
+    .await
+    .unwrap();
     let targets = invoke(&peer, "plugin_run_targets", json!({})).await.unwrap();
     assert_eq!(targets.as_array().unwrap().len(), 1);
     assert_eq!(targets[0]["pluginId"], "execution");
+    assert_eq!(targets[0]["target"]["commands"][0]["workdirArgs"], json!([]));
     assert!(desktop.run_targets(&project).is_empty());
     let id = targets[0]["id"].as_str().unwrap();
     let settings = invoke(&peer, "plugin_answer_run_target", json!({"id":id, "useTarget":false})).await.unwrap();
@@ -614,6 +622,10 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
         "<wrapped>\n<--cwd=/container>\n<php>\n<x.php>\n<literal ; $(touch bad)>\n"
     );
     assert!(!project.join("bad").exists());
+    let composer = json!({"id":"composer", "name":"Composer", "kind":"shell", "command":"composer", "args":["install"], "env":{}, "detected":false, "isTest":false, "target":id});
+    invoke(&peer, "run_start", json!({"config":composer, "onOutput":{"$channel":39}})).await.unwrap();
+    until("remote composer override", 5, || project.join("composer.txt").exists()).await;
+    assert_eq!(std::fs::read_to_string(project.join("composer.txt")).unwrap(), "<composer>\n<install>\n");
     invoke(
         &peer,
         "plugin_run_command",
@@ -622,6 +634,28 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     .await
     .unwrap();
     assert_eq!(invoke(&peer, "plugin_run_targets", json!({})).await.unwrap(), json!([]));
+    invoke(
+        &peer,
+        "plugin_run_command",
+        json!({"pluginId":"execution", "commandId":"target", "arg":"refuse", "editor":null}),
+    )
+    .await
+    .unwrap();
+    let targets = invoke(&peer, "plugin_run_targets", json!({})).await.unwrap();
+    let refused = targets[0]["id"].as_str().unwrap();
+    std::fs::remove_file(project.join("wrapped.txt")).unwrap();
+    let config = json!({"id":"refused", "name":"Refused", "kind":"shell", "command":"php", "args":[], "env":{}, "detected":false, "isTest":false, "target":refused});
+    let error = invoke(&peer, "run_start", json!({"config":config, "onOutput":{"$channel":40}})).await.unwrap_err();
+    assert!(error.to_string().contains("Project runtime is stopped"), "{error}");
+    assert!(!project.join("wrapped.txt").exists());
+    assert!(desktop.run_targets(&project).is_empty());
+    invoke(
+        &peer,
+        "plugin_run_command",
+        json!({"pluginId":"execution", "commandId":"untarget", "arg":"refuse", "editor":null}),
+    )
+    .await
+    .unwrap();
     client.plugin_events.lock().clear();
     client.events.lock().clear();
     let runner = peer.clone();

crates/ide-host/tests/trust.rs

@@ -48,6 +48,7 @@ async fn application_commands_work_in_restricted_projects_and_without_a_project(
         "clipboard_has_files",
         "clipboard_image",
         "clipboard_set_file_list",
+        "clipboard_write_text",
         "jdk_download_vendors",
         "jdk_download_releases",
         "jdk_download_location",

crates/ide-host/tests/workspace_edits.rs

@@ -197,6 +197,8 @@ async fn code_actions_skip_a_command_no_server_provides_after_their_edit() {
     let info = ops::doc::open(&host, "main", file.clone()).await.unwrap();
     // Optimize Imports as vtsls offers it: the edit, then a command its client runs itself.
     let action = |edit: bool| CodeAction {
+        diagnostics: Vec::new(),
+        original_diagnostics: None,
         title: "Organize Imports".into(),
         kind: Some("source.organizeImports".into()),
         is_preferred: false,

crates/ide-index/src/filter.rs

@@ -138,6 +138,10 @@ impl PathFilter {
         &self.config.0 == extra_roots && self.config.1 == excludes
     }
 
+    pub(crate) fn reload(&self) -> Self {
+        Self::new(&self.root, &self.config.0, &self.config.1)
+    }
+
     pub(crate) fn root(&self) -> &Path {
         &self.root
     }

crates/ide-index/src/lib.rs

@@ -332,6 +332,28 @@ impl ProjectIndex {
         }
     }
 
+    /// Refreshes ignore matchers and indexed entries in the affected subtrees.
+    pub fn ignore_rules_changed(&self, dirs: &[PathBuf]) {
+        let filter = self.shared.filter();
+        let mut affected = Vec::new();
+        for dir in dirs {
+            let path = if dir.is_absolute() { dir.clone() } else { self.root.join(dir) };
+            let path = dunce::canonicalize(&path).unwrap_or(path);
+            for root in filter.roots() {
+                if path.starts_with(root) {
+                    affected.push(path.clone());
+                    break;
+                }
+                if root.starts_with(&path) {
+                    affected.push(root.to_path_buf());
+                }
+            }
+        }
+        if !affected.is_empty() {
+            self.shared.enqueue(Job::IgnoreRules(affected));
+        }
+    }
+
     /// Boost for "recent files" ranking.
     /// Records a recently opened file; a virtual document's URI (library
     /// class) is kept verbatim, like IDEA lists library classes in Recent Files.

crates/ide-index/src/tests.rs

@@ -750,3 +750,66 @@ fn persisted_symbols_do_not_load_through_escaping_symlink_ancestors() {
     assert!(symbols(&idx, "old_symbol", SymbolFilter::All).is_empty());
     assert_eq!(initial.lock()[0], 0, "unsafe cached symbols must never be published");
 }
+
+#[test]
+fn rule_changes_refresh_only_the_affected_index_subtree() {
+    for (rule, subtree) in [(".git/info/exclude", ""), ("sub/.gitignore", "sub"), ("sub/.ignore", "sub")] {
+        let fx = Fixture::new(&[
+            (".git/HEAD", "ref: refs/heads/main\n"),
+            ("sub/generated/file.ts", "export function generated() {}\n"),
+            ("sub/local.ts", "export function localOnly() {}\n"),
+            ("other/keep.ts", "export function keep() {}\n"),
+        ]);
+        fx.write(rule, "");
+        let idx = fx.open();
+        assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
+        fx.write(rule, "generated/\nlocal.ts\n");
+        let dirs = [fx.root.join(subtree)];
+        idx.ignore_rules_changed(&dirs);
+        assert!(idx.wait_idle(WAIT));
+        assert!(files(&idx, "file.ts").is_empty(), "{rule}: ignored directory remained indexed");
+        assert_eq!(files(&idx, "local.ts"), ["sub/local.ts"]);
+        assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
+        assert_eq!(files(&idx, "keep.ts"), ["other/keep.ts"]);
+
+        fx.write(rule, "");
+        idx.ignore_rules_changed(&dirs);
+        assert!(idx.wait_idle(WAIT));
+        assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
+        assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
+        // The cached root matcher must also follow the rules for later watcher updates.
+        let fresh = fx.write("sub/generated/new.ts", "export function fresh() {}\n");
+        idx.update(&[fresh], &[]);
+        assert!(idx.wait_idle(WAIT));
+        assert_eq!(files(&idx, "new.ts"), ["sub/generated/new.ts"]);
+    }
+}
+
+#[test]
+fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
+    let fx = Fixture::new(&[
+        (".git/HEAD", "ref: refs/heads/main\n"),
+        (".git/info/exclude", ""),
+        ("member/generated/item.txt", "x"),
+    ]);
+    let idx = ProjectIndex::open(
+        &fx.root,
+        &fx.cache,
+        IndexRoots { include_root: false, folders: vec![fx.root.join("member")] },
+        vec![],
+        Arc::new(LanguageRegistry::load(None).unwrap()),
+        Arc::new(Syntax::new()),
+        Arc::new(NullSink),
+    )
+    .unwrap();
+    assert!(idx.wait_idle(WAIT));
+    assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
+    fx.write(".git/info/exclude", "generated/\n");
+    idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
+    assert!(idx.wait_idle(WAIT));
+    assert!(files(&idx, "item.txt").is_empty());
+    fx.write(".git/info/exclude", "");
+    idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
+    assert!(idx.wait_idle(WAIT));
+    assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
+}

crates/ide-index/src/worker.rs

@@ -26,6 +26,7 @@ pub(crate) enum Job {
     SaveRecent,
     /// The roots or excludes changed: scan again (unchanged files are kept).
     Rescan,
+    IgnoreRules(Vec<PathBuf>),
     /// File types changed: re-parse the indexed files whose language under the
     /// previous registry differs from the current one.
     Reparse(std::sync::Arc<LanguageRegistry>),
@@ -212,6 +213,10 @@ impl Shared {
     }
 
     fn full_scan(&self) {
+        self.scan(None);
+    }
+
+    fn scan(&self, dirs: Option<&[PathBuf]>) {
         let started = Instant::now();
         self.indexing.store(true, Ordering::SeqCst);
         self.emit_state();
@@ -227,7 +232,11 @@ impl Shared {
 
         let filter = self.filter();
         let mut found = Vec::new();
-        for root in filter.roots() {
+        let roots: Vec<&Path> = match dirs {
+            Some(dirs) => dirs.iter().map(PathBuf::as_path).collect(),
+            None => filter.roots().collect(),
+        };
+        for root in roots {
             found.extend(filter.walk(root, &self.cancelled));
         }
         if self.is_cancelled() {
@@ -237,7 +246,12 @@ impl Shared {
         let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
             let d = self.data.read();
             let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
-            let stale = d.paths().filter(|p| !seen.contains(p.as_path())).cloned().collect();
+            let stale = d
+                .paths()
+                .filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
+                .filter(|p| !seen.contains(p.as_path()))
+                .cloned()
+                .collect();
             (todo, stale)
         };
         if !stale.is_empty() {
@@ -381,6 +395,7 @@ impl Shared {
         let mut removed: Vec<PathBuf> = Vec::new();
         let mut save_recent = false;
         let mut rescan = false;
+        let mut rule_dirs = Vec::new();
         let mut reparse: Vec<std::sync::Arc<LanguageRegistry>> = Vec::new();
         for job in jobs {
             match job {
@@ -388,9 +403,29 @@ impl Shared {
                 Job::Removed(p) => removed.extend(p),
                 Job::SaveRecent => save_recent = true,
                 Job::Rescan => rescan = true,
+                Job::IgnoreRules(dirs) => rule_dirs.extend(dirs),
                 Job::Reparse(before) => reparse.push(before),
             }
         }
+        if !rule_dirs.is_empty() {
+            {
+                let mut filter = self.filter.write();
+                *filter = std::sync::Arc::new(filter.reload());
+            }
+            rule_dirs.sort();
+            rule_dirs.dedup();
+            let mut roots: Vec<PathBuf> = Vec::new();
+            for dir in rule_dirs {
+                if !roots.iter().any(|root| dir.starts_with(root)) {
+                    roots.push(dir);
+                }
+            }
+            if !rescan {
+                self.scan(Some(&roots));
+                changed.retain(|p| !roots.iter().any(|root| p.starts_with(root)));
+                removed.retain(|p| !roots.iter().any(|root| p.starts_with(root)));
+            }
+        }
         if rescan {
             // The scan also picks up whatever `changed` / `removed` reported.
             self.full_scan();

crates/ide-language/src/lib.rs

@@ -14,7 +14,7 @@ mod markers;
 pub mod plugin_point;
 mod registry;
 mod syntax;
-pub use markers::marked_root;
+pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root};
 pub use plugin_point::PluginLanguages;
 pub use registry::{FileTypes, LanguageRegistry};
 pub use syntax::{

crates/ide-language/src/markers.rs

@@ -19,6 +19,27 @@ pub fn marked_root(project_root: Option<&Path>, file: &Path, markers: &[String])
     best
 }
 
+/// `dir` contains at least one `.ino` regular file.
+pub fn is_arduino_sketch_dir(dir: &Path) -> bool {
+    std::fs::read_dir(dir).is_ok_and(|entries| {
+        entries.flatten().any(|entry| {
+            entry.path().extension().is_some_and(|ext| ext.eq_ignore_ascii_case("ino"))
+                && entry.file_type().is_ok_and(|kind| kind.is_file())
+        })
+    })
+}
+
+/// Nearest enclosing directory of `path` (including `path` when it is already a
+/// directory) within `project` that contains a `.ino` file.
+pub fn arduino_sketch_root(project: &Path, path: &Path) -> Option<PathBuf> {
+    let start = usize::from(!path.is_dir());
+    path.ancestors()
+        .skip(start)
+        .take_while(|dir| dir.starts_with(project))
+        .find(|dir| is_arduino_sketch_dir(dir))
+        .map(Path::to_path_buf)
+}
+
 /// `dir` contains `marker`: a relative path, a file name pattern with one
 /// `*` (`*.csproj`), or a TOML file name (no pattern) and a dotted table it
 /// must contain (`pyproject.toml#tool.ruff`).

crates/ide-language/src/registry.rs

@@ -70,6 +70,7 @@ const BUILTIN: &[(&str, &str)] = &[
     ("proto", include_str!("../../../languages/proto.toml")),
     ("python", include_str!("../../../languages/python.toml")),
     ("r", include_str!("../../../languages/r.toml")),
+    ("restructuredtext", include_str!("../../../languages/restructuredtext.toml")),
     ("ruby", include_str!("../../../languages/ruby.toml")),
     ("rust", include_str!("../../../languages/rust.toml")),
     ("sass", include_str!("../../../languages/sass.toml")),
@@ -562,6 +563,7 @@ mod tests {
         "R",
         "RPM Changes",
         "RPM Spec",
+        "reStructuredText",
         "Ruby",
         "SAS",
         "Scala",
@@ -628,6 +630,12 @@ mod tests {
         let asciidoc = reg.get(&LanguageId::new("asciidoc")).unwrap();
         assert_eq!(asciidoc.ui_mode.as_deref(), Some("AsciiDoc"));
         assert_eq!(asciidoc.line_comment.as_deref(), Some("//"));
+        for path in ["guide.rst", "README.RST"] {
+            assert_eq!(detect(&reg, path), "restructuredtext");
+        }
+        let rst = reg.get(&LanguageId::new("restructuredtext")).unwrap();
+        assert_eq!(rst.ui_mode.as_deref(), Some("reStructuredText"));
+        assert_eq!(rst.line_comment.as_deref(), Some(".."));
         assert_eq!(reg.detect(Path::new("script"), Some("#!/usr/bin/env python3")).as_str(), "python");
         assert_eq!(detect(&reg, "README"), "plaintext");
         assert_eq!(detect(&reg, "unknown.zzz"), "plaintext");
@@ -999,11 +1007,11 @@ mod tests {
     }
 
     #[test]
-    fn astro_server_reads_the_project_typescript() {
+    fn astro_server_leaves_typescript_sdk_resolution_to_the_launcher() {
         let reg = reg();
         let ls = &reg.get(&LanguageId::new("astro")).unwrap().language_servers[0];
         let tsdk = ls.initialization_options.as_ref().and_then(|o| o.get("typescript")?.get("tsdk")?.as_str());
-        assert_eq!(tsdk, Some("node_modules/typescript/lib"));
+        assert_eq!(tsdk, None);
     }
 
     #[test]

crates/ide-language/src/syntax/cache.rs

@@ -206,6 +206,7 @@ impl SyntaxCache {
                 // their trees join the cache.
                 .or_else(|| self.syntax.web_outline(lang, text))
                 .or_else(|| super::external::outline(lang, text))
+                .or_else(|| self.syntax.builtin_outline(lang, text))
             },
         )
     }

crates/ide-language/src/syntax/mod.rs

@@ -9,6 +9,7 @@ mod highlight;
 pub(crate) mod lines;
 mod literals;
 mod outline;
+mod rst;
 mod selection;
 mod sfc;
 mod web;
@@ -177,9 +178,15 @@ impl Syntax {
             let query = g.outline_query()?;
             Some(outline::outline(g, query, tree, text))
         })
+        .or_else(|| self.builtin_outline(lang, text))
         .unwrap_or_default()
     }
 
+    /// Outline for languages without a grammar that have a built-in parser.
+    fn builtin_outline(&self, lang: &LanguageId, text: &str) -> Option<Vec<OutlineItem>> {
+        (lang.as_str() == "restructuredtext" && text.len() <= MAX_PARSE_BYTES).then(|| rst::outline(text))
+    }
+
     /// Outline of an HTML container document (html, vue, svelte, jsp): `None`
     /// for every other language, CSS containers included.
     pub(crate) fn web_outline(&self, lang: &LanguageId, text: &str) -> Option<Vec<OutlineItem>> {

crates/ide-language/src/syntax/rst.rs

@@ -0,0 +1,131 @@
+//! reStructuredText section titles for the outline. No bundled grammar nests
+//! sections (tree-sitter-rst emits them flat), so levels follow docutils: each
+//! adornment style (character, with or without overline) takes the next level
+//! the first time it appears.
+
+use super::lines::LineIndex;
+use ide_core::{OutlineItem, SymbolKind};
+
+struct Line<'a> {
+    start: usize,
+    text: &'a str,
+}
+
+struct Heading {
+    level: usize,
+    start: usize,
+    end: usize,
+    name_start: usize,
+    name_end: usize,
+}
+
+pub(crate) fn outline(text: &str) -> Vec<OutlineItem> {
+    let lines: Vec<Line> = text
+        .split_inclusive('\n')
+        .scan(0, |at, raw| {
+            let start = *at;
+            *at += raw.len();
+            Some(Line { start, text: raw.trim_end_matches(['\n', '\r']) })
+        })
+        .collect();
+    let mut heads = headings(&lines);
+    for k in 0..heads.len() {
+        let end = heads[k + 1..].iter().find(|h| h.level <= heads[k].level).map_or(text.len(), |h| h.start);
+        heads[k].end = heads[k].start + text[heads[k].start..end].trim_end().len();
+    }
+    let index = LineIndex::new(text);
+    let mut i = 0;
+    nest(&heads, &mut i, None, text, &index)
+}
+
+fn headings(lines: &[Line]) -> Vec<Heading> {
+    let mut styles: Vec<(char, bool)> = Vec::new();
+    let mut out = Vec::new();
+    let mut push = |style: (char, bool), start: usize, title: &Line| {
+        let level = styles.iter().position(|&s| s == style).unwrap_or_else(|| {
+            styles.push(style);
+            styles.len() - 1
+        });
+        let name = title.text.trim();
+        let name_start = title.start + (title.text.len() - title.text.trim_start().len());
+        out.push(Heading { level, start, end: 0, name_start, name_end: name_start + name.len() });
+    };
+    // A title starts a new block: it follows a blank line, the start, or another title.
+    let mut at_block_start = true;
+    let mut i = 0;
+    while i < lines.len() {
+        let line = &lines[i];
+        if line.text.trim().is_empty() {
+            at_block_start = true;
+            i += 1;
+            continue;
+        }
+        if at_block_start {
+            if let Some(over) = adornment(line.text) {
+                if let [title, under, ..] = &lines[i + 1..]
+                    && !title.text.trim().is_empty()
+                    && adornment(title.text).is_none()
+                    && adornment(under.text) == Some(over)
+                    && fits(title.text.trim_end(), over.1)
+                {
+                    push((over.0, true), line.start, title);
+                    i += 3;
+                    continue;
+                }
+            } else if !line.text.starts_with([' ', '\t'])
+                && !starts_body_element(line.text)
+                && let Some(under) = lines.get(i + 1).and_then(|l| adornment(l.text))
+                && fits(line.text.trim_end(), under.1)
+            {
+                push((under.0, false), line.start, line);
+                i += 2;
+                continue;
+            }
+        }
+        // Indented lines (literal blocks after `::`, directive bodies, quotes)
+        // never hold titles: they are skipped here because adornments and
+        // underlined titles must start in column 0.
+        at_block_start = false;
+        i += 1;
+    }
+    out
+}
+
+/// `(character, length)` of a line made of one repeated ASCII punctuation character.
+fn adornment(line: &str) -> Option<(char, usize)> {
+    let line = line.trim_end();
+    let c = line.chars().next().filter(char::is_ascii_punctuation)?;
+    line.chars().all(|x| x == c).then_some((c, line.len()))
+}
+
+/// docutils accepts a short adornment (with a warning) unless it is shorter
+/// than 4 characters, which reads as ordinary text instead.
+// ponytail: counts chars, not display columns; wide CJK titles get a looser check.
+fn fits(title: &str, adornment_len: usize) -> bool {
+    adornment_len >= title.chars().count() || adornment_len >= 4
+}
+
+/// Lines docutils parses as another body element before trying a title:
+/// explicit markup (`..`, `__`), bullets, field lists, doctests, line blocks.
+fn starts_body_element(line: &str) -> bool {
+    let marker = |m: &str| line == m || line.strip_prefix(m).is_some_and(|r| r.starts_with(' '));
+    ["..", "__", "-", "*", "+", "•", ">>>", "|"].into_iter().any(marker)
+        || (line.starts_with(':') && line[1..].find(':').is_some_and(|k| k > 0 && marker(&line[..k + 2])))
+}
+
+fn nest(heads: &[Heading], i: &mut usize, parent: Option<usize>, text: &str, index: &LineIndex) -> Vec<OutlineItem> {
+    let mut items = Vec::new();
+    while let Some(h) = heads.get(*i).filter(|h| parent.is_none_or(|p| h.level > p)) {
+        *i += 1;
+        items.push(OutlineItem {
+            name: text[h.name_start..h.name_end].to_owned(),
+            detail: None,
+            kind: SymbolKind::Key,
+            range: index.range(h.start, h.end),
+            selection_range: index.range(h.name_start, h.name_end),
+            children: nest(heads, i, Some(h.level), text, index),
+            visibility: None,
+        });
+    }
+    items
+}

crates/ide-language/src/syntax/tests.rs

@@ -1638,3 +1638,91 @@ fn script_outlines_compose_positions_across_multiple_blocks() {
 fn script_outline_attaches_to_case_insensitive_html_tags() {
     check_outline("html", "<SCRIPT>function boot() {}</SCRIPT>", "Field SCRIPT\n  Function boot");
 }
+
+#[test]
+fn outline_restructuredtext_levels_follow_first_use_of_each_adornment() {
+    let src = "\
+=========
+ Project
+=========
+
+Install
+~~~~~~~
+
+From source
+-----------
+
+Literal block::
+
+    Not a title
+    -----------
+
+Intro
+--
+
+A paragraph
+with a line
+------------
+
+.. comment
+-----------
+
+Usage
+~~~~~
+
+.. note::
+
+   Indented
+   --------
+
+Short underline, still a title
+------
+
+Underline only
+==============
+";
+    check_outline(
+        "restructuredtext",
+        src,
+        "
+        Key Project
+          Key Install
+            Key From source
+          Key Usage
+            Key Short underline, still a title
+              Key Underline only
+        ",
+    );
+    let items = syntax().outline(&lang("restructuredtext"), src);
+    let project = &items[0];
+    assert_eq!(project.range.start, Pos::new(0, 0));
+    assert_eq!((project.selection_range.start, project.selection_range.end), (Pos::new(1, 1), Pos::new(1, 8)));
+    let install = &project.children[0];
+    assert_eq!((install.range.start, install.range.end), (Pos::new(4, 0), Pos::new(23, 11)));
+    assert!(syntax().outline(&lang("restructuredtext"), "Title\n\n").is_empty());
+}
+
+#[test]
+fn outline_restructuredtext_unicode_crlf_and_cached_edits() {
+    use ide_core::DocId;
+    use std::sync::Arc;
+
+    let src = "=========\r\n 中文😀\r\n=========\r\n\r\n子章节\r\n------\r\n\r\nBody\r\n\r\nOther\r\n------\r\n";
+    let id = DocId::next();
+    let language = lang("restructuredtext");
+    let cache = SyntaxCache::new(Arc::new(Syntax::new()));
+    cache.open(id, &language, 0);
+    let items = cache.outline(id, &language, 0, src);
+    assert_eq!(items, syntax().outline(&language, src));
+    assert_eq!(items[0].name, "中文😀");
+    assert_eq!(items[0].selection_range, Range::new(Pos::new(1, 1), Pos::new(1, 5)));
+    assert_eq!(items[0].children[0].name, "子章节");
+    assert_eq!(items[0].children[0].selection_range, Range::new(Pos::new(4, 0), Pos::new(4, 3)));
+    assert_eq!(items[0].children[0].range.end, Pos::new(7, 4));
+    assert_eq!(items[0].children[1].name, "Other");
+    let edited = src.replace("子章节", "新章节😀");
+    let updated = cache.outline(id, &language, 1, &edited);
+    assert_eq!(updated, syntax().outline(&language, &edited));
+    assert_eq!(updated[0].children[0].selection_range.end, Pos::new(4, 5));
+    assert_ne!(items, updated);
+}

crates/ide-lsp/src/arduino.rs

@@ -0,0 +1,210 @@
+//! Arduino sketches need their own board context, including their C/C++ sources.
+
+use crate::LspManager;
+use crate::server::Server;
+use ide_core::{LanguageId, Location};
+use serde_json::Value;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+pub(crate) const SERVER: &str = "arduino-language-server";
+
+pub(crate) fn sketch_root(project: &Path, file: &Path) -> Option<PathBuf> {
+    ide_language::arduino_sketch_root(project, file)
+}
+
+pub(crate) fn configure_client_capabilities(capabilities: &mut Value) {
+    // Arduino's proxy cannot decode the boolean full form, panics on inlayHint (#225),
+    // and cannot handle clangd's semanticTokens refresh request (#125).
+    for section in ["textDocument", "workspace"] {
+        if let Some(section) = capabilities[section].as_object_mut() {
+            section.remove("semanticTokens");
+            section.remove("inlayHint");
+        }
+    }
+    // ALS uses go.bug.st/lsp (LSP 3.14) which requires a `range` field on `lsp.TextEdit`.
+    // Clangd returns `InsertReplaceEdit` (`insert` + `replace`) when `insertReplaceSupport` is advertised,
+    // causing ALS to drop the connection with "json: undefined required field range into lsp.TextEdit".
+    if let Some(completion) = capabilities.get_mut("textDocument").and_then(|t| t.get_mut("completion"))
+        && let Some(item) = completion.get_mut("completionItem").and_then(|c| c.as_object_mut())
+    {
+        item.remove("insertReplaceSupport");
+    }
+}
+
+pub(crate) fn sanitize_server_capabilities(capabilities: &mut Value) {
+    // Arduino Language Server's request dispatcher advertises documentSymbol and
+    // workspaceSymbol, but panics with "not implemented" / "unimplemented" when called.
+    // Tree-sitter handles C++ outline/symbols in OpenIDEA without hitting ALS.
+    if let Some(obj) = capabilities.as_object_mut() {
+        obj.remove("documentSymbolProvider");
+        obj.remove("workspaceSymbolProvider");
+    }
+}
+
+impl LspManager {
+    pub(crate) fn arduino_servers(&self, language: &LanguageId, path: &Path) -> Option<Vec<Arc<Server>>> {
+        if !matches!(language.as_str(), "c" | "cpp") {
+            return None;
+        }
+        let configs = self.language_servers(&LanguageId::new("arduino"));
+        let cfg = configs.iter().find(|cfg| cfg.name == SERVER)?;
+        let project = self.project_root_for(path);
+        if sketch_root(&project, path).is_some() {
+            let server = self.server_for(cfg, &LanguageId::new("arduino"), path);
+            server.add_language(language);
+            let mut servers = vec![server];
+            servers.extend(
+                self.language_servers(language)
+                    .iter()
+                    .filter(|cfg| cfg.name != "clangd" && cfg.name != SERVER)
+                    .filter(|cfg| {
+                        !cfg.require_root_marker
+                            || crate::launch::marked_root(&project, path, &cfg.root_markers).is_some()
+                    })
+                    .map(|cfg| self.server_for(cfg, language, path)),
+            );
+            return Some(servers);
+        }
+        if !path.starts_with(&project)
+            && let Some(server) = self.origin_server(&crate::uri::path_to_uri_string(path))
+            && server.name == SERVER
+        {
+            return Some(vec![server]);
+        }
+        None
+    }
+
+    pub(crate) fn note_arduino_sources(&self, server: &Arc<Server>, locations: &[Location]) {
+        if server.name != SERVER {
+            return;
+        }
+        let mut origins = None;
+        for location in locations {
+            let path: &Path = &location.path;
+            if location.uri.is_none() && !path.starts_with(self.project_root_for(path)) {
+                origins
+                    .get_or_insert_with(|| self.virtual_origins.lock())
+                    .insert(crate::uri::path_to_uri_string(path), server.id);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bundled_server_allows_diagnostics() {
+        let registry = ide_language::LanguageRegistry::load(None).unwrap();
+        let language = registry.get(&LanguageId::new("arduino")).unwrap();
+        let cfg = language.language_servers.iter().find(|cfg| cfg.name == SERVER).unwrap();
+        assert!(crate::caps::Restriction::new(SERVER, &cfg.features, &cfg.code_action_kinds).diagnostics());
+    }
+
+    #[tokio::test]
+    async fn inspection_checks_the_sketch_server_and_root_for_all_sources() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        let sketch = root.join("examples/blink");
+        std::fs::create_dir_all(&sketch).unwrap();
+        std::fs::write(sketch.join("blink.ino"), "").unwrap();
+        let registry = Arc::new(ide_language::LanguageRegistry::load(None).unwrap());
+        let manager = LspManager::new(root.to_path_buf(), registry, Arc::new(|_: ide_core::IdeEvent| {}));
+        let expected_root = sketch.clone();
+        manager.set_config_hook(Box::new(move |cfg, server_root| {
+            cfg.command = std::env::current_exe().unwrap().to_string_lossy().into_owned();
+            if cfg.name != SERVER || server_root != expected_root {
+                cfg.launch_error = Some("unavailable".into());
+            }
+        }));
+        for name in ["blink.ino", "helper.cpp", "helper.h"] {
+            assert!(manager.serves_path(&sketch.join(name)), "{name}");
+        }
+        assert!(!manager.serves_path(&root.join("main.cpp")));
+    }
+
+    #[test]
+    fn nested_sketches_keep_separate_board_roots() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        let inner = root.join("examples/blink");
+        std::fs::create_dir_all(inner.join("src")).unwrap();
+        std::fs::write(root.join("main.ino"), "").unwrap();
+        std::fs::write(inner.join("blink.ino"), "").unwrap();
+        assert_eq!(sketch_root(root, &inner.join("blink.ino")), Some(inner.clone()));
+        assert_eq!(sketch_root(root, &inner.join("src/helper.cpp")), Some(inner));
+        assert_eq!(sketch_root(root, &root.join("helper.h")), Some(root.to_path_buf()));
+        assert_eq!(sketch_root(&root.join("examples"), &root.join("other.cpp")), None);
+    }
+
+    #[test]
+    fn ordinary_cpp_projects_and_ino_named_directories_are_not_sketches() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir(dir.path().join("not-a-file.ino")).unwrap();
+        assert_eq!(sketch_root(dir.path(), &dir.path().join("main.cpp")), None);
+    }
+
+    #[tokio::test]
+    async fn cpp_routing_is_scoped_to_sketches_and_respects_disabled_arduino() {
+        let dir = tempfile::tempdir().unwrap();
+        let root = dir.path();
+        let sketch = root.join("examples/blink");
+        std::fs::create_dir_all(&sketch).unwrap();
+        std::fs::write(sketch.join("blink.ino"), "").unwrap();
+        let registry = Arc::new(ide_language::LanguageRegistry::load(None).unwrap());
+        let manager = LspManager::new(root.to_path_buf(), registry, Arc::new(|_: ide_core::IdeEvent| {}));
+        let cpp = LanguageId::new("cpp");
+        let sketch_servers = manager.servers_for(&cpp, &sketch.join("helper.cpp"));
+        assert_eq!(sketch_servers.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), [SERVER]);
+        assert_eq!(sketch_servers[0].root, sketch);
+        assert!(sketch_servers[0].languages().contains(&LanguageId::new("arduino")));
+        assert_eq!(manager.servers_for(&cpp, &root.join("main.cpp"))[0].name, "clangd");
+        manager.set_servers_hook(Box::new(
+            |language, defined| {
+                if language.as_str() == "arduino" { Vec::new() } else { defined.to_vec() }
+            },
+        ));
+        assert_eq!(manager.servers_for(&cpp, &sketch.join("helper.cpp"))[0].name, "clangd");
+    }
+
+    #[test]
+    fn capabilities_are_sanitized_for_arduino_proxy_quirks() {
+        let mut client = serde_json::json!({
+            "textDocument": {
+                "semanticTokens": { "dynamicRegistration": false },
+                "inlayHint": { "dynamicRegistration": false },
+                "completion": {
+                    "completionItem": {
+                        "snippetSupport": true,
+                        "insertReplaceSupport": true
+                    }
+                }
+            },
+            "workspace": {
+                "semanticTokens": { "refreshSupport": true },
+                "inlayHint": { "refreshSupport": true }
+            }
+        });
+        configure_client_capabilities(&mut client);
+        assert!(client["textDocument"].get("semanticTokens").is_none());
+        assert!(client["textDocument"].get("inlayHint").is_none());
+        assert!(client["textDocument"]["completion"]["completionItem"].get("insertReplaceSupport").is_none());
+        assert_eq!(client["textDocument"]["completion"]["completionItem"]["snippetSupport"], true);
+        assert!(client["workspace"].get("semanticTokens").is_none());
+        assert!(client["workspace"].get("inlayHint").is_none());
+
+        let mut server = serde_json::json!({
+            "documentSymbolProvider": {},
+            "workspaceSymbolProvider": {},
+            "completionProvider": { "triggerCharacters": ["."] },
+            "hoverProvider": true
+        });
+        sanitize_server_capabilities(&mut server);
+        assert!(server.get("documentSymbolProvider").is_none());
+        assert!(server.get("workspaceSymbolProvider").is_none());
+        assert!(server.get("completionProvider").is_some());
+        assert!(server.get("hoverProvider").is_some());
+    }
+}

crates/ide-lsp/src/convert.rs

@@ -301,6 +301,7 @@ pub fn completion_item(conv: &Conv, path: &Path, item: lsp::CompletionItem, serv
     let mut out = CompletionItem {
         label: item.label.clone(),
         label_detail: None,
+        label_description: None,
         detail: None,
         kind: None,
         documentation: None,
@@ -349,6 +350,9 @@ pub fn overlay_completion(conv: &Conv, path: &Path, out: &mut CompletionItem, it
     if let Some(d) = label_details.and_then(|d| d.detail) {
         out.label_detail = Some(d);
     }
+    if let Some(d) = description.clone() {
+        out.label_description = Some(d);
+    }
     if let Some(d) = detail.or(description) {
         out.detail = Some(d);
     }
@@ -425,10 +429,12 @@ pub fn lsp_completion_item(text: &DocText, enc: Encoding, item: &CompletionItem)
     });
     lsp::CompletionItem {
         label: item.label.clone(),
-        label_details: item
-            .label_detail
-            .clone()
-            .map(|detail| lsp::CompletionItemLabelDetails { detail: Some(detail), description: None }),
+        label_details: (item.label_detail.is_some() || item.label_description.is_some()).then(|| {
+            lsp::CompletionItemLabelDetails {
+                detail: item.label_detail.clone(),
+                description: item.label_description.clone(),
+            }
+        }),
         kind: item.kind.map(lsp_completion_kind),
         detail: item.detail.clone(),
         documentation: item.documentation.as_ref().map(lsp_documentation),
@@ -562,10 +568,18 @@ pub fn lsp_command(c: &Command) -> lsp::Command {
     }
 }
 
-pub fn code_action(conv: &Conv, a: lsp::CodeActionOrCommand, server: ServerId) -> CodeAction {
+pub fn code_action(
+    conv: &Conv,
+    path: &Path,
+    a: lsp::CodeActionOrCommand,
+    server: ServerId,
+    server_name: &str,
+) -> CodeAction {
     match a {
         lsp::CodeActionOrCommand::Command(c) => CodeAction {
             title: c.title.clone(),
+            diagnostics: Vec::new(),
+            original_diagnostics: None,
             kind: None,
             is_preferred: false,
             disabled_reason: None,
@@ -576,6 +590,13 @@ pub fn code_action(conv: &Conv, a: lsp::CodeActionOrCommand, server: ServerId) -
         },
         lsp::CodeActionOrCommand::CodeAction(a) => CodeAction {
             title: a.title,
+            original_diagnostics: a.diagnostics.as_ref().and_then(|d| serde_json::to_string(d).ok()),
+            diagnostics: a
+                .diagnostics
+                .unwrap_or_default()
+                .into_iter()
+                .map(|d| diagnostic(conv, path, d, server_name))
+                .collect(),
             kind: a.kind.map(|k| k.as_str().to_owned()),
             is_preferred: a.is_preferred.unwrap_or(false),
             disabled_reason: a.disabled.map(|d| d.reason),
@@ -591,7 +612,7 @@ pub fn lsp_code_action(a: &CodeAction) -> lsp::CodeAction {
     lsp::CodeAction {
         title: a.title.clone(),
         kind: a.kind.clone().map(lsp::CodeActionKind::from),
-        diagnostics: None,
+        diagnostics: a.original_diagnostics.as_deref().and_then(|d| serde_json::from_str(d).ok()),
         edit: None,
         command: a.command.as_ref().map(lsp_command),
         is_preferred: a.is_preferred.then_some(true),
@@ -1067,6 +1088,66 @@ mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn code_action_diagnostics_use_ide_coordinates_and_round_trip_for_resolve() {
+        let path = Path::new("/go.mod");
+        let conv = Conv::new(Encoding::Utf8, |_| Some(Arc::new(DocText::new("😀 dependency"))));
+        let raw: lsp::Diagnostic = serde_json::from_value(json!({
+            "range": { "start": { "line": 0, "character": 5 }, "end": { "line": 0, "character": 15 } },
+            "message": "github.com/sergi/go-diff is not used in this module",
+            "severity": 2,
+            "code": 123,
+            "source": "go mod tidy",
+            "data": { "fix": "remove" }
+        }))
+        .unwrap();
+        let incoming = lsp::CodeAction {
+            title: "Remove dependency: github.com/sergi/go-diff".into(),
+            diagnostics: Some(vec![raw.clone()]),
+            ..Default::default()
+        };
+        let action = code_action(&conv, path, lsp::CodeActionOrCommand::CodeAction(incoming), ServerId(1), "gopls");
+        assert_eq!(action.diagnostics, vec![diagnostic(&conv, path, raw.clone(), "gopls")]);
+        assert_eq!(action.diagnostics[0].range, Range::new(Pos::new(0, 3), Pos::new(0, 13)));
+        assert_eq!(action.diagnostics[0].code.as_deref(), Some("123"));
+        let action: CodeAction = serde_json::from_value(serde_json::to_value(action).unwrap()).unwrap();
+        assert_eq!(lsp_code_action(&action).diagnostics, Some(vec![raw.clone()]));
+        let resolved = merge_code_action(&conv, action, lsp::CodeAction::default());
+        assert_eq!(lsp_code_action(&resolved).diagnostics, Some(vec![raw]));
+        assert_eq!(resolved.diagnostics.len(), 1);
+    }
+
+    #[test]
+    fn code_actions_without_diagnostics_keep_them_absent_for_resolve() {
+        let conv = Conv::utf16();
+        for incoming in [
+            lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction { title: "Fix".into(), ..Default::default() }),
+            lsp::CodeActionOrCommand::Command(lsp::Command {
+                title: "Fix".into(),
+                command: "fix".into(),
+                arguments: None,
+            }),
+        ] {
+            let action = code_action(&conv, Path::new("/a"), incoming, ServerId(1), "srv");
+            assert!(action.diagnostics.is_empty());
+            assert!(lsp_code_action(&action).diagnostics.is_none());
+        }
+        let raw = lsp::Diagnostic::new_simple(lsp::Range::default(), "problem".into());
+        let expected = diagnostic(&conv, Path::new("/a"), raw.clone(), "srv");
+        let action = code_action(
+            &conv,
+            Path::new("/a"),
+            lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {
+                diagnostics: Some(vec![raw]),
+                ..Default::default()
+            }),
+            ServerId(1),
+            "srv",
+        );
+        assert_eq!(action.diagnostics, vec![expected]);
+        assert_eq!(action.diagnostics[0].source.as_deref(), Some("srv"));
+    }
+
     #[test]
     fn merged_rename_edits_keep_the_first_servers_ones() {
         let edit = |l: u32, c: u32, text: &str| TextEdit {
@@ -1209,7 +1290,8 @@ mod tests {
         assert_eq!(a.insert_text, "println!($0)");
         assert!(a.is_snippet);
         assert_eq!(a.label_detail.as_deref(), Some("(…)"));
-        assert_eq!(a.detail.as_deref(), Some("std"));
+        assert_eq!(a.label_description.as_deref(), Some("std"));
+        assert_eq!(a.detail.as_deref(), Some("std"), "no `detail` from the server: the description stands in");
         assert_eq!(a.kind, Some(CompletionKind::Function));
         assert_eq!(a.replace_range, Some(Range::new(p(0, 4), p(0, 6))));
         assert_eq!(a.replace_range_tab, Some(Range::new(p(0, 4), p(0, 9))));
@@ -1225,6 +1307,9 @@ mod tests {
         let back = lsp_completion_item(&text, Encoding::Utf16, &a);
         assert_eq!(back.data, Some(json!({"k": 1})));
         assert!(matches!(back.text_edit, Some(lsp::CompletionTextEdit::InsertAndReplace(_))));
+        let details = back.label_details.expect("label details survive the resolve round trip");
+        assert_eq!(details.detail.as_deref(), Some("(…)"));
+        assert_eq!(details.description.as_deref(), Some("std"));
     }
 
     #[test]
@@ -1255,6 +1340,10 @@ mod tests {
             let item = completion_item(&Conv::utf16(), Path::new("/Main.java"), items[0].clone(), ServerId(1));
             assert_eq!(item.replace_range, Some(Range::new(p(2, 19), p(2, end))));
             assert_eq!(item.replace_range_tab, None);
+            // The list shows `print (Object obj)` and `void`; the long signature is only for the docs panel.
+            assert_eq!(item.label_detail.as_deref(), Some("(Object obj)"));
+            assert_eq!(item.label_description.as_deref(), Some("void"));
+            assert_eq!(item.detail.as_deref(), Some("PrintStream.print(Object obj) : void"));
             assert_eq!(item.filter_text.as_deref(), Some("print(Object obj) : void"));
             assert_eq!(item.insert_text, "print(${0});");
             assert!(item.is_snippet);

crates/ide-lsp/src/inspect.rs

@@ -63,6 +63,17 @@ impl LspManager {
     /// run doesn't prompt to install every language it meets.
     pub fn serves_path(&self, path: &Path) -> bool {
         let lang = self.languages.detect(path, None);
+        let arduino = if lang.as_str() == "arduino" {
+            Some(self.servers_for(&lang, path))
+        } else {
+            self.arduino_servers(&lang, path)
+        };
+        if let Some(servers) = arduino {
+            return servers.iter().any(|server| {
+                let cfg = self.configured(server);
+                cfg.launch_error.is_none() && self.launcher.available(&cfg, &server.root)
+            });
+        }
         self.language_servers(&lang).iter().any(|ls| {
             if ls.require_root_marker
                 && crate::launch::marked_root(&self.project_root, path, &ls.root_markers).is_none()

crates/ide-lsp/src/lib.rs

@@ -7,6 +7,7 @@
 //! never `lsp-types`, so the IPC surface stays stable.
 
 mod angular;
+mod arduino;
 mod caps;
 mod clang_tidy;
 mod convert;
@@ -502,10 +503,12 @@ impl LspManager {
     fn server_for(&self, cfg: &LanguageServerConfig, language: &LanguageId, path: &Path) -> Arc<Server> {
         let shared = is_local_jdtls(cfg).then(|| self.jdtls_workspace_state());
         let mut servers = self.servers.lock();
+        let project = self.project_root_for(path);
+        let sketch = (cfg.name == arduino::SERVER).then(|| arduino::sketch_root(&project, path)).flatten();
         let root = if shared.as_ref().is_some_and(|state| state.shared) {
             self.project_root.clone()
         } else {
-            launch::find_root(&self.project_root_for(path), path, &cfg.root_markers).unwrap_or_else(|| {
+            sketch.or_else(|| launch::find_root(&project, path, &cfg.root_markers)).unwrap_or_else(|| {
                 // Outside the project (library sources, …): reuse a running instance.
                 servers
                     .iter()
@@ -530,6 +533,9 @@ impl LspManager {
     /// only while all servers listed before it are missing. One that requires a
     /// root marker serves only files below one, and stands in for no other.
     fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
+        if let Some(servers) = self.arduino_servers(language, path) {
+            return servers;
+        }
         let mut out = Vec::new();
         let mut available_before = false;
         for sc in &self.language_servers(language) {
@@ -775,7 +781,11 @@ impl LspManager {
                 if let Some(info) = result.get("serverInfo") {
                     tracing::info!("{} initialized: {info}", server.name);
                 }
-                let mut caps = ServerCaps::parse(result.get("capabilities").cloned().unwrap_or_else(|| json!({})));
+                let mut caps_val = result.get("capabilities").cloned().unwrap_or_else(|| json!({}));
+                if server.name == arduino::SERVER {
+                    arduino::sanitize_server_capabilities(&mut caps_val);
+                }
+                let mut caps = ServerCaps::parse(caps_val);
                 let cfg = server.effective_config();
                 caps.restrict(caps::Restriction::new(&server.name, &cfg.features, &cfg.code_action_kinds));
                 caps
@@ -921,6 +931,9 @@ impl LspManager {
             "capabilities": caps::client_capabilities(),
             "trace": "off",
         });
+        if server.name == arduino::SERVER {
+            arduino::configure_client_capabilities(&mut params["capabilities"]);
+        }
         if server.name == "gopls" {
             params["capabilities"]["experimental"]["interactiveResolve"] = json!({ "inputTypes": ["string"] });
         }
@@ -1560,6 +1573,7 @@ impl LspManager {
                     let locs = convert::goto_response(&self.conv(t.enc()), r);
                     let locs = library_sources(snap, pos, locs).await;
                     self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
+                    self.note_arduino_sources(&t.server, &locs);
                     let locs = merge_locations(first, locs);
                     if !locs.is_empty() {
                         return Ok(locs);
@@ -1788,6 +1802,7 @@ impl LspManager {
                     .collect();
                 let locations: Vec<Location> = classified.iter().map(|r| r.location.clone()).collect();
                 self.note_virtual(&t.server, locations.iter().map(|l| l.uri.as_deref()));
+                self.note_arduino_sources(&t.server, &locations);
                 Ok(References { locations, classified, incomplete: widened.incomplete, libraries_skipped })
             }
             .await;
@@ -1855,6 +1870,7 @@ impl LspManager {
                         locs.retain(|l| !declarations.contains(l));
                     }
                     self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
+                    self.note_arduino_sources(&t.server, &locs);
                     acc.locations.extend(locs);
                     acc.incomplete = acc.incomplete.or(w.incomplete);
                 }
@@ -2058,7 +2074,8 @@ impl LspManager {
                             .unwrap_or_default()
                             .into_iter()
                             .map(|a| {
-                                let mut action = convert::code_action(&conv, a, t.server.id);
+                                let mut action =
+                                    convert::code_action(&conv, &snap.path, a, t.server.id, &t.server.name);
                                 self.tag_injected_origin(doc, &mut action.data);
                                 self.tag_injected_command(doc, action.server, &mut action.command);
                                 action
@@ -2935,6 +2952,64 @@ impl LspManager {
             .cloned()
     }
 
+    /// The binary archive behind a library document, never its displayed tab title.
+    pub fn library_archive(uri: &str) -> Option<PathBuf> {
+        if virtual_doc::scheme(uri) == "jar" {
+            return library_source::parse(uri).map(|e| e.jar);
+        }
+        virtual_doc::description(uri).filter(|p| p.ends_with(".jar") && Path::new(p).is_absolute()).map(PathBuf::from)
+    }
+
+    /// Open an attached archive at the declaration under the decompiled editor's caret.
+    pub async fn library_source_location(
+        &self,
+        uri: &str,
+        sources: PathBuf,
+        pos: Pos,
+        cancel: &CancellationToken,
+    ) -> IdeResult<Option<Location>> {
+        let previous = tokio::select! {
+            result = self.virtual_document(uri) => result?,
+            _ = cancel.cancelled() => return Err(IdeError::cancelled()),
+        };
+        let name = previous
+            .text
+            .lines()
+            .nth(pos.line as usize)
+            .and_then(|line| library_source::identifier_at(line, pos.col))
+            .map(str::to_owned);
+        let original = uri.to_owned();
+        let archive = sources.clone();
+        let found = tokio::task::spawn_blocking(move || {
+            library_source::source_in_archive(&original, &archive).map(|(uri, text)| {
+                let range = name.as_deref().map(|n| library_source::declaration_range(&text, n)).unwrap_or_default();
+                Location { path: uri.clone().into(), uri: Some(uri), range }
+            })
+        })
+        .await
+        .map_err(|e| IdeError::internal(e.to_string()))?;
+        if cancel.is_cancelled() {
+            return Err(IdeError::cancelled());
+        }
+        if found.is_some() {
+            if virtual_doc::scheme(uri) == "jdt" {
+                let result = self
+                    .jdtls_command_cancellable(
+                        &self.project_root,
+                        "java.project.updateSourceAttachment",
+                        vec![json!({ "classFileUri": uri, "attributes": { "sourceAttachmentPath": sources } })],
+                        cancel,
+                    )
+                    .await?;
+                if let Some(error) = result.get("errorMessage").and_then(Value::as_str).filter(|s| !s.is_empty()) {
+                    return Err(IdeError::unavailable(error));
+                }
+            }
+            self.virtual_docs.lock().remove(uri);
+        }
+        Ok(found)
+    }
+
     /// Contents of a virtual document, from the server that owns `uri`:
     /// `workspace/textDocumentContent` (LSP 3.18) when the server serves the
     /// scheme, jdtls' `java/classFileContents` for `jdt:` URIs. A `jar:` entry
@@ -3312,6 +3387,7 @@ impl LspManager {
                 .filter(|a| {
                     !wanted.iter().any(|w| w.id == a.server.id)
                         && (configs.iter().any(|c| c.fallback && c.name == a.server.name)
+                            || (a.server.name == "clangd" && wanted.iter().any(|s| s.name == arduino::SERVER))
                             || !configs
                                 .iter()
                                 .any(|c| c.name == a.server.name && c.target_key == a.server.config.target_key))

crates/ide-lsp/src/library_source.rs

@@ -79,6 +79,27 @@ pub(crate) fn class_source(uri: &str) -> Option<(String, String)> {
     None
 }
 
+pub(crate) fn source_in_archive(uri: &str, sources: &Path) -> Option<(String, String)> {
+    let jar = if uri.starts_with("jdt://contents/") {
+        let path = uri.split('?').next()?.strip_prefix("jdt://contents/")?;
+        let parts: Vec<_> = path.split('/').collect();
+        let [_, package, file] = parts.as_slice() else { return None };
+        let file = percent_decode_str(file).decode_utf8().ok()?;
+        let name = file.strip_suffix(".class").or_else(|| file.strip_suffix(".java"))?;
+        let package = percent_decode_str(package).decode_utf8().ok()?.replace('.', "/");
+        JarEntry {
+            prefix: "jar:file://".into(),
+            jar: sources.to_owned(),
+            entry: if package.is_empty() { format!("{name}.class") } else { format!("{package}/{name}.class") },
+        }
+    } else {
+        parse(uri)?
+    };
+    let class = jar.entry.strip_suffix(".class")?;
+    let (entry, text) = source_entry(sources, class)?;
+    Some((jar.uri_of(sources, &entry), text))
+}
+
 /// Sources jars of the artifact `jar`: `<name>-sources.jar` next to it (Maven
 /// repository), or in a sibling hash folder (Gradle `files-2.1/<g>/<a>/<v>/<hash>/`).
 fn sources_jars(jar: &Path) -> Vec<PathBuf> {
@@ -139,7 +160,20 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
     const KEYWORDS: [&str; 9] = ["fun", "class", "interface", "object", "val", "var", "typealias", "enum", "record"];
     let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';
     let mut fallback = None;
+    let mut block_comment = false;
     for (line_no, line) in text.lines().enumerate() {
+        let trimmed = line.trim_start();
+        if block_comment {
+            block_comment = !trimmed.contains("*/");
+            continue;
+        }
+        if trimmed.starts_with("/*") {
+            block_comment = !trimmed.contains("*/");
+            continue;
+        }
+        if trimmed.starts_with("//") || trimmed.starts_with('*') {
+            continue;
+        }
         let mut from = 0;
         while let Some(i) = line[from..].find(name) {
             let start = from + i;
@@ -161,8 +195,11 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
             if words.iter().any(|w| KEYWORDS.contains(w)) {
                 return range;
             }
-            let java_member =
-                after == Some('(') && !head.trim_end().ends_with('.') && !head.trim().is_empty() && !head.contains('=');
+            let java_member = after == Some('(')
+                && !head.trim_end().ends_with('.')
+                && !head.trim().is_empty()
+                && !head.contains(['=', '('])
+                && !words.iter().any(|w| matches!(*w, "return" | "throw" | "new" | "yield" | "assert"));
             if java_member && fallback.is_none() {
                 fallback = Some(range);
             }
@@ -227,6 +264,24 @@ mod tests {
         assert_eq!(parse("jar:///no/entry.jar"), None);
     }
 
+    #[test]
+    fn opens_selected_archives_for_jdt_and_jar_classes() {
+        let tmp = tempfile::tempdir().unwrap();
+        let sources = tmp.path().join("library sources.zip");
+        jar(&sources, &[("p/Lib.java", "package p; public class Lib { class Inner {} }")]);
+        for uri in [
+            "jdt://contents/lib-1.jar/p/Lib.class?=project/escaped-jar-path",
+            "jdt://contents/lib-1.jar/p/Lib.java?=project/escaped-jar-path",
+            "jar:file:///m2/g/lib/1/lib-1.jar!/p/Lib$Inner.class",
+        ] {
+            let (uri, text) = source_in_archive(uri, &sources).unwrap();
+            assert!(uri.ends_with("library%20sources.zip!/p/Lib.java"), "{uri}");
+            assert!(text.contains("class Lib"));
+        }
+        assert!(source_in_archive("jdt://contents/lib.jar/p/Missing.class", &sources).is_none());
+        assert!(source_in_archive("csharp:/p/App.csproj/decompiled/Lib.cs", &sources).is_none());
+    }
+
     #[test]
     fn finds_the_source_of_each_kind_of_class_in_maven_and_gradle_caches() {
         let tmp = tempfile::tempdir().unwrap();
@@ -285,6 +340,8 @@ mod tests {
         assert_eq!(at(java, "run"), (3, 49, 52), "the member, not the call in its body");
         assert_eq!(at("val x = 1", "missing"), (0, 0, 0));
         assert_eq!(at("// é\nfun ü() {}", "ü"), (1, 4, 5), "UTF-16 columns");
+        let java = "class Lib {\n    boolean caller(String s) { return isBlank(s); }\n    /**\n     * Changed signature from isBlank(String) to isBlank(CharSequence).\n     */\n    public static boolean isBlank(CharSequence cs) { return false; }\n}\n";
+        assert_eq!(at(java, "isBlank"), (5, 26, 33), "the declaration, not a call or Javadoc signature");
     }
 
     #[test]

crates/ide-lsp/src/types.rs

@@ -2,7 +2,7 @@
 
 use ide_core::event::ServerStatus;
 use ide_core::settings::ExternalFormatter;
-use ide_core::{Location, Range, ServerId, SymbolKind, TextEdit, WorkspaceEdit};
+use ide_core::{Diagnostic, Location, Range, ServerId, SymbolKind, TextEdit, WorkspaceEdit};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 
@@ -49,7 +49,11 @@ pub struct CompletionItem {
     pub label: String,
     /// e.g. `(req: CreateOrderRequest)` shown right after the label.
     pub label_detail: Option<String>,
-    /// e.g. return type, shown right-aligned.
+    /// `labelDetails.description`: a return type or module path, shown right-aligned. Servers
+    /// such as JDT.LS also send the whole signature as `detail`, which would repeat the label.
+    pub label_description: Option<String>,
+    /// The signature or type when the server sent no `label_description`; the documentation panel
+    /// shows it either way.
     pub detail: Option<String>,
     pub kind: Option<CompletionKind>,
     pub documentation: Option<Markup>,
@@ -193,6 +197,14 @@ pub struct InlineCompletionItem {
 #[serde(rename_all = "camelCase")]
 pub struct CodeAction {
     pub title: String,
+    /// Diagnostics this action fixes, in IDE coordinates.
+    #[serde(default)]
+    #[specta(optional)]
+    pub diagnostics: Vec<Diagnostic>,
+    /// Original server diagnostics, including encoding and data, for codeAction/resolve.
+    #[serde(default)]
+    #[specta(optional)]
+    pub original_diagnostics: Option<String>,
     /// LSP kind, e.g. `quickfix`, `refactor.extract`, `source.organizeImports`.
     pub kind: Option<String>,
     pub is_preferred: bool,

crates/ide-lsp/tests/mock_server.rs

@@ -1301,7 +1301,7 @@ async fn completion_mapping_merge_and_resolve() {
             "isIncomplete": false,
             "itemDefaults": { "data": { "from": "defaults" } },
             "items": [{
-                "label": "bar", "kind": 2, "detail": "fn() -> u8", "labelDetails": { "detail": "()" },
+                "label": "bar", "kind": 2, "detail": "fn() -> u8", "labelDetails": { "detail": "()", "description": "u8" },
                 "textEdit": { "newText": "bar()$0", "insert": {"start":{"line":0,"character":12},"end":{"line":0,"character":14}},
                               "replace": {"start":{"line":0,"character":12},"end":{"line":0,"character":15}} },
                 "insertTextFormat": 2, "sortText": "0001"
@@ -1322,6 +1322,7 @@ async fn completion_mapping_merge_and_resolve() {
     assert_eq!(bar.insert_text, "bar()$0");
     assert!(bar.is_snippet);
     assert_eq!(bar.label_detail.as_deref(), Some("()"));
+    assert_eq!(bar.label_description.as_deref(), Some("u8"));
     assert_eq!(bar.replace_range, Some(rng(0, 12, 0, 14)));
     assert_eq!(bar.replace_range_tab, Some(rng(0, 12, 0, 15)));
     assert_eq!(bar.data, Some(json!({ "from": "defaults" })));
@@ -1337,9 +1338,13 @@ async fn completion_mapping_merge_and_resolve() {
     assert_eq!(resolved.documentation.as_ref().unwrap().value, "**docs**");
     assert_eq!(resolved.additional_edits[0].new_text, "use foo;\n");
     assert_eq!(resolved.insert_text, "bar()$0", "fields absent from the resolve reply are kept");
+    assert_eq!(resolved.label_detail.as_deref(), Some("()"));
+    assert_eq!(resolved.label_description.as_deref(), Some("u8"));
+    assert_eq!(resolved.detail.as_deref(), Some("fn() -> u8"));
     assert_eq!(resolved.replace_range_tab, Some(rng(0, 12, 0, 15)));
     let sent = &a.requested("completionItem/resolve")[0];
     assert_eq!(sent["data"], json!({ "from": "defaults" }));
+    assert_eq!(sent["labelDetails"], json!({ "detail": "()", "description": "u8" }));
     assert_eq!(sent["textEdit"]["replace"]["end"]["character"], 15);
 
     // Server b has no resolve support: the item comes back unchanged.
@@ -1444,7 +1449,7 @@ async fn diagnostics_become_events_and_feed_code_actions() {
     s.respond(
         "textDocument/codeAction",
         json!([
-            { "title": "Remove", "kind": "quickfix", "isPreferred": true, "data": { "id": 7 } },
+            { "title": "Remove", "kind": "quickfix", "isPreferred": true, "data": { "id": 7 }, "diagnostics": [diag(0)] },
             { "title": "Run", "command": "mock.run", "arguments": [1] }
         ]),
     );
@@ -1459,6 +1464,9 @@ async fn diagnostics_become_events_and_feed_code_actions() {
     assert_eq!(actions.len(), 2);
     assert_eq!(actions[0].kind.as_deref(), Some("quickfix"));
     assert!(actions[0].is_preferred);
+    assert_eq!(actions[0].diagnostics[0].range, rng(0, 4, 0, 10));
+    assert_eq!(actions[0].diagnostics[0].message, "unused variable");
+    assert!(actions[1].diagnostics.is_empty());
     assert_eq!(actions[1].command.as_ref().unwrap().command, "mock.run");
     let req = &s.requested("textDocument/codeAction")[0];
     assert_eq!(req["context"]["only"], json!(["quickfix"]));
@@ -1468,6 +1476,8 @@ async fn diagnostics_become_events_and_feed_code_actions() {
 
     let resolved = h.mgr.resolve_code_action(doc, actions[0].clone()).await.unwrap();
     assert_eq!(s.requested("codeAction/resolve")[0]["data"], json!({ "id": 7 }));
+    assert_eq!(s.requested("codeAction/resolve")[0]["diagnostics"], json!([diag(0)]));
+    assert_eq!(resolved.diagnostics, actions[0].diagnostics);
     let edit = resolved.edit.unwrap();
     assert!(
         matches!(&edit.files[0], FileEdit::Edit { path: p, edits, .. } if p == &path && edits[0].range == rng(0, 0, 1, 0))

crates/ide-plugin/src/actor.rs

@@ -196,7 +196,7 @@ impl Actor {
         grace: Duration,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
-        self.call_cancellable_before(cancel, grace, None, f)
+        self.call_cancellable_before(cancel, grace, None, false, f)
     }
 
     /// A cancellable editor call: queued work expires after `soft`, and a
@@ -209,7 +209,18 @@ impl Actor {
         soft: Duration,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
-        self.call_cancellable_before(cancel, grace, Some(Instant::now() + soft), f)
+        self.call_cancellable_before(cancel, grace, Some(Instant::now() + soft), false, f)
+    }
+
+    /// A launch gate's deadline also interrupts running host calls and background tasks.
+    pub fn call_bounded<R: Send + 'static>(
+        &self,
+        cancel: &ide_core::CancellationToken,
+        grace: Duration,
+        timeout: Duration,
+        f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
+    ) -> Result<R, ActorError> {
+        self.call_cancellable_before(cancel, grace, Some(Instant::now() + timeout), true, f)
     }
 
     fn call_cancellable_before<R: Send + 'static>(
@@ -217,6 +228,7 @@ impl Actor {
         cancel: &ide_core::CancellationToken,
         grace: Duration,
         deadline: Option<Instant>,
+        hard_deadline: bool,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
         let (reply, result) = mpsc::sync_channel(1);
@@ -260,7 +272,7 @@ impl Actor {
             match result.recv_timeout(Duration::from_millis(5)) {
                 Ok(outcome) if cancelled_at.is_some() => {
                     drop(outcome);
-                    return Err(ActorError::Cancelled);
+                    return Err(if cancel.is_cancelled() { ActorError::Cancelled } else { ActorError::SoftTimeout });
                 }
                 Ok(outcome) => return outcome,
                 Err(mpsc::RecvTimeoutError::Disconnected) => {
@@ -268,19 +280,21 @@ impl Actor {
                 }
                 Err(mpsc::RecvTimeoutError::Timeout) => {}
             }
-            if !cancel.is_cancelled() {
+            let timed_out = hard_deadline && deadline.is_some_and(|t| Instant::now() >= t);
+            if !cancel.is_cancelled() && !timed_out {
                 if deadline.is_some_and(|t| Instant::now() >= t) && !*running.lock().unwrap_or_else(|e| e.into_inner())
                 {
                     return Err(ActorError::SoftTimeout);
                 }
                 continue;
             }
+            let failure = || if cancel.is_cancelled() { ActorError::Cancelled } else { ActorError::SoftTimeout };
             match cancelled_at {
                 None => {
                     cancelled_at = Some(Instant::now());
                     let running = running.lock().unwrap_or_else(|e| e.into_inner());
                     if !*running {
-                        return Err(ActorError::Cancelled);
+                        return Err(failure());
                     }
                     self.cancel.cancel_soft();
                 }
@@ -290,7 +304,7 @@ impl Actor {
                     if *running {
                         self.cancel();
                     }
-                    return Err(ActorError::Cancelled);
+                    return Err(failure());
                 }
                 Some(_) => {}
             }

crates/ide-plugin/src/execution.rs

@@ -151,3 +151,19 @@ pub enum PluginTestEvent {
     Output(TestOutput),
     Other { kind: String, data: String },
 }
+
+/// Operation about to launch through a plugin-owned run target (API 1.5).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RunTargetOperation {
+    Run,
+    Debug,
+    Test,
+}
+
+/// Launch metadata available to a target validator; arguments and environment are omitted.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RunTargetLaunch {
+    pub operation: RunTargetOperation,
+    pub program: String,
+    pub cwd: String,
+}

crates/ide-plugin/src/runtime.rs

@@ -18,6 +18,7 @@ use crate::types::{
 };
 use crate::wit_host::injections_bindings::exports::openidea::plugin::injections as wit_inj;
 use crate::wit_host::language_features_bindings::exports::openidea::plugin::language_features as wit_lf;
+use crate::wit_host::run_target_validation_bindings::exports::openidea::plugin::run_target_validation as wit_rtv;
 use crate::wit_host::{
     bindings, commit_checks_bindings, details_bindings, endpoints_bindings, file_actions_bindings, hover_bindings,
     indexing_bindings, inlay_bindings, providers_bindings, semantic_bindings, syntax_bindings, views_bindings,
@@ -925,6 +926,7 @@ pub struct Runtime {
 
 /// What the component exports: the `plugin` world, plus optional interfaces.
 struct Exports {
+    run_target_validation: Option<wit_rtv::Guest>,
     language_features: Option<wit_lf::Guest>,
     injections: Option<wit_inj::Guest>,
     plugin: bindings::Plugin,
@@ -1062,6 +1064,7 @@ impl Runtime {
         let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
         let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
         let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
+        let validation_indices = wit_rtv::GuestIndices::new(&pre).ok();
         let lf_indices = wit_lf::GuestIndices::new(&pre).ok();
         let inj_indices = wit_inj::GuestIndices::new(&pre).ok();
         let mcp_indices =
@@ -1073,6 +1076,8 @@ impl Runtime {
         let test_results = tests_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let language_features = lf_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let injections = inj_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
+        let run_target_validation =
+            validation_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let plugin = plugin_indices.load(&mut store, &instance).map_err(api_hint)?;
         let syntax = match syntax_indices {
             Some(indices) => Some(indices.load(&mut store, &instance).map_err(api_hint)?),
@@ -1125,6 +1130,7 @@ impl Runtime {
         Ok(Self {
             store,
             exports: Exports {
+                run_target_validation,
                 language_features,
                 injections,
                 plugin,
@@ -1149,6 +1155,37 @@ impl Runtime {
         })
     }
 
+    pub fn has_run_target_validation(&self) -> bool {
+        self.exports.run_target_validation.is_some()
+    }
+
+    /// Missing optional validators allow the launch without a guest call.
+    pub fn validate_run_target(
+        &mut self,
+        root: String,
+        target: String,
+        launch: crate::RunTargetLaunch,
+        timeout: Duration,
+    ) -> Result<Result<(), String>, CallError> {
+        if self.exports.run_target_validation.is_none() {
+            return Ok(Ok(()));
+        }
+        let invocation = Invocation { workspace_root: Some(root.clone().into()), ..Default::default() };
+        let launch = wit_rtv::LaunchInfo {
+            operation: match launch.operation {
+                crate::RunTargetOperation::Run => wit_rtv::Operation::Run,
+                crate::RunTargetOperation::Debug => wit_rtv::Operation::Debug,
+                crate::RunTargetOperation::Test => wit_rtv::Operation::Test,
+            },
+            program: launch.program,
+            cwd: launch.cwd,
+        };
+        self.call(invocation, timeout, |e, store| {
+            e.run_target_validation.as_ref().unwrap().call_validate(store, &root, &target, &launch)
+        })
+        .map(|r| r.map_err(|message| clip(message, 4096)))
+    }
+
     /// Complete configurations from the optional API 1.4 export.
     pub fn run_configurations(
         &mut self,

crates/ide-plugin/src/wit_host.rs

@@ -1878,31 +1878,72 @@ impl From<bindings::openidea::plugin::views::ContentTabReply> for crate::Content
     }
 }
 
+impl StoreData {
+    fn register_plugin_run_target(
+        &mut self,
+        project: Resource<ProjectRes>,
+        target: crate::PluginRunTarget,
+    ) -> Fallible<()> {
+        if let Err(e) = self.require(Capability::Process(target.program.clone())) {
+            return Ok(Err(e));
+        }
+        let root = self.table.get(&project)?.root.clone();
+        Ok(self.host.register_run_target(&root, target).map_err(to_wit))
+    }
+}
+
 impl bindings::openidea::plugin::run_targets::Host for StoreData {
     fn register(
         &mut self,
         project: Resource<ProjectRes>,
         target: bindings::openidea::plugin::run_targets::RunTarget,
     ) -> Fallible<()> {
-        if let Err(e) = self.require(Capability::Process(target.program.clone())) {
-            return Ok(Err(e));
-        }
-        let root = self.table.get(&project)?.root.clone();
-        Ok(self
-            .host
-            .register_run_target(
-                &root,
-                crate::PluginRunTarget {
-                    id: target.id,
-                    name: target.name,
-                    program: target.program,
-                    args: target.args,
-                    workdir_args: target.workdir_args,
-                    container_root: target.container_root,
-                    commands: target.commands,
-                },
-            )
-            .map_err(to_wit))
+        self.register_plugin_run_target(
+            project,
+            crate::PluginRunTarget {
+                id: target.id,
+                name: target.name,
+                program: target.program,
+                args: target.args,
+                workdir_args: target.workdir_args,
+                container_root: target.container_root,
+                commands: target
+                    .commands
+                    .into_iter()
+                    .map(|(name, args)| ide_core::remote_settings::PluginCommandOverride {
+                        name,
+                        args,
+                        workdir_args: None,
+                    })
+                    .collect(),
+            },
+        )
+    }
+    fn register_with_overrides(
+        &mut self,
+        project: Resource<ProjectRes>,
+        target: bindings::openidea::plugin::run_targets::RunTargetWithOverrides,
+    ) -> Fallible<()> {
+        self.register_plugin_run_target(
+            project,
+            crate::PluginRunTarget {
+                id: target.id,
+                name: target.name,
+                program: target.program,
+                args: target.args,
+                workdir_args: target.workdir_args,
+                container_root: target.container_root,
+                commands: target
+                    .commands
+                    .into_iter()
+                    .map(|c| ide_core::remote_settings::PluginCommandOverride {
+                        name: c.name,
+                        args: c.args,
+                        workdir_args: c.workdir_args,
+                    })
+                    .collect(),
+            },
+        )
     }
     fn unregister(&mut self, project: Resource<ProjectRes>, id: String) -> wasmtime::Result<()> {
         let root = self.table.get(&project)?.root.clone();
@@ -2294,3 +2335,8 @@ pub(crate) mod mcp_bindings {
         },
     });
 }
+
+/// Optional API 1.5 run-target launch validation.
+pub(crate) mod run_target_validation_bindings {
+    wasmtime::component::bindgen!({ world: "run-target-validator", path: "../../wit" });
+}

crates/ide-plugin/tests/fixtures/api14/dist/plugin.wasm.sources

@@ -1 +1 @@
-9963d6606bb6b859bebe1f55892488944f6d5e3308e6c0109f38f4b1a67b01f5
+023542d758cd359aa4d1282b95ddd2edca9fcf746862700705dd637b3e524571

crates/ide-plugin/tests/fixtures/commit/dist/plugin.wasm.sources

@@ -1 +1 @@
-7ab9937fdb2e78d0d62d9b85b78a0a6d9511224f85908c3a5a5e9c0d4b5e7e14
+ef4cedb7ab9caa7a5a597fa8bd302e4e10607989c575af1ca0c237f2d8bb06c8

crates/ide-plugin/tests/fixtures/data-tools/dist/plugin.wasm.sources

@@ -1 +1 @@
-cf1f91d8accf8339bf6e22bef5067bfe3cba75d38cd30d8748b0aa451ee2495b
+c215812502ccbb85b08efb9da234e6e9709deb84a492b41e771c61d4c38a05fb

crates/ide-plugin/tests/fixtures/detail-views/dist/plugin.wasm.sources

@@ -1 +1 @@
-12ad7d649d752f2a40b28dee718a3e04b64597496ab43787c084e3cb774ccfe6
+52efdb99877cded6fc5357d80f722975e314610b9d2bc91979b4b4cb05d8cdb8

crates/ide-plugin/tests/fixtures/diagnostics/dist/plugin.wasm.sources

@@ -1 +1 @@
-4bfce353b3c94490c5f95a046cd2371042b243c326bd63c65619e1489d7ab889
+0fb78e5c48f267e529ceb719ceb1e5aca82f2288071e9a0cc14809c27e7cd15a

crates/ide-plugin/tests/fixtures/endpoints/dist/plugin.wasm.sources

@@ -1 +1 @@
-cfbd6aac217a7baea907affe4e1e7f89d1330843398e913e68b71f3a99cfb71b
+5a4c7a37b5ff83d62dcc3da616da3712113fa6257e834f51705a4f7e417e519a

crates/ide-plugin/tests/fixtures/execution/dist/plugin.wasm.sources

@@ -1 +1 @@
-dcf00138820979f523bd93e1f6b08c627c6f061ae5b6e91b340646f905593cf3
+e5598d719f6e66790858758718842e4474747c6e14eb3e1c29c4584b26279ef6

crates/ide-plugin/tests/fixtures/execution/plugin.toml

@@ -1,7 +1,7 @@
 id = "execution"
 name = "Plugin execution tests"
 version = "0.1.0"
-engines.openidea = "^1.4"
+engines.openidea = "^1.5"
 wasm = "dist/plugin.wasm"
 activation = ["on-command:*"]
 [capabilities]
@@ -50,3 +50,11 @@ title = "target"
 [[contributes.commands]]
 id = "untarget"
 title = "untarget"
+
+[[contributes.commands]]
+id = "target-overrides"
+title = "target-overrides"
+
+[[contributes.commands]]
+id = "validation"
+title = "validation"

crates/ide-plugin/tests/fixtures/execution/src/lib.rs

@@ -20,6 +20,32 @@ impl Plugin for Execution {
                 )?;
                 Ok(None)
             }
+            "target-overrides" => {
+                let project = ctx.project().ok_or_else(|| Error::Invalid("no project".into()))?;
+                let workdir_args = match arg {
+                    Some("empty") => Some(vec![]),
+                    Some("own") => Some(vec!["--working-dir={cwd}".into()]),
+                    Some("invalid") => Some(vec!["bad\0arg".into()]),
+                    _ => None,
+                };
+                host::register_run_target_with_overrides(
+                    &project,
+                    &PluginRunTargetWithOverrides {
+                        id: "wrapper".into(),
+                        name: "Execution target".into(),
+                        program: "execution-tool".into(),
+                        args: vec!["wrapped".into()],
+                        workdir_args: vec!["--cwd={cwd}".into()],
+                        container_root: Some("/container".into()),
+                        commands: vec![PluginCommandOverride {
+                            name: "composer".into(),
+                            args: vec!["composer".into()],
+                            workdir_args,
+                        }],
+                    },
+                )?;
+                Ok(None)
+            }
             "untarget" => {
                 host::unregister_run_target(&ctx.project().unwrap(), arg.unwrap_or("wrapper"));
                 Ok(None)
@@ -53,6 +79,7 @@ impl Plugin for Execution {
                 Ok(None)
             }
             "events" => host::storage::get("events"),
+            "validation" => host::storage::get("validation"),
             _ => Err(Error::NotFound(id.into())),
         }
     }
@@ -121,4 +148,25 @@ impl TestResults for Execution {
         ]
     }
 }
-register_plugin!(Execution, run_configurations, test_results);
+impl RunTargetValidation for Execution {
+    fn validate(&mut self, project: &str, target: &str, launch: &RunTargetLaunch) -> Result<(), String> {
+        host::storage::set(
+            "validation",
+            &format!("{project}|{target}|{:?}|{}|{}", launch.operation, launch.program, launch.cwd),
+        )
+        .unwrap();
+        match target {
+            "refuse" => Err("Project runtime is stopped".into()),
+            "long-refusal" => Err("x".repeat(10000)),
+            "trap" => panic!("validator failed"),
+            "timeout" => {
+                let _task = host::begin_task("Validation", true);
+                loop {
+                    std::hint::spin_loop();
+                }
+            }
+            _ => Ok(()),
+        }
+    }
+}
+register_plugin!(Execution, run_configurations, test_results, run_target_validation);

crates/ide-plugin/tests/fixtures/file-templates/dist/plugin.wasm.sources

@@ -1 +1 @@
-98e0e01e8405ae7501e89c0dab06e6672b5240a831b19e8fbf0604a3171b31e9
+18a37beb12a0a3da68345314f7bfbb9521e8819702ef50a1c81f29bc3112c997

crates/ide-plugin/tests/fixtures/files-events/dist/plugin.wasm.sources

@@ -1 +1 @@
-fcee11f27ff9ae0038e8067712e269ccd49423372f692e9351c24f82906aafad
+c464178ead4043d49d10e63430436f9e261b211b1a7ff18d146ed244975baf7d

crates/ide-plugin/tests/fixtures/grouped-views/dist/plugin.wasm.sources

@@ -1 +1 @@
-5c777d7b146277fa803587d1788a7359b08478def00c4574dd565d784200e39a
+655bbe70bf3280a6e301255955d3e99e68b29242538b60060f61082977019212

crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources

@@ -1 +1 @@
-825b9ee483796efd24fcfe358b94f4667d87e311475769ec9e41ba9af6d03a6a
+2987ca7af6f5ae800ed3bcf826b7f85b713371cb6efa483953e0a4974248f61f

crates/ide-plugin/tests/fixtures/hover/dist/plugin.wasm.sources

@@ -1 +1 @@
-45b8cbd2ed7635ce04651937574dde9cf441dd619d76b8996f522c671950eaee
+ff914b1c3ae4709c86e8138cdc84ea500ebde77ac09dcd3722faeffeb25b3454

crates/ide-plugin/tests/fixtures/indexer/dist/plugin.wasm.sources

@@ -1 +1 @@
-e456b7ddf087ffbf2df62431bf9df47fad1929079c99a941a5deaf30599109f9
+8db8367b3e0872ebcb03b7f37a55fa1510f52e7f40eb07e401a40a0019349eb8

crates/ide-plugin/tests/fixtures/inlay-hints/dist/plugin.wasm.sources

@@ -1 +1 @@
-e0d8b590ad6ffd9569c6362802b2be909cb34b37b18cc8cc8492f9c460610e20
+8ec23043c138a4fe9ba13cdaf13b78b56032eea14f48caddde6e5016226e3d28

crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources

@@ -1 +1 @@
-d2512203db3e5c6df93e9ccd5ff8daed8f1ebd28462b8caf7d500e814d3b6671
+cde70a51050b29cbf553df08c6aadb660be51c9146ec1d3e186de55a3130a7c1

crates/ide-plugin/tests/fixtures/language-features/dist/plugin.wasm.sources

@@ -1 +1 @@
-b32da5137b552cfad2557716343ed8ac9236b34fec018e3f2facc7b78b67e72a
+21ac46f028c4a151b1f89eac12ad8894d1dbc84a3489f3054dec239c87de5e4a

crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources

@@ -1 +1 @@
-ae58467cdb6e98a491d739884eee96d239f80451de749950d81f4fd480edba58
+7981067231363be183e28e9aa0dd8cffb430783080c702a1843c361187b3f267

crates/ide-plugin/tests/fixtures/path-events/dist/plugin.wasm.sources

@@ -1 +1 @@
-e378c85a4fe395c7b172065a33a2f15ad76852ac42d4099d2cf1f64540e13143
+e4fafd8b7ea6d9bb6d10836c8fc133a58277f68e293410d221372bced719a192

crates/ide-plugin/tests/fixtures/private-dir/dist/plugin.wasm.sources

@@ -1 +1 @@
-23dc9ab1affb5b0c0166a5bb2bffb8a273a5c9eed0c06d402f16a1440b835639
+c6d9a0c72cf63c1a4ddb9cb45fa7eaf2cd4d6e14d6977b6e834196ad526f0a2a

crates/ide-plugin/tests/fixtures/run-target-api14/README.md

@@ -0,0 +1,8 @@
+# Frozen API 1.4 run-target guest
+
+`dist/plugin.wasm` is the execution fixture shipped in OpenIDEA v0.1.40,
+from commit `37c2a6048eea89d4f6db645622612358b643862b`, built against API 1.4.
+The manifest exposes its `target` command under a separate plugin id.
+Keep this binary frozen: rebuilding it with the current SDK would stop testing
+released guests. Its source is `crates/ide-plugin/tests/fixtures/execution/src/lib.rs`
+at that commit. It registers a Composer override inheriting the shared cwd arguments.

crates/ide-plugin/tests/fixtures/run-target-api14/plugin.toml

@@ -0,0 +1,12 @@
+id = "run-target-api14"
+name = "Frozen API 1.4 run target"
+version = "0.1.0"
+engines.openidea = "^1.4"
+wasm = "dist/plugin.wasm"
+activation = ["on-command:*"]
+[capabilities]
+required = ["project.read"]
+optional = ["process:execution-tool"]
+[[contributes.commands]]
+id = "target"
+title = "target"