The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(agents): stop idle agents, run tasks locally by default, keep worktrees next to the project (#1050)
l0ng-aie20eb1acf8d1
diff --git a/crates/ide-agent/src/lib.rs b/crates/ide-agent/src/lib.rsindex d85bd0b77..66786c1d6 100644--- a/crates/ide-agent/src/lib.rs+++ b/crates/ide-agent/src/lib.rs@@ -29,7 +29,7 @@ use serde::{Deserialize, Serialize};use serde_json::{Value, json};use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};use std::path::{Path, PathBuf};-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};use std::sync::{Arc, Weak};use std::time::Duration;@@ -44,6 +44,9 @@ const REPLAY_GRACE: Duration = Duration::from_millis(300);/// can trail its `session/prompt` response by this much.const TURN_GRACE: Duration = Duration::from_millis(100);const STDERR_LINES: usize = 20;+/// An agent idle this long after its turn is stopped when it can reload its session+/// (`session/load`): the next message starts it again where it left off.+const IDLE_RELEASE: Duration = Duration::from_secs(5 * 60);/// Updates of a session's state rather than its conversation.const SESSION_STATE: [&str; 5] =["session_info_update", "config_option_update", "current_mode_update", "available_commands_update", "usage_update"];@@ -92,6 +95,8 @@ struct Shared {providers: RwLock<Vec<provider::ProviderSpec>>,/// Last probe of each provider.probes: Mutex<HashMap<String, AgentProbe>>,+ /// [`IDLE_RELEASE`], in milliseconds (shorter in tests).+ idle_release_ms: AtomicU64,}/// What an agent offered in its last session, for the New Task page.@@ -207,6 +212,8 @@ struct Live {capabilities: AgentCapabilities,/// `promptCapabilities.embeddedContext`: referenced files are sent with their text.embedded: bool,+ /// `session/load`: the process can be stopped between turns and the session reloaded.+ resumable: bool,}struct Task {@@ -228,6 +235,8 @@ struct Task {cancel_pending: AtomicBool,/// The agent reported something for the current turn.turn_started: AtomicBool,+ /// Turns sent so far: an idle release scheduled before the latest one is void.+ turns: AtomicU64,/// Settings already sent this session (`(option, value)`), so a refusal is not retried.config_sent: Mutex<HashSet<(String, String)>>,dirty: Mutex<BTreeSet<(Session, usize)>>,@@ -238,6 +247,11 @@ struct Task {}impl AgentManager {+ #[cfg(test)]+ fn set_idle_release(&self, delay: Duration) {+ self.shared.idle_release_ms.store(delay.as_millis() as u64, Ordering::Relaxed);+ }+/// Loads the project's saved tasks. Spawned work runs on `runtime`.pub fn new(paths: AgentPaths, runtime: tokio::runtime::Handle) -> Self {let connector: Connector = Arc::new(|spec, cwd, client, on_stderr| match spec.driver {@@ -262,6 +276,7 @@ impl AgentManager {known: Mutex::new(known),providers,probes: Mutex::new(HashMap::new()),+ idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),});let mut tasks = HashMap::new();for file in std::fs::read_dir(&shared.paths.store_dir).into_iter().flatten().flatten() {@@ -888,6 +903,7 @@ impl Task {send_now: AtomicBool::new(false),cancel_pending: AtomicBool::new(false),turn_started: AtomicBool::new(false),+ turns: AtomicU64::new(0),config_sent: Mutex::new(HashSet::new()),dirty: Mutex::new(BTreeSet::new()),flush_scheduled: AtomicBool::new(false),@@ -1030,12 +1046,42 @@ impl Task {}match (next, result) {(Some(queued), _) => prompt = queued.prompt,- (None, Ok(_)) => return self.set_status(AgentStatus::Ready, None),+ (None, Ok(_)) => {+ self.set_status(AgentStatus::Ready, None);+ return self.release_when_idle();+ }(None, Err(failure)) => return self.fail(failure),}}}+ /// Stops the agent's process once the task has stayed idle for [`IDLE_RELEASE`], so+ /// finished tasks don't keep an agent (and what it started) running. Only an agent that+ /// reloads its session: the next message starts it again with the conversation intact.+ fn release_when_idle(self: &Arc<Self>) {+ let turn = self.turns.load(Ordering::Acquire);+ let delay = Duration::from_millis(self.shared.idle_release_ms.load(Ordering::Relaxed));+ let task = Arc::downgrade(self);+ self.shared.runtime.spawn(async move {+ tokio::time::sleep(delay).await;+ let Some(task) = task.upgrade() else { return };+ if task.turns.load(Ordering::Acquire) != turn+ || task.state.lock().busy+ || !task.permissions.lock().is_empty()+ {+ return;+ }+ let live = {+ let mut live = task.live.lock();+ if live.as_ref().is_some_and(|l| l.resumable && !l.peer.is_closed()) { live.take() } else { None }+ };+ if let Some(live) = live {+ tracing::debug!("agent task {}: idle, stopping the agent until the next message", task.id);+ live.peer.kill();+ }+ });+ }+/// Ends a turn that failed: nothing it started stays open.fn fail(self: &Arc<Self>, failure: Failure) {self.cancel_permissions();@@ -1096,6 +1142,7 @@ impl Task {/// Sends one prompt, starting the agent first if needed; returns the stop reason.async fn turn(self: &Arc<Self>, prompt: &AgentPrompt) -> Result<String, Failure> {+ self.turns.fetch_add(1, Ordering::AcqRel);self.turn_started.store(false, Ordering::Release);self.state.lock().task.resets_ms = None;let attachments = prompt@@ -1292,7 +1339,7 @@ impl Task {}self.persist();self.emit_task();- let live = Live { peer, session: session_id, capabilities, embedded };+ let live = Live { peer, session: session_id, capabilities, embedded, resumable: can_load };*self.live.lock() = Some(live.clone());Ok(live)}diff --git a/crates/ide-agent/src/native/claude/cli.rs b/crates/ide-agent/src/native/claude/cli.rsindex fca21d858..26e3204e1 100644--- a/crates/ide-agent/src/native/claude/cli.rs+++ b/crates/ide-agent/src/native/claude/cli.rs@@ -98,6 +98,8 @@ impl Cli for Process {use std::process::Stdio;let mut cmd = tokio::process::Command::new(&l.program);ide_core::process::prepare(cmd.as_std_mut());+ // `claude` may be a wrapper (`claude.cmd` → node): stopping it stops what it started.+ ide_core::process::own_group(cmd.as_std_mut());cmd.args(&l.args).current_dir(&l.cwd).envs(ide_core::process::shell_env())@@ -120,6 +122,9 @@ impl Cli for Process {tokio::select! {_ = child.wait() => {}_ = token.cancelled() => {+ if let Some(pid) = child.id() {+ let _ = tokio::task::spawn_blocking(move || ide_core::process::kill_tree_of(pid)).await;+ }let _ = child.start_kill();let _ = child.wait().await;}diff --git a/crates/ide-agent/src/tests.rs b/crates/ide-agent/src/tests.rsindex eb64fd67c..e33338a77 100644--- a/crates/ide-agent/src/tests.rs+++ b/crates/ide-agent/src/tests.rs@@ -9,6 +9,8 @@ struct FakeAgent {/// Every connection's agent side, kept open.servers: Mutex<Vec<Peer>>,calls: Mutex<Vec<String>>,+ /// Without `loadSession` (a session lives only as long as its process).+ no_load: bool,}impl FakeAgent {@@ -89,7 +91,7 @@ impl Handler for FakeAgent {if params.pointer("/clientCapabilities/subagents").is_some_and(Value::is_object) {self.calls.lock().push("subagents".into());}- Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": true,+ Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": !self.no_load,"sessionCapabilities": {"fork": {}}, "_meta": {"openidea": {"rollback": true, "steer": true}}}}))}"session/new" => Ok(json!({"sessionId": "s1",@@ -1054,3 +1056,56 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notiflet probe = mgr.probe("copilot", false).await.unwrap();assert!(probe.error.is_none());}++#[tokio::test(flavor = "multi_thread")]+async fn idle_agents_stop_and_resume_their_session_on_the_next_message() {+ let new = || NewAgentTask {+ project_root: None,+ prompt: text("again"),+ provider: "claude".into(),+ config: Vec::new(),+ isolation: Isolation::Local,+ base: None,+ };+ let live =+ |mgr: &AgentManager, id: &str| mgr.task(id).unwrap().live.lock().as_ref().is_some_and(|l| !l.peer.is_closed());++ let tmp = tempfile::tempdir().unwrap();+ let agent = Arc::new(FakeAgent::default());+ let mgr = manager(tmp.path(), agent.clone());+ mgr.set_idle_release(Duration::from_millis(200));+ let task = mgr.create(new()).await.unwrap();+ wait_for(&mgr, &task.id, AgentStatus::Ready).await;+ assert!(live(&mgr, &task.id));+ // The process is stopped once the task stays idle…+ tokio::time::sleep(Duration::from_millis(600)).await;+ assert!(!live(&mgr, &task.id));+ assert!(agent.servers.lock()[0].is_closed(), "its connection is closed");+ assert_eq!(mgr.task(&task.id).unwrap().state.lock().task.status, AgentStatus::Ready, "not an error");+ // …and the next message starts it again on the same session.+ mgr.prompt(&task.id, text("again"), false).await.unwrap();+ wait_for(&mgr, &task.id, AgentStatus::Ready).await;+ assert!(agent.calls.lock().contains(&"session/load".to_owned()));+ assert_eq!(+ mgr.entries(&task.id, None).unwrap().iter().filter(|e| matches!(e, AgentEntry::Agent { .. })).count(),+ 2+ );++ // A new turn before the delay ran out keeps the agent.+ mgr.prompt(&task.id, text("again"), false).await.unwrap();+ tokio::time::sleep(Duration::from_millis(100)).await;+ wait_for(&mgr, &task.id, AgentStatus::Ready).await;+ assert!(live(&mgr, &task.id));+ mgr.shutdown();++ // An agent that can't reload its session keeps running: stopping it would lose the conversation.+ let tmp = tempfile::tempdir().unwrap();+ let agent = Arc::new(FakeAgent { no_load: true, ..FakeAgent::default() });+ let mgr = manager(tmp.path(), agent.clone());+ mgr.set_idle_release(Duration::from_millis(200));+ let task = mgr.create(new()).await.unwrap();+ wait_for(&mgr, &task.id, AgentStatus::Ready).await;+ tokio::time::sleep(Duration::from_millis(600)).await;+ assert!(live(&mgr, &task.id));+ mgr.shutdown();+}diff --git a/crates/ide-core/src/process.rs b/crates/ide-core/src/process.rsindex b7a74e44f..49565b3da 100644--- a/crates/ide-core/src/process.rs+++ b/crates/ide-core/src/process.rs@@ -53,6 +53,31 @@ pub fn kill_tree(child: &mut Child) {let _ = child.wait();}+/// [`kill_tree`] for a child known by its process id (a `tokio` child): `SIGKILL` to its+/// process group (spawn it with [`own_group`]) or `taskkill /T /F`. Call it before the child+/// is reaped, so the id still names it. The child itself is left to its owner to kill and reap.+pub fn kill_tree_of(pid: u32) {+ #[cfg(unix)]+ if let Ok(pid) = libc::pid_t::try_from(pid) {+ // SAFETY: plain syscall; see `signal_group`.+ unsafe {+ libc::kill(-pid, libc::SIGKILL);+ }+ }+ #[cfg(windows)]+ {+ let mut taskkill = Command::new("taskkill");+ prepare(&mut taskkill)+ .args(["/T", "/F", "/PID", &pid.to_string()])+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null());+ let _ = taskkill.status();+ }+ #[cfg(not(any(unix, windows)))]+ let _ = pid;+}+/// [`kill_tree`] that first asks the group to exit: `SIGTERM`, then `grace`, then `SIGKILL`./// Git removes its `index.lock` on `SIGTERM`, where `SIGKILL` leaves it behind and the next/// git command fails. Windows has no such signal to send from outside the child's console,@@ -395,6 +420,28 @@ fn append_path_entries(path: &OsStr, extra: &OsStr) -> OsString {mod tests {use super::*;+ #[cfg(unix)]+ #[test]+ fn kill_tree_of_reaches_what_the_child_started() {+ use std::io::BufRead;+ let mut cmd = Command::new("sh");+ own_group(&mut cmd).args(["-c", "sleep 30 & echo $!; wait"]).stdout(std::process::Stdio::piped());+ let mut child = cmd.spawn().unwrap();+ let mut line = String::new();+ std::io::BufReader::new(child.stdout.take().unwrap()).read_line(&mut line).unwrap();+ let grandchild: libc::pid_t = line.trim().parse().unwrap();+ let alive = |pid: libc::pid_t| unsafe { libc::kill(pid, 0) } == 0;+ assert!(alive(grandchild));+ kill_tree_of(child.id());+ let _ = child.wait();+ // Reparented to init once its parent is gone, which reaps it.+ let gone = (0..100).any(|_| {+ std::thread::sleep(Duration::from_millis(20));+ !alive(grandchild)+ });+ assert!(gone, "the grandchild {grandchild} survived");+ }+#[cfg(windows)]#[test]fn user_path_reads_the_current_users_path() {diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex 63d69ae8c..82e4b0579 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -494,12 +494,14 @@ impl Host {ide_agent::AgentPaths {project_root: root.to_path_buf(),store_dir: self.data_dir.join("agents").join(project_key),- // Outside the app data dir: its path has spaces on macOS, which trips up build scripts.- worktrees_dir: dirs::home_dir()- .unwrap_or_else(|| self.data_dir.clone())- .join(".openidea")- .join("worktrees")- .join(project_key),+ worktrees_dir: agent_worktrees_dir(root, || {+ // Outside the app data dir: its path has spaces on macOS, which trips up build scripts.+ dirs::home_dir()+ .unwrap_or_else(|| self.data_dir.clone())+ .join(".openidea")+ .join("worktrees")+ .join(project_key)+ }),models_file: self.data_dir.join("agents").join("models.json"),custom_agents_dir: Some(self.config_dir.join("agents")),home_dir: dirs::home_dir(),@@ -1004,6 +1006,20 @@ fn content_root_watcher(.ok()}+/// Where agent tasks create their worktrees: next to the project, `<parent>/<name>.worktrees`,+/// so they sit on the project's drive and outside its tree (not indexed, watched or shown in+/// its git status); `fallback` for a project at a filesystem root.+fn agent_worktrees_dir(root: &Path, fallback: impl FnOnce() -> PathBuf) -> PathBuf {+ match (root.parent(), root.file_name()) {+ (Some(parent), Some(name)) => {+ let mut dir = name.to_os_string();+ dir.push(".worktrees");+ parent.join(dir)+ }+ _ => fallback(),+ }+}+pub(crate) fn unlinked_maven_poms(root: &Path, settings: &ide_core::settings::Settings) -> Vec<PathBuf> {ide_build::maven::UnlinkedProjects::load(root, &settings.languages.java.maven).poms().map(PathBuf::from).collect()}@@ -1279,3 +1295,17 @@ mod workspace_edit_tests {assert_eq!(documents.snapshot(doc.id).unwrap().text, "sum_values();\n");}}++#[cfg(test)]+mod agent_worktree_tests {+ use super::agent_worktrees_dir;+ use std::path::{Path, PathBuf};++ #[test]+ fn agent_worktrees_sit_next_to_the_project() {+ let fallback = || PathBuf::from("/home/me/.openidea/worktrees/key");+ let project = Path::new("/work").join("acme-api");+ assert_eq!(agent_worktrees_dir(&project, fallback), Path::new("/work").join("acme-api.worktrees"));+ assert_eq!(agent_worktrees_dir(Path::new("/"), fallback), fallback());+ }+}diff --git a/crates/ide-jsonrpc/src/lib.rs b/crates/ide-jsonrpc/src/lib.rsindex b7af9fcfc..c04331ad9 100644--- a/crates/ide-jsonrpc/src/lib.rs+++ b/crates/ide-jsonrpc/src/lib.rs@@ -384,6 +384,9 @@ impl Peer {let resolved = resolve_spawn_program(command, env);let mut cmd = tokio::process::Command::new(&resolved);ide_core::process::prepare(cmd.as_std_mut());+ // Wrappers (`npx`, `codex.cmd`, launcher scripts) start the real server as a child:+ // stopping the connection stops the whole tree.+ ide_core::process::own_group(cmd.as_std_mut());cmd.args(args).current_dir(cwd).envs(ide_core::process::shell_env())@@ -422,6 +425,9 @@ impl Peer {let (status, killed) = tokio::select! {status = child.wait() => (status.ok(), false),_ = inner.kill.cancelled() => {+ if let Some(pid) = child.id() {+ let _ = tokio::task::spawn_blocking(move || ide_core::process::kill_tree_of(pid)).await;+ }let _ = child.start_kill();(child.wait().await.ok(), true)}diff --git a/src/features/agents/HomeEditor.tsx b/src/features/agents/HomeEditor.tsxindex e12ef1e29..e909aa5e4 100644--- a/src/features/agents/HomeEditor.tsx+++ b/src/features/agents/HomeEditor.tsx@@ -165,7 +165,7 @@ export function HomeEditor({ docked = false }: { docked?: boolean; input?: Editodetail: tx("edits your files directly"),},]}- onChange={(isolation) => updateDraft({ isolation })}+ onChange={(isolation) => updateDraft({ isolation, isolationChosen: true })}/>)}{isolation === "local" && current && (diff --git a/src/features/agents/draft.test.ts b/src/features/agents/draft.test.tsnew file mode 100644index 000000000..1553504c2--- /dev/null+++ b/src/features/agents/draft.test.ts@@ -0,0 +1,13 @@+import { expect, it } from "vitest";+import { savedDraft } from "./store";++it("runs tasks in the local checkout unless the user picked a worktree", () => {+ expect(savedDraft({}).isolation).toBe("local");+ // Saved before the choice was recorded: `worktree` was only the old default.+ expect(savedDraft({ provider: "codex", isolation: "worktree" })).toMatchObject({+ provider: "codex",+ isolation: "local",+ });+ expect(savedDraft({ isolation: "worktree", isolationChosen: true }).isolation).toBe("worktree");+ expect(savedDraft({ isolation: "local", isolationChosen: true }).isolation).toBe("local");+});diff --git a/src/features/agents/store.ts b/src/features/agents/store.tsindex f22a72237..4bb32f11f 100644--- a/src/features/agents/store.ts+++ b/src/features/agents/store.ts@@ -38,6 +38,8 @@ export interface Draft {/** Settings chosen for the next task, by option id (reset when the agent changes). */config: Record<string, string>;isolation: Isolation;+ /** The user picked `isolation`: otherwise a task runs in the local checkout. */+ isolationChosen?: boolean;/** `null`: the current branch. */base: string | null;}@@ -99,7 +101,16 @@ function save(key: string, value: unknown) {}}-const fallbackDraft: Draft = { provider: "claude", config: {}, isolation: "worktree", base: null };+const fallbackDraft: Draft = { provider: "claude", config: {}, isolation: "local", base: null };++/**+ * The saved New Task settings. A worktree is used only when the user picked it: drafts+ * saved before that choice was recorded carried the old default (`worktree`) instead.+ */+export function savedDraft(saved: Partial<Draft>): Draft {+ const draft = { ...fallbackDraft, ...saved };+ return draft.isolationChosen ? draft : { ...draft, isolation: "local" };+}export const useAgents = create<AgentsState>(() => ({loaded: false,@@ -110,7 +121,7 @@ export const useAgents = create<AgentsState>(() => ({changes: new Map(),providers: [],limits: new Map(),- draft: { ...fallbackDraft, ...load<Partial<Draft>>(DRAFT_KEY, {}) },+ draft: savedDraft(load<Partial<Draft>>(DRAFT_KEY, {})),composers: new Map(),lastComposer: HOME,history: load<string[]>(HISTORY_KEY, []),