test(agents): find the working indicator in the tray below the conversation

The Hierarchy tool window's content tab had no close button, so a type or
call hierarchy stayed until another one replaced it. The tab is closable
now; closing it clears the tree and hides the tool window, which has no
other content.

Refs #2471

crates/ide-extension/Cargo.toml

@@ -18,6 +18,7 @@ semver = "1"
 blake3.workspace = true
 zip.workspace = true
 base64.workspace = true
+dunce.workspace = true
 ed25519-dalek = "3"
 
 [dev-dependencies]

crates/ide-extension/src/ledger.rs

@@ -441,11 +441,13 @@ pub fn resolve_program(name: &str, path_var: Option<&OsStr>) -> Result<PathBuf,
 /// `p` with its parent canonicalized but the file name as found: PATH
 /// entries like `/var` → `/private/var` (macOS) or `~` links collapse to
 /// their real directory, while a linked program (`cargo` → rustup) keeps
-/// its link name so the shim still dispatches on argv[0].
+/// its link name so the shim still dispatches on argv[0]. `dunce` keeps the
+/// path in its usual form on Windows: a `\\?\`-prefixed pin would never
+/// match the path the program was actually started with.
 fn canonical_dir(p: &Path) -> PathBuf {
     let Some(dir) = p.parent() else { return p.to_path_buf() };
     let Some(name) = p.file_name() else { return p.to_path_buf() };
-    std::fs::canonicalize(dir).map(|d| d.join(name)).unwrap_or_else(|_| p.to_path_buf())
+    dunce::canonicalize(dir).map(|d| d.join(name)).unwrap_or_else(|_| p.to_path_buf())
 }
 
 fn is_executable(p: &Path) -> bool {
@@ -498,6 +500,20 @@ mod tests {
         list.iter().map(|s| s.parse().unwrap()).collect()
     }
 
+    #[test]
+    #[cfg(windows)]
+    fn pinned_program_path_has_no_verbatim_prefix() {
+        // std::fs::canonicalize returns \\?\-prefixed paths on Windows; a pin
+        // stored in that form would never match the plain path the program is
+        // started with. dunce keeps the usual form.
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::write(dir.path().join("cargo.exe"), b"").unwrap();
+        let pinned = resolve_program("cargo.exe", Some(dir.path().as_os_str())).unwrap();
+        let shown = pinned.to_string_lossy();
+        assert!(!shown.starts_with(r"\\?\"), "verbatim prefix leaked into the pin: {shown}");
+        assert!(pinned.is_absolute());
+    }
+
     fn req<'a>(version: &'a str, hash: &'a str, required: &[&str], optional: &[&str]) -> Request<'a> {
         Request {
             subject: Subject::Installed("p".into()),

crates/ide-http/src/env.rs

@@ -52,6 +52,8 @@ fn search_dirs(file: Option<&Path>, root: Option<&Path>) -> Vec<PathBuf> {
 }
 
 fn parse_env(text: &str) -> IdeResult<EnvMap> {
+    // Editors on Windows (Notepad) save UTF-8 with a byte order mark, which serde_json rejects.
+    let text = text.strip_prefix('\u{feff}').unwrap_or(text);
     let value: serde_json::Value =
         serde_json::from_str(text).map_err(|e| IdeError::invalid(format!("invalid environment file: {e}")))?;
     let mut out = EnvMap::new();
@@ -262,4 +264,12 @@ mod tests {
         let envs = Environments::load(Some(&other.path().join("s.http")), Some(root)).unwrap();
         assert_eq!(envs.names(), vec!["dev"]);
     }
+
+    #[test]
+    fn reads_env_files_saved_with_a_byte_order_mark() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join(PUBLIC_FILE), "\u{feff}{\"dev\":{\"host\":\"h\"}}").unwrap();
+        let envs = Environments::load(Some(&tmp.path().join("a.http")), Some(tmp.path())).unwrap();
+        assert_eq!(envs.names(), vec!["dev"]);
+    }
 }

crates/ide-ssh/src/secrets.rs

@@ -101,6 +101,22 @@ fn new_id() -> String {
     uuid::Uuid::new_v4().to_string()
 }
 
+/// Runs a credential-store operation off the async runtime.
+///
+/// The Linux Secret Service client is blocking (`zbus`) and starts a runtime of
+/// its own; calling it while a runtime already drives the current thread panics
+/// with "Cannot start a runtime from within a runtime". The store may also wait
+/// on an OS prompt, so run it on a plain thread when called from async code.
+fn off_runtime<R: Send>(f: impl FnOnce() -> R + Send) -> R {
+    if tokio::runtime::Handle::try_current().is_err() {
+        return f();
+    }
+    std::thread::scope(|scope| match scope.spawn(f).join() {
+        Ok(value) => value,
+        Err(panic) => std::panic::resume_unwind(panic),
+    })
+}
+
 impl SecretFile {
     pub fn new(path: PathBuf) -> Self {
         Self::with_legacy(path, |v| serde_json::from_value(v).ok())
@@ -115,85 +131,95 @@ impl SecretFile {
     }
 
     pub fn get(&self, key: &str) -> Option<String> {
-        let _g = LOCK.lock();
-        match self.load() {
-            Contents::Index(mut index) if index.keys.contains(key) => match self.vault.get(&service(&index.id), key) {
-                Ok(secret) => Some(secret),
-                Err(StoreError::NoEntry) => {
-                    // Removed outside the app: stop listing it.
-                    index.keys.remove(key);
-                    self.write_logged(&index);
-                    None
+        off_runtime(|| {
+            let _g = LOCK.lock();
+            match self.load() {
+                Contents::Index(mut index) if index.keys.contains(key) => {
+                    match self.vault.get(&service(&index.id), key) {
+                        Ok(secret) => Some(secret),
+                        Err(StoreError::NoEntry) => {
+                            // Removed outside the app: stop listing it.
+                            index.keys.remove(key);
+                            self.write_logged(&index);
+                            None
+                        }
+                        Err(e) => {
+                            tracing::warn!("saved passwords: {key}: {e}");
+                            None
+                        }
+                    }
                 }
-                Err(e) => {
-                    tracing::warn!("saved passwords: {key}: {e}");
-                    None
-                }
-            },
-            Contents::Index(_) => None,
-            Contents::Plaintext(mut old, _) => old.remove(key),
-        }
+                Contents::Index(_) => None,
+                Contents::Plaintext(mut old, _) => old.remove(key),
+            }
+        })
     }
 
     pub fn set(&self, key: &str, secret: &str) -> IdeResult<()> {
-        let _g = LOCK.lock();
-        let mut index = match self.load() {
-            Contents::Index(index) => index,
-            Contents::Plaintext(_, why) => return Err(unavailable(&why)),
-        };
-        let service = service(&index.id);
-        self.vault.set(&service, key, secret).map_err(|e| unavailable(&e.to_string()))?;
-        if index.keys.insert(key.to_owned())
-            && let Err(e) = self.write(&index)
-        {
-            let _ = self.vault.delete(&service, key);
-            return Err(e);
-        }
-        Ok(())
+        off_runtime(|| {
+            let _g = LOCK.lock();
+            let mut index = match self.load() {
+                Contents::Index(index) => index,
+                Contents::Plaintext(_, why) => return Err(unavailable(&why)),
+            };
+            let service = service(&index.id);
+            self.vault.set(&service, key, secret).map_err(|e| unavailable(&e.to_string()))?;
+            if index.keys.insert(key.to_owned())
+                && let Err(e) = self.write(&index)
+            {
+                let _ = self.vault.delete(&service, key);
+                return Err(e);
+            }
+            Ok(())
+        })
     }
 
     pub fn delete(&self, key: &str) {
-        let _g = LOCK.lock();
-        match self.load() {
-            Contents::Index(mut index) => {
-                if !index.keys.contains(key) {
-                    return;
+        off_runtime(|| {
+            let _g = LOCK.lock();
+            match self.load() {
+                Contents::Index(mut index) => {
+                    if !index.keys.contains(key) {
+                        return;
+                    }
+                    match self.vault.delete(&service(&index.id), key) {
+                        Ok(()) | Err(StoreError::NoEntry) => {}
+                        Err(e) => {
+                            // Kept in the index so that the next delete tries again.
+                            tracing::warn!("saved passwords: could not forget {key}: {e}");
+                            return;
+                        }
+                    }
+                    index.keys.remove(key);
+                    self.write_logged(&index);
                 }
-                match self.vault.delete(&service(&index.id), key) {
-                    Ok(()) | Err(StoreError::NoEntry) => {}
-                    Err(e) => {
-                        // Kept in the index so that the next delete tries again.
+                Contents::Plaintext(mut old, _) => {
+                    if old.remove(key).is_none() {
+                        return;
+                    }
+                    // A move halfway may have copied it already.
+                    if let Some(id) = self.pending_id()
+                        && let Err(e) = self.vault.delete(&service(&id), key)
+                        && !matches!(e, StoreError::NoEntry)
+                    {
                         tracing::warn!("saved passwords: could not forget {key}: {e}");
                         return;
                     }
+                    self.write_logged(&old);
                 }
-                index.keys.remove(key);
-                self.write_logged(&index);
             }
-            Contents::Plaintext(mut old, _) => {
-                if old.remove(key).is_none() {
-                    return;
-                }
-                // A move halfway may have copied it already.
-                if let Some(id) = self.pending_id()
-                    && let Err(e) = self.vault.delete(&service(&id), key)
-                    && !matches!(e, StoreError::NoEntry)
-                {
-                    tracing::warn!("saved passwords: could not forget {key}: {e}");
-                    return;
-                }
-                self.write_logged(&old);
-            }
-        }
+        })
     }
 
     /// Every stored key, sorted (the secrets themselves stay private).
     pub fn keys(&self) -> Vec<String> {
-        let _g = LOCK.lock();
-        match self.load() {
-            Contents::Index(index) => index.keys.into_iter().collect(),
-            Contents::Plaintext(old, _) => old.into_keys().collect(),
-        }
+        off_runtime(|| {
+            let _g = LOCK.lock();
+            match self.load() {
+                Contents::Index(index) => index.keys.into_iter().collect(),
+                Contents::Plaintext(old, _) => old.into_keys().collect(),
+            }
+        })
     }
 
     fn load(&self) -> Contents {
@@ -558,4 +584,50 @@ mod tests {
             assert_eq!(mode & 0o777, 0o600);
         }
     }
+
+    /// A credential store that behaves like the Linux Secret Service client:
+    /// its blocking API runs a tokio runtime.
+    #[derive(Default)]
+    struct NestedRuntimeVault {
+        entries: Mutex<HashMap<(String, String), String>>,
+    }
+
+    fn nested_runtime() {
+        tokio::runtime::Builder::new_multi_thread().build().expect("a nested runtime").block_on(async {});
+    }
+
+    impl Vault for NestedRuntimeVault {
+        fn available(&self) -> bool {
+            true
+        }
+        fn get(&self, service: &str, key: &str) -> StoreResult<String> {
+            nested_runtime();
+            self.entries.lock().get(&(service.to_owned(), key.to_owned())).cloned().ok_or(StoreError::NoEntry)
+        }
+        fn set(&self, service: &str, key: &str, secret: &str) -> StoreResult<()> {
+            nested_runtime();
+            self.entries.lock().insert((service.to_owned(), key.to_owned()), secret.to_owned());
+            Ok(())
+        }
+        fn delete(&self, service: &str, key: &str) -> StoreResult<()> {
+            nested_runtime();
+            self.entries.lock().remove(&(service.to_owned(), key.to_owned())).map(|_| ()).ok_or(StoreError::NoEntry)
+        }
+    }
+
+    /// Saving a password from a Tauri command runs on a tokio runtime; the
+    /// Secret Service's blocking client starts a runtime of its own and panics
+    /// when both share a thread ("Cannot start a runtime from within a runtime").
+    #[tokio::test(flavor = "multi_thread")]
+    async fn credential_store_access_leaves_the_async_runtime_first() {
+        let tmp = tempfile::tempdir().unwrap();
+        let vault = Arc::new(NestedRuntimeVault::default());
+        let file =
+            SecretFile::with_vault(tmp.path().join("db-passwords.json"), |v| serde_json::from_value(v).ok(), vault);
+        file.set("s1", "hunter2").unwrap();
+        assert_eq!(file.get("s1").as_deref(), Some("hunter2"));
+        assert_eq!(file.keys(), ["s1"]);
+        file.delete("s1");
+        assert_eq!(file.get("s1"), None);
+    }
 }

e2e/agentScroll.spec.ts

@@ -66,6 +66,79 @@ async function openHistory(page: Page) {
   return stream;
 }
 
+for (const placement of ["editor", "toolWindow"] as const) {
+  test(`lets small upward wheel steps leave the end while replies stream in the ${placement}`, async ({ page }) => {
+    const stream = await openHistory(page);
+    await page.evaluate(
+      async ({ id, placement }) => {
+        const path = "/src/features/agents/store.ts";
+        const store = await import(path);
+        const state = store.useAgents.getState();
+        store.useAgents.setState({
+          tasks: new Map(state.tasks).set(id, { ...state.tasks.get(id)!, status: "running" }),
+        });
+        if (placement === "toolWindow") store.dockTask(id);
+      },
+      { id: task.id, placement },
+    );
+    // The working indicator sits in the tray below the conversation.
+    await expect(
+      page.getByRole("status").getByText("Working…", { exact: true }).filter({ visible: true }),
+    ).toBeVisible();
+    await expect(stream.locator(":scope > *")).toHaveCount(80 * 3);
+    await expect.poll(() => stream.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop)).toBeLessThan(2);
+    const timer = await page.evaluate(async (id) => {
+      const path = "/src/features/agents/store.ts";
+      const store = await import(path);
+      const el = [...document.querySelectorAll<HTMLElement>("[class*='_stream_']")].find((el) => el.offsetHeight)!;
+      el.addEventListener(
+        "wheel",
+        () => {
+          el.dataset.streamWheelStart = String(el.scrollTop);
+        },
+        { capture: true, once: true },
+      );
+      let chunks = 0;
+      return window.setInterval(() => {
+        const state = store.useAgents.getState();
+        const entries = state.entries.get(id)!.slice();
+        const last = entries.at(-1)!;
+        if (last.type !== "agent") throw new Error("Expected a streaming reply");
+        entries[entries.length - 1] = { ...last, text: `${last.text}\n\nStreaming chunk ${++chunks}` };
+        store.useAgents.setState({ entries: new Map(state.entries).set(id, entries) });
+        el.dataset.streamChunks = String(chunks);
+      }, 40);
+    }, task.id);
+    const chunks = async () => Number(await stream.getAttribute("data-stream-chunks"));
+    try {
+      await stream.hover();
+      for (let i = 0; i < 8; i++) {
+        const previous = await chunks();
+        await page.mouse.wheel(0, -12);
+        await expect.poll(chunks).toBeGreaterThan(previous);
+      }
+      const top = await stream.evaluate((el) => el.scrollTop);
+      expect(Number(await stream.getAttribute("data-stream-wheel-start")) - top).toBeGreaterThan(80);
+      const previous = await chunks();
+      await expect.poll(chunks).toBeGreaterThan(previous + 3);
+      expect(Math.abs((await stream.evaluate((el) => el.scrollTop)) - top)).toBeLessThanOrEqual(1);
+      const jump = page.getByRole("button", { name: "Jump to Latest" });
+      await expect(jump).toBeVisible();
+      await jump.click();
+      await expect
+        .poll(() => stream.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
+        .toBeLessThan(2);
+      const resumed = await chunks();
+      await expect.poll(chunks).toBeGreaterThan(resumed + 3);
+      await expect
+        .poll(() => stream.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
+        .toBeLessThan(2);
+    } finally {
+      await page.evaluate((timer) => window.clearInterval(timer), timer);
+    }
+  });
+}
+
 for (const selected of [false, true]) {
   test(`keeps long-chat scroll geometry stable while jumping through history (selected: ${selected})`, async ({
     page,

src/editor/lsp/semantic/kotlin/index.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { Text } from "@codemirror/state";
+import { Tree } from "@lezer/common";
 import { semanticRanges } from "../index";
 
 describe("Kotlin semantic tokens", () => {
@@ -42,4 +43,42 @@ describe("Kotlin semantic tokens", () => {
       )[0]?.className,
     ).toBe("cm-sem-property");
   });
+
+  it("colours annotation names as annotations, not as the constructor calls the server reports", () => {
+    const lines = [
+      '@Column(name = "x")',
+      "@field:Inject @Outer.Inner",
+      "list.forEach { return@forEach }",
+      "[email protected]()",
+    ];
+    const doc = Text.of(lines);
+    const types = ["method", "class", "label"];
+    const tok = (line: number, word: string, type: string) => [
+      line,
+      lines[line]!.lastIndexOf(word),
+      word.length,
+      types.indexOf(type),
+      0,
+    ];
+    const data = [
+      tok(0, "Column", "method"),
+      tok(1, "Inject", "class"),
+      tok(1, "Outer", "class"),
+      tok(1, "Inner", "class"),
+      tok(2, "forEach", "label"),
+      tok(3, "Outer", "class"),
+    ].flat();
+    const tokens = { tokenTypes: types, tokenModifiers: [], data };
+    const ranges = semanticRanges(doc, tokens, false, "kotlin", Tree.empty);
+    const classOf = (line: number, word: string) => {
+      const from = doc.line(line + 1).from + lines[line]!.lastIndexOf(word);
+      return ranges.find((r) => r.from === from)?.className;
+    };
+    expect(classOf(0, "Column")).toBe("cm-sem-annotation");
+    expect(classOf(1, "Inject")).toBe("cm-sem-annotation");
+    expect(classOf(1, "Outer")).toBe("cm-sem-annotation");
+    expect(classOf(1, "Inner")).toBe("cm-sem-annotation");
+    expect(classOf(2, "forEach")).toBe("cm-sem-constant");
+    expect(classOf(3, "Outer")).not.toBe("cm-sem-annotation");
+  });
 });

src/editor/lsp/semantic/kotlin/index.ts

@@ -1,7 +1,49 @@
+import type { Text } from "@codemirror/state";
 import { registerLanguageSemantics, type LanguageSemantics } from "../languages";
 
+const NAME = /[A-Za-z_][\w]*/y;
+
+/**
+ * The names of annotation usages (`@Column`, `@field:Column`, `@Outer.Inner`), as `"from:to"` → `"annotation"`.
+ * An `@` right after a name is a label (`return@forEach`, `this@Outer`, `loop@`), not an annotation.
+ */
+function annotationNames(doc: Text): Map<string, string> {
+  const out = new Map<string, string>();
+  const text = doc.toString();
+  for (let at = text.indexOf("@"); at >= 0; at = text.indexOf("@", at + 1)) {
+    if (/[\w`]/.test(text[at - 1] ?? "")) continue;
+    let pos = at + 1;
+    const name = () => {
+      NAME.lastIndex = pos;
+      const m = NAME.exec(text);
+      return m ? { from: pos, to: pos + m[0].length } : null;
+    };
+    let first = name();
+    // A use-site target (`@field:`, `@get:`, `@file:`) precedes the annotation's name.
+    if (first && text[first.to] === ":" && text[first.to + 1] !== ":") {
+      pos = first.to + 1;
+      first = name();
+    }
+    for (let part = first; part;) {
+      out.set(`${part.from}:${part.to}`, "annotation");
+      if (text[part.to] !== ".") break;
+      pos = part.to + 1;
+      part = name();
+    }
+  }
+  return out;
+}
+
 const kotlinSemantics: LanguageSemantics = {
-  tokenClasses({ type, modifiers, classes }) {
+  symbolKinds: (_tree, doc) => annotationNames(doc),
+  tokenClasses({ type, modifiers, kind, classes }) {
+    // JetBrains Kotlin LSP reports an annotation usage as a constructor call (`method`);
+    // IDEA colours the name as an annotation (Metadata), like its `@`.
+    if (kind === "annotation" && type !== "label") {
+      classes.length = 0;
+      classes.push("cm-sem-annotation");
+      return;
+    }
     if (type === "operator" && modifiers.includes("declaration")) classes.push("cm-sem-function");
     // JetBrains Kotlin LSP uses `modification` for mutable declarations and references.
     if ((type === "variable" || type === "property" || type === "parameter") && modifiers.includes("modification"))

src/editor/refactor/introduce.ts

@@ -30,6 +30,7 @@ import {
   javaTypeFromHover,
   literalType,
   replacesBareStatement,
+  trailingName,
   variableDeclaration,
   type DeclContext,
   type DeclResult,
@@ -378,17 +379,17 @@ function usesSemicolons(doc: Text, statement: SyntaxNode): boolean {
 
 /** Return / declared type of a Java call or name from the server's hover, if it answers. */
 async function javaHoverType(p: Prepared, expr: SyntaxNode, text: string): Promise<string | null> {
-  const m = /([A-Za-z_$][\w$]*)\s*(\([\s\S]*\))?\s*$/.exec(text);
-  if (!m || !/method_invocation|identifier|field_access/.test(expr.kind)) return null;
+  const last = trailingName(text);
+  if (!last || !/method_invocation|identifier|field_access/.test(expr.kind)) return null;
   const { from } = rangeToOffsets(p.doc, expr.range);
-  const pos = p.doc.lineAt(from + m.index);
-  const at = { line: pos.number - 1, col: from + m.index - pos.from };
+  const pos = p.doc.lineAt(from + last.index);
+  const at = { line: pos.number - 1, col: from + last.index - pos.from };
   try {
     const hover = await Promise.race([
       call(commands.lspHover(nextRequestId(), p.ctx.doc, at)),
       new Promise<null>((resolve) => setTimeout(() => resolve(null), 1500)),
     ]);
-    return hover ? javaTypeFromHover(hover.contents.value, m[1]!) : null;
+    return hover ? javaTypeFromHover(hover.contents.value, last.name) : null;
   } catch {
     return null;
   }

src/editor/refactor/refactor.test.ts

@@ -5,6 +5,7 @@ import {
   isLiteral,
   javaConstructedType,
   javaTypeFromHover,
+  trailingName,
   literalType,
   replacesBareStatement,
   variableDeclaration,
@@ -152,6 +153,15 @@ describe("templates", () => {
     expect(isLiteral("kotlin", "identifier", "true")).toBe(true);
   });
 
+  it("finds the name a chained expression ends in, for the hover that types it", () => {
+    expect(trailingName("demo.getList().get(0)")).toEqual({ name: "get", index: 15 });
+    expect(trailingName("a.b(c(d)).e")).toEqual({ name: "e", index: 10 });
+    expect(trailingName("names()")).toEqual({ name: "names", index: 0 });
+    expect(trailingName("list.get(i) ")).toEqual({ name: "get", index: 5 });
+    expect(trailingName("(a + b)")).toBeNull();
+    expect(trailingName("x)")).toBeNull();
+  });
+
   it("reads a Java type from a jdtls hover", () => {
     expect(javaTypeFromHover("```java\nString java.lang.String.trim()\n```", "trim")).toBe("String");
     expect(javaTypeFromHover("```java\njava.util.List<java.lang.String> a.B.names()\n```", "names")).toBe(

src/editor/refactor/templates.ts

@@ -229,6 +229,27 @@ export function javaConstructedType(text: string): string | null {
   return obj[1]!.replace(/\s+/g, "");
 }
 
+/**
+ * The name an expression ends in — the last call's method (`a.b().c(0)` → `c`) or the last
+ * name (`a.b` → `b`) — with its offset in `text`. Null when it ends in something else.
+ */
+export function trailingName(text: string): { name: string; index: number } | null {
+  let end = text.trimEnd().length;
+  if (text[end - 1] === ")") {
+    // Back to the `(` that opens the trailing argument list.
+    let depth = 0;
+    let i = end - 1;
+    for (; i >= 0; i--) {
+      if (text[i] === ")") depth++;
+      else if (text[i] === "(" && --depth === 0) break;
+    }
+    if (i < 0) return null;
+    end = text.slice(0, i).trimEnd().length;
+  }
+  const m = /[A-Za-z_$][\w$]*$/.exec(text.slice(0, end));
+  return m ? { name: m[0], index: m.index } : null;
+}
+
 /**
  * Type of a Java expression from a jdtls-style hover (```java\nString java.lang.String.trim()\n```
  * or `String name`), for a call / name ending in `name`. Null when unclear.

src/features/agents/SessionEditor.tsx

@@ -543,6 +543,15 @@ interface StreamProps {
 /** Entries rendered at a time when a conversation opens at its end. */
 const ENTRY_BATCH = 40;
 
+function scrollsInside(target: EventTarget | null, root: HTMLElement): boolean {
+  for (let el = target instanceof Element ? target : null; el && el !== root; el = el.parentElement) {
+    if (el.scrollTop <= 0) continue;
+    const overflow = getComputedStyle(el).overflowY;
+    if (overflow === "auto" || overflow === "scroll") return true;
+  }
+  return false;
+}
+
 function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, findFocus, onCloseFind }: StreamProps) {
   const ref = useRef<HTMLDivElement>(null);
   useSelectionBoundary(ref);
@@ -569,6 +578,21 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
   const markUserScroll = useCallback(() => {
     userScrolled.current = performance.now();
   }, []);
+  const touchY = useRef<number | null>(null);
+  const scrollingUp = useRef(false);
+  // Release before the browser scrolls: a streamed chunk can arrive before its scroll event.
+  const stopFollowing = useCallback(
+    (target: EventTarget | null) => {
+      const el = ref.current;
+      if (!el || el.scrollHeight <= el.clientHeight || scrollsInside(target, el)) return;
+      scrollingUp.current = true;
+      if (!position.current.stick) return;
+      position.current = { top: el.scrollTop, stick: false };
+      positions.set(key, position.current);
+      setAway(true);
+    },
+    [key, positions],
+  );
   // Earlier entries are prepended above the view: remember where the first painted row is
   // so the content stays put and the scrollbar doesn't jump under the pointer.
   const anchor = useRef<{ el: Element; top: number } | null>(null);
@@ -624,7 +648,7 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
   /** A diagram that drew after the last streamed chunk grows the conversation: keep following. */
   const onDiagramDrawn = useCallback(() => {
     const el = ref.current;
-    if (el && position.current.stick) el.scrollTop = el.scrollHeight;
+    if (el && position.current.stick && !dragging.current) el.scrollTop = el.scrollHeight;
   }, []);
   useLayoutEffect(() => {
     const el = ref.current;
@@ -632,6 +656,7 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
     const truncated = entries.length < previousLength.current;
     previousLength.current = entries.length;
     if ((truncated || entries.length === 0) && el.scrollHeight - el.scrollTop - el.clientHeight < 40) {
+      scrollingUp.current = false;
       position.current = { top: el.scrollTop, stick: true };
       positions.set(key, position.current);
       setAway(false);
@@ -640,8 +665,9 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
   useLayoutEffect(() => {
     const el = ref.current;
     if (!el || entries === null || !visible) return;
-    if (position.current.stick) el.scrollTop = el.scrollHeight;
-    else if (!restored.current) el.scrollTop = position.current.top;
+    if (position.current.stick) {
+      if (!dragging.current) el.scrollTop = el.scrollHeight;
+    } else if (!restored.current) el.scrollTop = position.current.top;
     restored.current = true;
   });
   useLayoutEffect(() => {
@@ -658,7 +684,7 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
     const el = ref.current;
     if (!el) return;
     const observer = new ResizeObserver(() => {
-      if (position.current.stick) el.scrollTop = el.scrollHeight;
+      if (position.current.stick && !dragging.current) el.scrollTop = el.scrollHeight;
     });
     observer.observe(el);
     return () => {
@@ -670,7 +696,8 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
   const jumpToLatest = useCallback(() => {
     const el = ref.current;
     if (!el) return;
-    position.current = { top: el.scrollHeight, stick: true };
+    scrollingUp.current = false;
+    position.current = { top: el.scrollTop, stick: true };
     if (typeof el.scrollTo === "function") el.scrollTo({ top: el.scrollHeight, behavior: "smooth" });
     else el.scrollTop = el.scrollHeight;
     setAway(false);
@@ -734,28 +761,52 @@ function Stream({ loadError, task, entries, subagent, onOpenSubagent, finding, f
       renderRow(row)
     );
   return (
-    <div
-      className={styles.streamArea}
-      onWheel={markUserScroll}
-      onTouchMove={markUserScroll}
-      onKeyDown={markUserScroll}
-      onPointerDown={markUserScroll}
-    >
+    <div className={styles.streamArea}>
       {finding && <FindBar streamRef={ref} focus={findFocus} onClose={onCloseFind} />}
       <div
         ref={ref}
         // The conversation is read and copied like a document; focusable so ⌘F reaches it.
         className={clsx(styles.stream, selectableText)}
         tabIndex={-1}
+        onWheel={(e) => {
+          markUserScroll();
+          if (e.deltaY < 0 && !e.ctrlKey && !e.defaultPrevented) stopFollowing(e.target);
+          else if (e.deltaY > 0 && !e.ctrlKey && !e.defaultPrevented) scrollingUp.current = false;
+        }}
+        onTouchStart={(e) => {
+          touchY.current = e.touches.length === 1 ? e.touches[0]!.clientY : null;
+        }}
+        onTouchMove={(e) => {
+          markUserScroll();
+          const y = e.touches.length === 1 ? e.touches[0]!.clientY : null;
+          if (y !== null && touchY.current !== null && y > touchY.current) stopFollowing(e.target);
+          else if (y !== null && touchY.current !== null && y < touchY.current) scrollingUp.current = false;
+          touchY.current = y;
+        }}
+        onKeyDown={(e) => {
+          markUserScroll();
+          if (e.defaultPrevented || (e.target as Element).closest("input, textarea, [contenteditable]")) return;
+          if (e.key === "ArrowUp" || e.key === "PageUp" || e.key === "Home" || (e.key === " " && e.shiftKey))
+            stopFollowing(e.target);
+          else if (e.key === "ArrowDown" || e.key === "PageDown" || e.key === "End" || (e.key === " " && !e.shiftKey))
+            scrollingUp.current = false;
+        }}
+        onPointerDown={() => {
+          markUserScroll();
+          scrollingUp.current = false;
+        }}
         onScroll={(e) => {
           const el = e.currentTarget;
           const atEnd = el.scrollHeight - el.scrollTop - el.clientHeight < 40;
           const laidOut = el.scrollHeight !== seenHeight.current;
           seenHeight.current = el.scrollHeight;
           const byUser = dragging.current || performance.now() - userScrolled.current < 500 || !laidOut;
-          const stick = atEnd || (position.current.stick && !byUser);
+          const movedDown = el.scrollTop > position.current.top;
+          const stayedAtEnd = position.current.stick && el.scrollTop === position.current.top;
+          const stick =
+            (atEnd && !scrollingUp.current && (movedDown || stayedAtEnd)) || (position.current.stick && !byUser);
           // Still following: back to the end the offset was moved away from.
-          if (stick && !atEnd) el.scrollTop = el.scrollHeight;
+          if (stick && !atEnd && !dragging.current) el.scrollTop = el.scrollHeight;
           position.current = { top: el.scrollTop, stick };
           positions.set(key, position.current);
           setAway(!position.current.stick);

src/features/agents/mermaidFollow.test.tsx

@@ -1,4 +1,4 @@
-import { act, render, waitFor } from "@testing-library/react";
+import { act, fireEvent, render, waitFor } from "@testing-library/react";
 import { beforeEach, expect, it, vi } from "vitest";
 import type { AgentEntry, AgentTask } from "@/bindings";
 
@@ -73,7 +73,7 @@ it("redraws a diagram when the theme changes", async () => {
   }
 });
 
-it("follows the end when a diagram draws after the last update", async () => {
+it.each([false, true])("preserves scroll ownership when a diagram finishes (away: %s)", async (away) => {
   // The diagram is still rendering when the conversation arrives at its end.
   let draw!: () => void;
   mermaid.render.mockReset().mockImplementation(
@@ -94,8 +94,16 @@ it("follows the end when a diagram draws after the last update", async () => {
   const scroller = block.closest<HTMLElement>("div[tabindex='-1']")!;
   Object.defineProperty(scroller, "scrollHeight", { value: 1000, configurable: true });
   expect(scroller.scrollTop).toBe(0);
+  if (away) {
+    Object.defineProperty(scroller, "clientHeight", { value: 400, configurable: true });
+    scroller.scrollTop = 600;
+    fireEvent.scroll(scroller);
+    fireEvent.wheel(scroller, { deltaY: -4 });
+    scroller.scrollTop = 588;
+    fireEvent.scroll(scroller);
+  }
   // The draw lands after the last streamed chunk: the viewport must follow it.
   await act(async () => draw());
   await waitFor(() => expect(block).toHaveAttribute("data-mermaid-state", "ok"));
-  expect(scroller.scrollTop).toBe(1000);
+  expect(scroller.scrollTop).toBe(away ? 588 : 1000);
 });

src/features/agents/sessionState.test.tsx

@@ -357,6 +357,89 @@ describe("message tags", () => {
 });
 
 describe("scrolling", () => {
+  it.each(["wheel", "touch", "ArrowUp", "PageUp", "Home", "Shift+Space"])(
+    "releases following before an upward %s scroll, even within the bottom threshold",
+    async (method) => {
+      useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "Initial reply" }]]]) });
+      render(<SessionEditor input={input("A")} />);
+      const el = stream();
+      let height = 1000;
+      Object.defineProperty(el, "scrollHeight", { configurable: true, get: () => height });
+      Object.defineProperty(el, "clientHeight", { configurable: true, value: 400 });
+      el.scrollTop = 600;
+      fireEvent.scroll(el);
+      if (method === "wheel") fireEvent.wheel(el, { deltaY: -4 });
+      if (method === "touch") {
+        fireEvent.touchStart(el, { touches: [{ clientY: 100 }] });
+        fireEvent.touchMove(el, { touches: [{ clientY: 110 }] });
+      }
+      if (["ArrowUp", "PageUp", "Home"].includes(method)) fireEvent.keyDown(el, { key: method });
+      if (method === "Shift+Space") fireEvent.keyDown(el, { key: " ", shiftKey: true });
+      // A chunk can land before the browser dispatches the scroll event.
+      height = 1004;
+      act(() => useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "Streaming" }]]]) }));
+      expect(el.scrollTop).toBe(600);
+      el.scrollTop = 588;
+      fireEvent.scroll(el);
+      // A queued event at the same offset must not re-enable following near the bottom.
+      fireEvent.scroll(el);
+      el.scrollTop = 592;
+      fireEvent.scroll(el);
+      height = 1008;
+      act(() => useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "More streaming" }]]]) }));
+      expect(el.scrollTop).toBe(592);
+      expect(screen.getByRole("button", { name: "Jump to Latest" })).toBeInTheDocument();
+      // Scrolling down to the end resumes following.
+      fireEvent.wheel(el, { deltaY: 12 });
+      el.scrollTop = 608;
+      fireEvent.scroll(el);
+      height = 1100;
+      act(() => useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "Latest" }]]]) }));
+      expect(el.scrollTop).toBe(1100);
+    },
+  );
+
+  it("does not move the viewport while the scrollbar is held during streaming", () => {
+    useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "Initial reply" }]]]) });
+    render(<SessionEditor input={input("A")} />);
+    const el = stream();
+    let height = 1000;
+    Object.defineProperty(el, "scrollHeight", { configurable: true, get: () => height });
+    Object.defineProperty(el, "clientHeight", { configurable: true, value: 400 });
+    el.scrollTop = 600;
+    fireEvent.scroll(el);
+    fireEvent.pointerDown(el);
+    height = 1100;
+    act(() => useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "Streaming" }]]]) }));
+    expect(el.scrollTop).toBe(600);
+    el.scrollTop = 588;
+    fireEvent.scroll(el);
+    fireEvent.pointerUp(window);
+    height = 1200;
+    act(() => useAgents.setState({ entries: new Map([["A", [{ type: "agent", text: "More streaming" }]]]) }));
+    expect(el.scrollTop).toBe(588);
+  });
+
+  it("keeps following when an inner tool output consumes the upward wheel", () => {
+    const transcript: AgentEntry[] = [tool("live", { status: "running", output: "Tool output" })];
+    useAgents.setState({ entries: new Map([["A", transcript]]) });
+    render(<SessionEditor input={input("A")} />);
+    const el = stream();
+    const output = screen.getByText("Tool output");
+    let height = 1000;
+    Object.defineProperty(el, "scrollHeight", { configurable: true, get: () => height });
+    Object.defineProperty(el, "clientHeight", { configurable: true, value: 400 });
+    output.style.overflowY = "auto";
+    output.scrollTop = 100;
+    el.scrollTop = 600;
+    fireEvent.scroll(el);
+    fireEvent.wheel(output, { deltaY: -4 });
+    height = 1100;
+    act(() => useAgents.setState({ entries: new Map([["A", [...transcript, { type: "agent", text: "Streaming" }]]]) }));
+    expect(el.scrollTop).toBe(1100);
+    expect(screen.queryByRole("button", { name: "Jump to Latest" })).toBeNull();
+  });
+
   it("hides Jump to Latest and follows new replies after retracting the conversation", async () => {
     render(<SessionEditor input={input("A")} />);
     const el = stream();

src/features/code-insight/HierarchyView.tsx

@@ -17,6 +17,7 @@ import {
 } from "@/ui";
 import { openLocation } from "./ipc";
 import {
+  closeHierarchy,
   ROOT_ID,
   directionLabel,
   hierarchyTitle,
@@ -64,9 +65,10 @@ export function HierarchyTabs() {
       variant="compact"
       className={styles.tabs}
       aria-label="Hierarchies"
-      items={[{ id: "current", label }]}
+      items={[{ id: "current", label, closable: true }]}
       activeId="current"
       onSelect={() => undefined}
+      onClose={closeHierarchy}
     />
   );
 }

src/features/code-insight/hierarchy.test.ts

@@ -2,9 +2,10 @@ import { describe, expect, it, vi } from "vitest";
 import type { HierarchyItem, OutlineItem, ReferencesIncomplete, SymbolKind } from "@/bindings";
 
 const hint = vi.fn();
+const hide = vi.hoisted(() => vi.fn());
 vi.mock("@/workbench/contributions", async (orig) => ({
   ...(await orig<typeof import("@/workbench/contributions")>()),
-  toolWindowService: () => ({ show: () => undefined }),
+  toolWindowService: () => ({ show: () => undefined, hide }),
 }));
 
 const range = (l1: number, c1: number, l2: number, c2: number) => ({
@@ -167,3 +168,13 @@ describe("hierarchy", () => {
     }
   });
 });
+
+describe("closing the hierarchy tab", () => {
+  it("clears the tree and hides the tool window", async () => {
+    const { closeHierarchy, useHierarchy } = await import("./hierarchy");
+    useHierarchy.setState({ root: { name: "Number", path: "/p/Number.java", line: 0, col: 0 } as never });
+    closeHierarchy();
+    expect(useHierarchy.getState().root).toBeNull();
+    expect(hide).toHaveBeenCalledWith("hierarchy");
+  });
+});

src/features/code-insight/hierarchy.ts

@@ -73,6 +73,12 @@ export function resetHierarchy() {
   }));
 }
 
+/** Closes the hierarchy's content tab; with no content left the tool window hides. */
+export function closeHierarchy() {
+  resetHierarchy();
+  toolWindowService().hide("hierarchy");
+}
+
 /** The empty-result line of the hierarchy tree. */
 export function noneFoundLabel(mode: HierarchyMode, direction: HierarchyDirection): string {
   if (mode === "call") return direction === "incoming" ? tx`— no callers found` : tx`— no callees found`;