@@ -106,6 +106,8 @@ final class ViewerWindow: NSObject, NSWindowDelegate, WKNavigationDelegate, WKUI
     private var tabbarHeight = -1 // last value sent to the page
     private var measuredTabbar = 0 // AppKit's tab bar height, measured outside full screen
     private var layoutObserver: NSKeyValueObservation?
+    private var tabBarObserver: NSKeyValueObservation?
+    private weak var observedGroup: NSWindowTabGroup?
 
     init(folder: URL) {
         server = Server(folder: folder)
@@ -166,17 +168,23 @@ final class ViewerWindow: NSObject, NSWindowDelegate, WKNavigationDelegate, WKUI
 
     /// Tells the page how tall the native tab bar is (0 when hidden).
     func syncTabBar(force: Bool = false) {
-        let inset = ViewerWindow.titlebarMetrics(window).height
-        var h: Int
-        if window.styleMask.contains(.fullScreen) {
-            // The title bar is gone; a tab bar that stays on screen is the whole inset. A larger
-            // inset is the toolbar sliding in while the pointer is at the top edge: an overlay,
-            // so keep the current offset rather than shifting the page under the pointer.
-            if inset > max(measuredTabbar, 1) + 4 { return }
-            h = inset
-        } else {
-            h = max(0, inset - titlebarHeight)
-            if h > 0 { measuredTabbar = h }
+        // The window moves to another group when its tab is dragged out or into another window.
+        if window.tabGroup !== observedGroup {
+            observedGroup = window.tabGroup
+            tabBarObserver = observedGroup?.observe(\.isTabBarVisible) { [weak self] _, _ in
+                DispatchQueue.main.async { self?.syncTabBar() }
+            }
+        }
+        var h = 0
+        if window.tabGroup?.isTabBarVisible == true {
+            if window.styleMask.contains(.fullScreen) {
+                // The title bar is gone, and the inset also grows while the toolbar slides in at the
+                // top edge (an overlay): use the height measured in a window, not the inset.
+                h = measuredTabbar > 0 ? measuredTabbar : 28
+            } else {
+                h = max(0, ViewerWindow.titlebarMetrics(window).height - titlebarHeight)
+                if h > 0 { measuredTabbar = h }
+            }
         }
         if h == tabbarHeight && !force { return }
         tabbarHeight = h
@@ -260,9 +268,10 @@ final class ViewerWindow: NSObject, NSWindowDelegate, WKNavigationDelegate, WKUI
         }
     }
 
-    // A new document starts without the offset: send it before the page first paints.
+    // A new document starts without the offset or full screen state: send them before the page first paints.
     func webView(_ webView: WKWebView, didCommit navigation: WKNavigation!) {
         syncTabBar(force: true)
+        setFullScreenAttribute(window.styleMask.contains(.fullScreen))
     }
 
     func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
@@ -311,6 +320,7 @@ final class ViewerWindow: NSObject, NSWindowDelegate, WKNavigationDelegate, WKUI
 
     func windowWillClose(_ notification: Notification) {
         layoutObserver = nil
+        tabBarObserver = nil
         webView.configuration.userContentController.removeScriptMessageHandler(forName: "native")
         server.stop()
         onClose?(self)
@@ -340,11 +350,14 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     func applicationDidFinishLaunching(_ notification: Notification) {
         // `codeviewer <dir>` from a terminal runs: open -n -a Codeviewer --args --folder <dir>
         // (a restart after an update passes one --folder per tab, --window to start a new window).
+        // Without --window (the CLI, or a restart from an older build) each --folder tabs as usual.
         let args = CommandLine.arguments
+        let layout = args.contains("--window")
         var last: ViewerWindow?
         for (i, a) in args.enumerated() where (a == "--folder" || a == "--window") && i + 1 < args.count {
+            let url = URL(fileURLWithPath: args[i + 1], isDirectory: true)
             let tabbed = a == "--folder"
-            last = open(folder: URL(fileURLWithPath: args[i + 1], isDirectory: true), tabbed: tabbed, into: tabbed ? last?.window : nil)
+            last = layout ? open(folder: url, tabbed: tabbed, into: tabbed ? last?.window : nil) : open(folder: url)
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
             if !self.openedSomething { self.chooseFolder(nil) }
@@ -420,7 +433,12 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         panel.message = "Choose a folder to view"
         NSApp.activate(ignoringOtherApps: true)
         if panel.runModal() == .OK {
-            panel.urls.forEach { open(folder: $0, tabbed: tabbed) }
+            // New Window with several folders: one new window, the rest as its tabs.
+            var host: NSWindow?
+            for u in panel.urls {
+                let w = open(folder: u, tabbed: tabbed || host != nil, into: host)
+                if !tabbed && host == nil { host = w.window }
+            }
         } else if windows.isEmpty {
             NSApp.terminate(nil)
         }
@@ -430,17 +448,15 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
     /// window layout: tabs of one window stay together, separate windows stay separate.
     func relaunch() {
         var args = ["-n", Bundle.main.bundlePath, "--args"]
-        var groups: [[ViewerWindow]] = []
-        for w in windows {
-            if let i = groups.firstIndex(where: { $0[0].window.tabbedWindows?.contains(w.window) == true }) {
-                groups[i].append(w)
-            } else {
-                groups.append([w])
+        var done = Set<ObjectIdentifier>()
+        for w in windows where !done.contains(ObjectIdentifier(w)) {
+            // tabbedWindows is in tab order; nil for a window that stands alone.
+            let group = (w.window.tabbedWindows ?? [w.window]).compactMap { nsw in windows.first { $0.window === nsw } }
+            for (i, t) in group.enumerated() {
+                done.insert(ObjectIdentifier(t))
+                args += [i == 0 ? "--window" : "--folder", t.server.folder.path]
             }
         }
-        for g in groups {
-            for (i, w) in g.enumerated() { args += [i == 0 ? "--window" : "--folder", w.server.folder.path] }
-        }
         let p = Process()
         p.executableURL = URL(fileURLWithPath: "/usr/bin/open")
         p.arguments = args
 
@@ -9,6 +9,7 @@ import { icons } from "./icons.ts";
 import { GitState, relativeTime } from "./git.ts";
 import { Updates } from "./updates.ts";
 import { debounce, dragSplitter, esc, formatBytes, h, IS_MAC, MOD, store } from "./util.ts";
+import { isContextMenuOpen } from "./menu.ts";
 
 type ThemeName = "dark" | "light" | "system";
 
@@ -531,6 +532,7 @@ class App {
     window.addEventListener(
       "keydown",
       (e) => {
+        if (isContextMenuOpen()) return; // its own listener takes the key
         const mod = IS_MAC ? e.metaKey : e.ctrlKey;
         const k = e.key.toLowerCase();
         const inTerm = (e.target as HTMLElement).classList?.contains("term-input");
 
@@ -1,5 +1,5 @@
 import { Highlighter, type Tok } from "./highlight.ts";
-import { esc, h } from "./util.ts";
+import { dismissable, esc, h } from "./util.ts";
 import { icons } from "./icons.ts";
 import { diffLines, gutterMarks, ADDED, MODIFIED, DELETED_BELOW, DELETED_ABOVE, type Hunk } from "./diff.ts";
 
@@ -254,18 +254,9 @@ export class CodeView {
     box.style.left = `${this.gutterW - 6}px`;
     this.el.append(box);
     this.peek = box;
-    const onKey = (e: KeyboardEvent) => {
-      if (e.key === "Escape") this.closePeek();
-    };
-    const onDown = (e: MouseEvent) => {
-      if (!box.contains(e.target as Node) && !(e.target as HTMLElement).classList.contains("g")) this.closePeek();
-    };
-    window.addEventListener("keydown", onKey, true);
-    window.addEventListener("mousedown", onDown, true);
-    box.addEventListener("peek-close", () => {
-      window.removeEventListener("keydown", onKey, true);
-      window.removeEventListener("mousedown", onDown, true);
-    });
+    // A click on a gutter marker toggles the peek itself.
+    const off = dismissable(box, () => this.closePeek(), { keep: (t) => !!t.classList?.contains("g") });
+    box.addEventListener("peek-close", off);
   }
 
   private closePeek() {
 
@@ -52,14 +52,16 @@ export class GitState {
   status: GitStatus = { repo: false } as GitStatus;
   private files = new Map<string, FileGit>();
   private prefixes = new Map<string, FileGit>(); // untracked/ignored directories (no trailing "/")
+  private prev = { files: this.files, prefixes: this.prefixes };
   private dirs = new Map<string, Letter>();
   private listeners = new Set<() => void>();
   counts = { changed: 0, staged: 0, untracked: 0, conflicts: 0 };
 
   set(s: GitStatus) {
     this.status = s;
-    this.files.clear();
-    this.prefixes.clear();
+    this.prev = { files: this.files, prefixes: this.prefixes };
+    this.files = new Map();
+    this.prefixes = new Map();
     this.dirs.clear();
     this.counts = { changed: 0, staged: 0, untracked: 0, conflicts: 0 };
     for (const [raw, xy] of Object.entries(s.files ?? {})) {
@@ -93,23 +95,20 @@ export class GitState {
 
   file(path: string): FileGit | null {
     path = nfc(path);
-    return this.files.get(path) ?? this.underPrefix(path);
+    return this.files.get(path) ?? underPrefix(this.prefixes, path);
   }
 
-  /** Status of a directory: its own (untracked/ignored) or the strongest inside it. */
-  dir(path: string): Letter | null {
+  /** True if the last status update took `path` from changed to clean or ignored. */
+  cleared(path: string): boolean {
     path = nfc(path);
-    return (this.prefixes.get(path) ?? this.underPrefix(path))?.letter ?? this.dirs.get(path) ?? null;
+    const was = this.prev.files.get(path) ?? underPrefix(this.prev.prefixes, path);
+    return !!was && was.letter !== "I" && (this.file(path)?.letter ?? "I") === "I";
   }
 
-  /** Nearest untracked/ignored ancestor directory, walking up (O(depth)). */
-  private underPrefix(path: string): FileGit | null {
-    if (!this.prefixes.size) return null;
-    for (let i = path.lastIndexOf("/"); i > 0; i = path.lastIndexOf("/", i - 1)) {
-      const g = this.prefixes.get(path.slice(0, i));
-      if (g) return g;
-    }
-    return null;
+  /** Status of a directory: its own (untracked/ignored) or the strongest inside it. */
+  dir(path: string): Letter | null {
+    path = nfc(path);
+    return (this.prefixes.get(path) ?? underPrefix(this.prefixes, path))?.letter ?? this.dirs.get(path) ?? null;
   }
 
   /** Changed (non-ignored) files, most important first. */
@@ -121,6 +120,16 @@ export class GitState {
   }
 }
 
+/** Nearest untracked/ignored ancestor directory, walking up (O(depth)). */
+function underPrefix(prefixes: Map<string, FileGit>, path: string): FileGit | null {
+  if (!prefixes.size) return null;
+  for (let i = path.lastIndexOf("/"); i > 0; i = path.lastIndexOf("/", i - 1)) {
+    const g = prefixes.get(path.slice(0, i));
+    if (g) return g;
+  }
+  return null;
+}
+
 export function relativeTime(ms: number): string {
   const s = Math.round((Date.now() - ms) / 1000);
   const units: [number, string][] = [
 
@@ -1,4 +1,4 @@
-import { h } from "./util.ts";
+import { dismissable, h } from "./util.ts";
 
 export interface MenuItem {
   label: string;
@@ -11,6 +11,10 @@ export function closeContextMenu() {
   current?.dispose();
 }
 
+export function isContextMenuOpen() {
+  return !!current;
+}
+
 /** Shows a small context menu at the pointer, replacing the browser's (or WebView's) own. */
 export function showContextMenu(e: MouseEvent, items: MenuItem[]) {
   e.preventDefault();
@@ -39,10 +43,7 @@ export function showContextMenu(e: MouseEvent, items: MenuItem[]) {
   el.style.top = `${Math.max(4, Math.min(e.clientY, innerHeight - r.height - 4))}px`;
 
   const buttons = [...el.querySelectorAll<HTMLElement>(".ctx-item")];
-  const onDown = (ev: Event) => {
-    if (!el.contains(ev.target as Node)) closeContextMenu();
-  };
-  // While open, the menu owns the keyboard: no shortcut runs underneath it.
+  // While open, the menu owns the keyboard: App's shortcuts check isContextMenuOpen() and step aside.
   const onKey = (ev: KeyboardEvent) => {
     ev.stopPropagation();
     if (["Shift", "Control", "Alt", "Meta"].includes(ev.key)) return;
@@ -56,22 +57,12 @@ export function showContextMenu(e: MouseEvent, items: MenuItem[]) {
     } else closeContextMenu();
     ev.preventDefault();
   };
-  const onBlur = () => closeContextMenu();
-  // Capture phase, so a click elsewhere closes the menu even if a handler stops propagation.
-  window.addEventListener("mousedown", onDown, true);
-  window.addEventListener("keydown", onKey, true);
-  window.addEventListener("blur", onBlur);
-  window.addEventListener("resize", onBlur);
-  window.addEventListener("wheel", onBlur, { passive: true, capture: true });
+  const off = dismissable(el, closeContextMenu, { key: onKey, transient: true });
   current = {
     dispose: () => {
       current = null;
       el.remove();
-      window.removeEventListener("mousedown", onDown, true);
-      window.removeEventListener("keydown", onKey, true);
-      window.removeEventListener("blur", onBlur);
-      window.removeEventListener("resize", onBlur);
-      window.removeEventListener("wheel", onBlur, true);
+      off();
       // Only if focus was still in the menu (or lost with it); a click elsewhere keeps its target.
       if (returnTo?.isConnected && (!document.activeElement || document.activeElement === document.body)) {
         returnTo.focus({ preventScroll: true });
 
@@ -45,7 +45,7 @@ export class FileTree {
     new ResizeObserver(() => this.schedule()).observe(this.scroller);
     this.rows.addEventListener("click", (e) => this.onClick(e as MouseEvent, false));
     this.rows.addEventListener("dblclick", (e) => this.onClick(e as MouseEvent, true));
-    this.rows.addEventListener("contextmenu", (e) => this.onContextMenu(e as MouseEvent));
+    this.scroller.addEventListener("contextmenu", (e) => this.onContextMenu(e as MouseEvent));
     this.scroller.addEventListener("keydown", (e) => this.onKey(e));
   }
 
@@ -182,15 +182,20 @@ export class FileTree {
     this.schedule();
   }
 
-  /** Our own menu instead of the WebView's (Reload, Inspect Element…). */
+  /** Our own menu instead of the WebView's (Reload, Inspect Element…), anywhere in the explorer. */
   private onContextMenu(e: MouseEvent) {
     e.preventDefault();
     const row = (e.target as HTMLElement).closest<HTMLElement>(".row");
     const n = row && this.flat[Number(row.dataset.i)];
-    if (!n || n.type !== "file") return;
+    const collapse = { label: "Collapse All", run: () => this.collapseAll() };
+    if (!n) return showContextMenu(e, [collapse]);
     this.selected = n.path;
     this.schedule();
-    showContextMenu(e, [{ label: "Open in New Tab", run: () => this.onOpen(n.path, true) }]);
+    if (n.type === "dir") {
+      showContextMenu(e, [{ label: n.expanded ? "Collapse" : "Expand", run: () => void this.toggle(n) }, collapse]);
+    } else if (n.type === "file") {
+      showContextMenu(e, [{ label: "Open in New Tab", run: () => this.onOpen(n.path, true) }]);
+    }
   }
 
   private async toggle(n: TNode, open = !n.expanded) {
@@ -332,14 +337,15 @@ export class FileTree {
     this.reflow();
   }
 
-  /** Git status changed: committed, reverted or ignored files no longer count as changes. */
+  /**
+   * Git status changed: files it just saw committed, reverted or ignored no longer count as
+   * changes. Only that transition prunes: a status taken before a write would still call the
+   * file clean, and the next one (showing it modified) wouldn't bring the marker back.
+   */
   onGitChanged() {
     if (this.git?.repo) {
       let pruned = false;
-      for (const p of this.changed) {
-        const g = this.git.file(p);
-        if (!g || g.letter === "I") pruned = this.changed.delete(p) || pruned;
-      }
+      for (const p of this.changed) if (this.git.cleared(p)) pruned = this.changed.delete(p) || pruned;
       if (pruned) this.recomputeChangedDirs();
     }
     this.schedule();
 
@@ -126,3 +126,35 @@ export function dragSplitter(handle: HTMLElement, axis: "x" | "y", onStart: () =
     handle.addEventListener("pointercancel", up);
   });
 }
+
+/**
+ * Closes a popup on a mousedown outside it and on Escape (or `key`, which then decides),
+ * optionally also when the window blurs, resizes or scrolls. Capture phase, so handlers that
+ * stop propagation can't keep it open. Returns the function that removes the listeners.
+ */
+export function dismissable(
+  el: HTMLElement,
+  onClose: () => void,
+  opts: { key?: (e: KeyboardEvent) => void; keep?: (target: HTMLElement) => boolean; transient?: boolean } = {},
+): () => void {
+  const onDown = (e: Event) => {
+    const t = e.target as HTMLElement;
+    if (!el.contains(t) && !opts.keep?.(t)) onClose();
+  };
+  const onKey = opts.key ?? ((e: KeyboardEvent) => e.key === "Escape" && onClose());
+  const onAway = () => onClose();
+  window.addEventListener("mousedown", onDown, true);
+  window.addEventListener("keydown", onKey, true);
+  if (opts.transient) {
+    window.addEventListener("blur", onAway);
+    window.addEventListener("resize", onAway);
+    window.addEventListener("wheel", onAway, { passive: true, capture: true });
+  }
+  return () => {
+    window.removeEventListener("mousedown", onDown, true);
+    window.removeEventListener("keydown", onKey, true);
+    window.removeEventListener("blur", onAway);
+    window.removeEventListener("resize", onAway);
+    window.removeEventListener("wheel", onAway, true);
+  };
+}
@@ -31,3 +31,20 @@ test("lookups stay fast with thousands of ignored folders", () => {
   for (let i = 0; i < 6000; i++) g.file(`pkg${i % 500}/src/module${i}.py`);
   expect(performance.now() - t).toBeLessThan(50 * BUDGET);
 });
+
+test("cleared: only a changed-to-clean/ignored transition counts", () => {
+  const g = new GitState();
+  g.set({ ...base, files: { "a.ts": ".M", "b.ts": "??", "gen/": "!!", "c.ts": ".M", "out/": "??" } });
+  expect(g.cleared("a.ts")).toBe(false); // nothing before this status
+  // A status taken before d.ts was written still calls it clean: that mustn't count.
+  g.set({ ...base, files: { "b.ts": "!!", "gen/": "!!", "c.ts": ".M" } });
+  expect(g.cleared("a.ts")).toBe(true); // committed or reverted
+  expect(g.cleared("b.ts")).toBe(true); // now ignored
+  expect(g.cleared("out/x.js")).toBe(true); // untracked folder gone
+  expect(g.cleared("c.ts")).toBe(false); // still modified
+  expect(g.cleared("d.ts")).toBe(false); // clean before and after
+  expect(g.cleared("gen/x.js")).toBe(false); // ignored before and after
+  g.set({ ...base, files: { "c.ts": ".M", "d.ts": ".M" } });
+  expect(g.cleared("d.ts")).toBe(false); // clean to modified
+  expect(g.cleared("a.ts")).toBe(false); // clean to clean
+});