From 52de2b1ba2066ef7825e27287b34685b4f7f6a1e Mon Sep 17 00:00:00 2001
From: Gadzhi Gadzhiev <168296+resure@users.noreply.github.com>
Date: Sun, 5 Jul 2026 13:30:40 +0300
Subject: [PATCH 1/5] =?UTF-8?q?feat:=20per-note=20windows=20=E2=80=94=20op?=
 =?UTF-8?q?en=20any=20note=20in=20its=20own=20window=20(Apple=20Notes-styl?=
 =?UTF-8?q?e)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Desktop only. Entry points: row ⋯/context menu "Open in New Window", ⌘↵ on a
focused list row, and ⌘-click on a row. The note-N window opens smaller with
both side panels closed, restores its ASSIGNED note (never touching the shared
sidecar's last-active pointer), lands focus in the editor body, and titles
itself after the note (rename included). Opening the same note again focuses
its existing window (per-note focus-if-open, kept current via set_window_note);
workspace-level focus-if-open skips note windows.

⌘0 / Window ▸ Main Window (native accelerator) surfaces the full workspace view
for the FOCUSED window's workspace — focusing the existing main/ws-N window or
creating one — never dragging forward a main window parked on another workspace.

Also, since main + a note window now routinely show one folder: the note list
re-reads on window focus (throttled); right-click / ⌘-click on a row no longer
move selection or steal focus; and new windows open flash-free (no welcome-card
flash during bootstrap — delayed spinner instead; shell-assigned windows skip
the folder probe; the empty-editor placeholder waits for the initial load).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 README.md                               |  16 ++
 src-tauri/capabilities/default.json     |   2 +-
 src-tauri/src/lib.rs                    | 222 ++++++++++++++++++++++--
 src/App.tsx                             |  10 ++
 src/components/FolderGate.test.tsx      |  26 ++-
 src/components/FolderGate.tsx           |  55 ++++--
 src/components/NoteList.test.tsx        |  80 ++++++++-
 src/components/NoteList.tsx             |  93 ++++++++--
 src/components/ShortcutsDialog.test.tsx |  12 +-
 src/components/ShortcutsDialog.tsx      |   7 +-
 src/components/Workspace.test.tsx       |   2 +
 src/components/Workspace.tsx            | 148 +++++++++++++---
 src/hooks/useNotes.test.tsx             |  46 +++++
 src/hooks/useNotes.ts                   |  57 +++++-
 src/hooks/useNotesStorage.ts            | 130 ++++++++++----
 src/hooks/useShortcuts.ts               |   4 +-
 src/isTauri.ts                          |  14 ++
 src/shortcuts.ts                        |  21 +++
 18 files changed, 825 insertions(+), 120 deletions(-)

diff --git a/README.md b/README.md
index c37c5b4..72302c9 100644
--- a/README.md
+++ b/README.md
@@ -177,6 +177,22 @@ Key modules:
 
 ### Backlog
 
+Bugs (testing notes, 2026-07-05):
+
+- iCloud Drive: opening a folder whose files aren't downloaded yet hangs the app (probe/walk
+  blocks on download-on-demand materialization; needs async download handling or a clear error)
+- Plain URLs in note text aren't highlighted as links — not even in preview mode
+- Opening a note that begins with a `[[wiki link]]` sometimes pops the link tooltip immediately,
+  anchored top-left and stuck (likely a caret-lands-inside-link position race; sometimes fine)
+- Markup (CodeMirror) mode: the undo/redo stack appears shared across notes — undo after
+  switching can revert the previous note's edits (WYSIWYG resets history on swap; CM may not)
+
+UI wishes:
+
+- Indicate that read-only preview mode is active (some visible state, not just the frozen editor)
+- Indicate the selected folder scope when the folder rail is closed (the list silently stays
+  filtered)
+
 - Search index update on external file updates (+ reload workspace menu item?)
 - Density (line spacing) setting to complement the per-note font/width overrides?
 - Restore all workspace windows on relaunch (today only the last-active one comes back)
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index d2f982f..6b81fff 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -2,7 +2,7 @@
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
   "description": "enables the default permissions",
-  "windows": ["main", "ws-*"],
+  "windows": ["main", "ws-*", "note-*"],
   "permissions": [
     "core:default",
     "core:window:allow-start-dragging",
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 42ba9e3..168ad3d 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -696,17 +696,22 @@ fn open_external(url: String) -> Result<(), String> {
 
 /// Per-window workspace tracking.
 /// - `labels`: a live window's label → the workspace id it shows. Fed by the frontend
-///   (`set_window_workspace` on every workspace open) and by `open_workspace_window` (which assigns
-///   the workspace *before* the window's page loads); drained by the `Destroyed` window event.
-/// - `pending`: workspace ids whose window is currently being built. During the build gap the
-///   window isn't yet resolvable via `get_webview_window`, so without this marker a second
-///   `open_workspace_window` for the same workspace would treat the label as dead, prune it, and
-///   spawn a duplicate window.
+///   (`set_window_workspace` on every workspace open) and by `open_workspace_window` /
+///   `open_note_window` (which assign the workspace *before* the window's page loads); drained by
+///   the `Destroyed` window event.
+/// - `notes`: a note window's label → the note id (store rel-path) it shows. Assigned by
+///   `open_note_window` before the page loads, kept current by the frontend's `set_window_note`
+///   (in-window navigation / rename / close), drained with `labels`. Powers per-note focus-if-open.
+/// - `pending`: workspace ids (or `ws\u{1f}note` composite keys, see `note_pending_key`) whose
+///   window is currently being built. During the build gap the window isn't yet resolvable via
+///   `get_webview_window`, so without this marker a second open for the same target would treat
+///   the label as dead, prune it, and spawn a duplicate window.
 ///
-/// Powers focus-if-open, so the same workspace never casually ends up in two windows.
+/// Powers focus-if-open, so the same workspace (or note) never casually ends up in two windows.
 #[derive(Default)]
 struct WindowState {
     labels: HashMap<String, String>,
+    notes: HashMap<String, String>,
     pending: HashSet<String>,
 }
 
@@ -717,15 +722,35 @@ struct WindowWorkspaces(Mutex<WindowState>);
 /// nothing restores workspace windows across launches.
 static NEXT_WS_WINDOW: AtomicU32 = AtomicU32::new(1);
 
+/// Monotonic suffix for `note-N` window labels (same one-run lifetime story as `NEXT_WS_WINDOW`).
+static NEXT_NOTE_WINDOW: AtomicU32 = AtomicU32::new(1);
+
+/// Label prefix of single-note windows. Mirrors `NOTE_WINDOW_PREFIX` in `src/isTauri.ts` — keep
+/// them in sync. A note window carries a workspace assignment in `labels` like any window (its
+/// page bootstraps through the same `window_workspace` ask), but workspace-level focus-if-open
+/// skips it: asking for a workspace should land on a full workspace view, never on a lone note.
+const NOTE_WINDOW_PREFIX: &str = "note-";
+
+/// `pending` key for a note-window build. The unit separator can't occur in a workspace id or a
+/// note rel-path, so composite keys share the set with plain workspace ids without colliding.
+fn note_pending_key(ws_id: &str, note_id: &str) -> String {
+    format!("{ws_id}\u{1f}{note_id}")
+}
+
 /// The label of a window showing `ws_id`, excluding `exclude` (a window never "finds itself"
-/// when asking where else its target workspace is open).
+/// when asking where else its target workspace is open). Note windows never match — see
+/// `NOTE_WINDOW_PREFIX`.
 fn window_label_for_workspace(
     map: &HashMap<String, String>,
     ws_id: &str,
     exclude: Option<&str>,
 ) -> Option<String> {
     map.iter()
-        .find(|(label, ws)| ws.as_str() == ws_id && Some(label.as_str()) != exclude)
+        .find(|(label, ws)| {
+            !label.starts_with(NOTE_WINDOW_PREFIX)
+                && ws.as_str() == ws_id
+                && Some(label.as_str()) != exclude
+        })
         .map(|(label, _)| label.clone())
 }
 
@@ -848,6 +873,128 @@ async fn open_workspace_window(
     Ok(false)
 }
 
+/// This window's assigned note id, if it's a note window (assigned before its page loads, so the
+/// bootstrap ask can't race it — mirrors `window_workspace`).
+#[tauri::command]
+fn window_note(
+    window: tauri::WebviewWindow,
+    state: tauri::State<'_, WindowWorkspaces>,
+) -> Option<String> {
+    state.0.lock().unwrap().notes.get(window.label()).cloned()
+}
+
+/// Record which note this (note) window is showing — the frontend calls it whenever the open note
+/// changes (navigation, rename, close), keeping per-note focus-if-open accurate. `None` drops the
+/// assignment (the window closed its note).
+#[tauri::command]
+fn set_window_note(
+    window: tauri::WebviewWindow,
+    state: tauri::State<'_, WindowWorkspaces>,
+    note_id: Option<String>,
+) {
+    let mut st = state.0.lock().unwrap();
+    match note_id {
+        Some(id) => {
+            st.notes.insert(window.label().to_string(), id);
+        }
+        None => {
+            st.notes.remove(window.label());
+        }
+    }
+}
+
+/// Open a single note in its own window: focus the note window already showing this exact
+/// (workspace, note), or create a fresh `note-N` window assigned to both before its page loads.
+/// The frontend recognizes the `note-` label and opens with both side panels closed. Returns
+/// whether an existing window was focused rather than a new one created.
+///
+/// Async for the same reason as `open_workspace_window`: `WebviewWindowBuilder::build` may
+/// deadlock on the main thread, and async commands run off it.
+#[tauri::command]
+async fn open_note_window(
+    app: tauri::AppHandle,
+    state: tauri::State<'_, WindowWorkspaces>,
+    ws_id: String,
+    note_id: String,
+    title: String,
+) -> Result<bool, String> {
+    let pending_key = note_pending_key(&ws_id, &note_id);
+    let label = {
+        let mut st = state.0.lock().unwrap();
+        // This exact note's window is already being built — don't spawn a second (mirrors the
+        // workspace path's pending guard).
+        if st.pending.contains(&pending_key) {
+            return Ok(true);
+        }
+        // Focus the live window already showing this (workspace, note); prune dead labels (a crash
+        // that skipped the Destroyed cleanup) along the way, like the workspace path.
+        loop {
+            let found = {
+                let WindowState { labels, notes, .. } = &mut *st;
+                notes
+                    .iter()
+                    .find(|(label, note)| {
+                        note.as_str() == note_id
+                            && labels.get(label.as_str()).map(String::as_str)
+                                == Some(ws_id.as_str())
+                    })
+                    .map(|(label, _)| label.clone())
+            };
+            let Some(found) = found else { break };
+            if let Some(target) = app.get_webview_window(&found) {
+                drop(st);
+                let _ = target.show();
+                let _ = target.set_focus();
+                return Ok(true);
+            }
+            st.labels.remove(&found);
+            st.notes.remove(&found);
+        }
+        let label = format!(
+            "{NOTE_WINDOW_PREFIX}{}",
+            NEXT_NOTE_WINDOW.fetch_add(1, Ordering::SeqCst)
+        );
+        // Assign workspace AND note before the window exists (the page's first asks can't race),
+        // and mark the build pending — same discipline as `open_workspace_window`.
+        st.labels.insert(label.clone(), ws_id.clone());
+        st.notes.insert(label.clone(), note_id.clone());
+        st.pending.insert(pending_key.clone());
+        label
+    };
+    // Clone the main window's config like workspace windows do, sized down: this window shows a
+    // single note (both side panels closed), not a whole three-pane workspace.
+    let mut config = app.config().app.windows[0].clone();
+    config.label = label.clone();
+    config.title = title;
+    config.width = 760.0;
+    config.height = 640.0;
+    let built = tauri::WebviewWindowBuilder::from_config(&app, &config)
+        .and_then(|builder| builder.build());
+    {
+        let mut st = state.0.lock().unwrap();
+        st.pending.remove(&pending_key);
+        if built.is_err() {
+            st.labels.remove(&label);
+            st.notes.remove(&label);
+        }
+    }
+    let window = built.map_err(stringify)?;
+    apply_macos_chrome(&window);
+    Ok(false)
+}
+
+/// Re-show + focus the main window: the Dock-icon Reopen and the no-window-focused fallback of
+/// Window ▸ Main Window (⌘0) land here. On macOS ⌘W *hides* main rather than closing it (see the
+/// close-request handler), so this is a show+focus; unminimize first so a minimized main actually
+/// comes forward instead of just taking keyboard focus in the Dock.
+fn show_main_window(app: &tauri::AppHandle) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.unminimize();
+        let _ = main.show();
+        let _ = main.set_focus();
+    }
+}
+
 /// macOS window chrome shared by the main window (at setup) and each workspace window: make the
 /// title bar tall with SYSTEM-positioned traffic lights, and paint the webview backdrop in the
 /// resolved theme so a fresh window doesn't flash white before the page background loads (the
@@ -949,6 +1096,18 @@ fn build_menu(app: &tauri::AppHandle) -> tauri::Result<tauri::menu::Menu<tauri::
             true,
             &[&PredefinedMenuItem::fullscreen(app, None)?],
         )?;
+        // "Main Window" (⌘0) surfaces the full workspace view for the FOCUSED window's workspace —
+        // the way back from a single-note window, mirroring Mail's Window ▸ Message Viewer. The
+        // event handler emits to the focused window, whose frontend focuses (or creates) the
+        // workspace window for ITS workspace. A native accelerator (not a frontend keydown) so it
+        // works from every window regardless of what has focus, like the Edit-menu clipboard chords.
+        let main_window = MenuItem::with_id(
+            app,
+            "main-window",
+            "Main Window",
+            true,
+            Some("CmdOrCtrl+0"),
+        )?;
         let window_menu = Submenu::with_items(
             app,
             "Window",
@@ -957,6 +1116,8 @@ fn build_menu(app: &tauri::AppHandle) -> tauri::Result<tauri::menu::Menu<tauri::
                 &PredefinedMenuItem::minimize(app, None)?,
                 &PredefinedMenuItem::maximize(app, None)?,
                 &PredefinedMenuItem::separator(app)?,
+                &main_window,
+                &PredefinedMenuItem::separator(app)?,
                 &PredefinedMenuItem::close_window(app, None)?,
             ],
         )?;
@@ -977,7 +1138,24 @@ pub fn run() {
         // default menu (Edit's copy/paste/undo, Window, View) so nothing is lost.
         .menu(build_menu)
         .on_menu_event(|app, event| {
-            if event.id() == "about" {
+            if event.id() == "main-window" {
+                // ⌘0 is WORKSPACE-scoped: tell the focused window, and its frontend focuses (or
+                // creates) the full workspace window for its own workspace via
+                // `open_workspace_window` — so a note window returns to ITS workspace's list
+                // view, never dragging forward a main window parked on some other workspace.
+                // Target selection mirrors the About item below; with no window to ask at all,
+                // fall back to plainly re-showing the hidden main.
+                let windows = app.webview_windows();
+                let target = windows
+                    .values()
+                    .find(|window| window.is_focused().unwrap_or(false))
+                    .or_else(|| windows.values().find(|w| w.is_visible().unwrap_or(false)));
+                if let Some(window) = target {
+                    let _ = app.emit_to(window.label(), "menu:main-window", ());
+                } else {
+                    show_main_window(app);
+                }
+            } else if event.id() == "about" {
                 // The frontend (Workspace) listens for this and opens <AboutDialog>. Target one
                 // window — a broadcast would pop the dialog in every open workspace window at once.
                 // Prefer the focused window; if none is focused (the app is backgrounded, or main
@@ -1030,10 +1208,12 @@ pub fn run() {
                     api.prevent_close();
                     let _ = window.hide();
                 }
-                // A closed window's workspace assignment must not keep answering focus-if-open.
+                // A closed window's workspace/note assignments must not keep answering focus-if-open.
                 tauri::WindowEvent::Destroyed => {
                     let state = window.state::<WindowWorkspaces>();
-                    state.0.lock().unwrap().labels.remove(window.label());
+                    let mut st = state.0.lock().unwrap();
+                    st.labels.remove(window.label());
+                    st.notes.remove(window.label());
                 }
                 _ => {}
             }
@@ -1063,6 +1243,9 @@ pub fn run() {
             set_window_workspace,
             focus_workspace_window,
             open_workspace_window,
+            window_note,
+            set_window_note,
+            open_note_window,
         ])
         .build(tauri::generate_context!())
         .expect("error while building tauri application")
@@ -1075,10 +1258,7 @@ pub fn run() {
             } = event
             {
                 if !has_visible_windows {
-                    if let Some(window) = app_handle.get_webview_window("main") {
-                        let _ = window.show();
-                        let _ = window.set_focus();
-                    }
+                    show_main_window(app_handle);
                 }
             }
             // The handler is macOS-only; consume the args elsewhere so the build stays warning-free.
@@ -1514,5 +1694,15 @@ mod tests {
         // A destroyed window's entry stops answering once removed (the Destroyed handler's job).
         map.remove("ws-1");
         assert_eq!(window_label_for_workspace(&map, "tauri:/b", None), None);
+
+        // A single-note window registers its workspace too, but must never answer a
+        // workspace-level focus-if-open — opening a workspace should never land on a lone note.
+        map.insert("note-1".to_string(), "tauri:/b".to_string());
+        assert_eq!(window_label_for_workspace(&map, "tauri:/b", None), None);
+        map.insert("ws-2".to_string(), "tauri:/b".to_string());
+        assert_eq!(
+            window_label_for_workspace(&map, "tauri:/b", None),
+            Some("ws-2".to_string())
+        );
     }
 }
diff --git a/src/App.tsx b/src/App.tsx
index ba01513..5549782 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -73,10 +73,20 @@ export function App() {
                                 workspaceId={storage.activeWorkspaceId ?? 'workspace'}
                                 storageLabel={storage.storageLabel}
                                 workspaces={storage.workspaces}
+                                // A single-note window's assigned note — only while it still
+                                // shows the workspace it was created for (an in-place workspace
+                                // switch remounts Workspace without a note assignment).
+                                initialNoteId={
+                                    storage.windowNote &&
+                                    storage.windowNote.workspaceId === storage.activeWorkspaceId
+                                        ? storage.windowNote.noteId
+                                        : null
+                                }
                                 themePref={themePref}
                                 onChangeThemePref={setThemePref}
                                 onOpenWorkspace={storage.openWorkspace}
                                 onOpenWorkspaceInNewWindow={storage.openInNewWindow}
+                                onOpenNoteInNewWindow={storage.openNoteInNewWindow}
                                 onRemoveWorkspace={storage.removeWorkspace}
                                 onRefreshWorkspaces={storage.refreshWorkspaces}
                                 onOpenFolder={() => void storage.pickFolder()}
diff --git a/src/components/FolderGate.test.tsx b/src/components/FolderGate.test.tsx
index 8cbdfe7..7aa4d1d 100644
--- a/src/components/FolderGate.test.tsx
+++ b/src/components/FolderGate.test.tsx
@@ -1,4 +1,4 @@
-import {screen} from '@testing-library/react';
+import {act, screen} from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import {describe, expect, it, vi} from 'vitest';
 
@@ -16,6 +16,7 @@ function makeStorage(over: Partial<NotesStorage> = {}): NotesStorage {
         backend: null,
         storageLabel: null,
         activeWorkspaceId: null,
+        windowNote: null,
         workspaces: [],
         error: null,
         isTauri,
@@ -28,6 +29,7 @@ function makeStorage(over: Partial<NotesStorage> = {}): NotesStorage {
         reset: vi.fn(async () => {}),
         openWorkspace: vi.fn(async () => true),
         openInNewWindow: vi.fn(async () => {}),
+        openNoteInNewWindow: vi.fn(async () => {}),
         removeWorkspace: vi.fn(async () => {}),
         refreshWorkspaces: vi.fn(async () => {}),
         ...over,
@@ -83,9 +85,25 @@ describe('FolderGate', () => {
         expect(storage.reset).toHaveBeenCalledTimes(1);
     });
 
-    it('renders the choice screen while loading', () => {
+    it('renders no gate UI while loading (no welcome-card flash in fresh windows)', () => {
         renderWithProviders(<FolderGate storage={makeStorage({state: 'loading'})} />);
-        expect(screen.getByRole('button', {name: /Open a folder/})).toBeInTheDocument();
+        expect(screen.queryByText('Welcome to Gravity Notes')).not.toBeInTheDocument();
+        expect(screen.queryByRole('button', {name: /Open a folder/})).not.toBeInTheDocument();
+    });
+
+    it('shows the bootstrap spinner only once the restore proves slow', () => {
+        vi.useFakeTimers();
+        try {
+            renderWithProviders(<FolderGate storage={makeStorage({state: 'loading'})} />);
+            // Immediately: just the themed background, not even a spinner (the common fast case).
+            expect(document.querySelector('.g-loader')).toBeNull();
+            act(() => {
+                vi.advanceTimersByTime(400);
+            });
+            expect(document.querySelector('.g-loader')).not.toBeNull();
+        } finally {
+            vi.useRealTimers();
+        }
     });
 
     it('renders the error text when set', () => {
@@ -110,7 +128,7 @@ describe('FolderGate', () => {
         expect(storage.openWorkspace).toHaveBeenCalledWith('tauri:/Users/me/Vault');
     });
 
-    it('hides the recents list while loading (a click would race the restore)', () => {
+    it('hides the recents list while loading (no gate UI at all — a click would race the restore)', () => {
         renderWithProviders(
             <FolderGate
                 storage={makeStorage({
diff --git a/src/components/FolderGate.tsx b/src/components/FolderGate.tsx
index 244432b..8c209c2 100644
--- a/src/components/FolderGate.tsx
+++ b/src/components/FolderGate.tsx
@@ -1,5 +1,7 @@
+import {useEffect, useState} from 'react';
+
 import {Database, Folder} from '@gravity-ui/icons';
-import {Button, Card, Icon, Text} from '@gravity-ui/uikit';
+import {Button, Card, Icon, Loader, Text} from '@gravity-ui/uikit';
 
 import type {NotesStorage} from '../hooks/useNotesStorage';
 
@@ -8,12 +10,29 @@ import './FolderGate.css';
 /** How many recents the choice screen offers (the full list lives in the in-app switcher). */
 const MAX_GATE_RECENTS = 5;
 
+/**
+ * Only a restore slower than this shows the bootstrap spinner at all. The common case — the
+ * last-active workspace (or a fresh ws-/note- window's shell-assigned one, which even skips the
+ * folder probe) opening in well under this — paints straight from the themed background into the
+ * workspace, with no intermediate flash of gate UI.
+ */
+const LOADER_DELAY_MS = 300;
+
 /**
  * Full-screen gate shown until a storage backend is chosen and ready. Renders the first-run
  * "where do your notes live" choice (a folder on your computer, or in this browser) and the
- * folder re-permission prompt, per the non-ready states of {@link NotesStorage}.
+ * folder re-permission prompt, per the non-ready states of {@link NotesStorage}. The transient
+ * 'loading' bootstrap state renders NO gate UI — flashing the welcome/choice card at every new
+ * window was noise — just a spinner once the restore proves slow (see LOADER_DELAY_MS).
  */
 export function FolderGate({storage}: {storage: NotesStorage}) {
+    if (storage.state === 'loading') {
+        return (
+            <div className="folder-gate">
+                <DelayedLoader />
+            </div>
+        );
+    }
     return (
         <div className="folder-gate">
             <Card className="folder-gate__card" view="raised">
@@ -28,6 +47,16 @@ export function FolderGate({storage}: {storage: NotesStorage}) {
     );
 }
 
+/** Nothing for the first {@link LOADER_DELAY_MS}, then a plain centered spinner. */
+function DelayedLoader() {
+    const [visible, setVisible] = useState(false);
+    useEffect(() => {
+        const timer = setTimeout(() => setVisible(true), LOADER_DELAY_MS);
+        return () => clearTimeout(timer);
+    }, []);
+    return visible ? <Loader size="m" /> : null;
+}
+
 function Content({storage}: {storage: NotesStorage}) {
     if (storage.state === 'needs-permission') {
         return (
@@ -49,7 +78,8 @@ function Content({storage}: {storage: NotesStorage}) {
         );
     }
 
-    // 'choosing' (and 'loading', which shows the same choice briefly).
+    // 'choosing' — the bootstrap 'loading' state never reaches here (FolderGate renders the
+    // delayed spinner for it instead), so nothing below needs a mid-restore disabled state.
     return (
         <>
             <Icon data={Folder} size={32} className="folder-gate__icon" />
@@ -63,13 +93,7 @@ function Content({storage}: {storage: NotesStorage}) {
             </Text>
             <div className="folder-gate__actions">
                 {storage.supportsFolders ? (
-                    <Button
-                        view="action"
-                        size="l"
-                        loading={storage.state === 'loading'}
-                        disabled={storage.state === 'loading'}
-                        onClick={() => void storage.pickFolder()}
-                    >
+                    <Button view="action" size="l" onClick={() => void storage.pickFolder()}>
                         Open a folder…
                     </Button>
                 ) : null}
@@ -79,12 +103,6 @@ function Content({storage}: {storage: NotesStorage}) {
                     <Button
                         view={storage.supportsFolders ? 'outlined' : 'action'}
                         size="l"
-                        loading={storage.state === 'loading' && !storage.supportsFolders}
-                        // Disable while the remembered choice is still being restored, so a click
-                        // can't discard it mid-bootstrap (the folder button already showed a
-                        // spinner; this one didn't when `supportsFolders`, leaving it racily
-                        // clickable).
-                        disabled={storage.state === 'loading'}
                         onClick={() => void storage.useBrowserStorage()}
                     >
                         Store in this browser
@@ -98,9 +116,8 @@ function Content({storage}: {storage: NotesStorage}) {
                 </Text>
             ) : null}
             {/* Known workspaces, so landing here (first run aside — e.g. after a failed folder
-                probe) is never a dead end: any recent is one click away. Only once bootstrap has
-                settled — clicking mid-'loading' would race the restore. */}
-            {storage.state === 'choosing' && storage.workspaces.length > 0 ? (
+                probe) is never a dead end: any recent is one click away. */}
+            {storage.workspaces.length > 0 ? (
                 <div className="folder-gate__recents">
                     <Text variant="caption-2" color="secondary">
                         Or reopen a recent workspace:
diff --git a/src/components/NoteList.test.tsx b/src/components/NoteList.test.tsx
index 79d4155..09397ce 100644
--- a/src/components/NoteList.test.tsx
+++ b/src/components/NoteList.test.tsx
@@ -486,6 +486,78 @@ describe('NoteList — reveal in Finder', () => {
     });
 });
 
+describe('NoteList — open in new window (desktop)', () => {
+    it('opens a note in a new window via the row menu', async () => {
+        const user = userEvent.setup();
+        const onOpenInNewWindow = vi.fn();
+        setup({onOpenInNewWindow});
+        const beta = screen.getByRole('option', {name: /Beta/});
+        await user.click(within(beta).getByRole('button', {name: 'Note actions'}));
+        await user.click(await screen.findByRole('menuitem', {name: /Open in New Window/}));
+        expect(onOpenInNewWindow).toHaveBeenCalledWith('Beta.md');
+    });
+
+    it('omits the item on targets without windows (no onOpenInNewWindow)', async () => {
+        const user = userEvent.setup();
+        setup();
+        const beta = screen.getByRole('option', {name: /Beta/});
+        await user.click(within(beta).getByRole('button', {name: 'Note actions'}));
+        expect(await screen.findByRole('menuitem', {name: /Rename/})).toBeInTheDocument();
+        expect(
+            screen.queryByRole('menuitem', {name: /Open in New Window/}),
+        ).not.toBeInTheDocument();
+    });
+
+    it('⌘↵ on a focused row opens that note in a new window (no commit)', () => {
+        const onOpenInNewWindow = vi.fn();
+        const {props} = setup({onOpenInNewWindow});
+        const beta = screen.getByRole('option', {name: /Beta/});
+        beta.focus();
+        fireEvent.keyDown(beta, {key: 'Enter', metaKey: true});
+        expect(onOpenInNewWindow).toHaveBeenCalledWith('Beta.md');
+        expect(props.onCommit).not.toHaveBeenCalled();
+    });
+
+    it('⌘⇧↵ (the global new-note chord) is left to bubble, not treated as open-in-window', () => {
+        const onOpenInNewWindow = vi.fn();
+        setup({onOpenInNewWindow});
+        const beta = screen.getByRole('option', {name: /Beta/});
+        beta.focus();
+        fireEvent.keyDown(beta, {key: 'Enter', metaKey: true, shiftKey: true});
+        expect(onOpenInNewWindow).not.toHaveBeenCalled();
+    });
+
+    it('⌘↵ stays inert without the callback (web build)', () => {
+        const {props} = setup();
+        const beta = screen.getByRole('option', {name: /Beta/});
+        beta.focus();
+        fireEvent.keyDown(beta, {key: 'Enter', metaKey: true});
+        expect(props.onCommit).not.toHaveBeenCalled();
+    });
+
+    it('⌘-click on a row opens it in a new window, leaving this window’s selection alone', () => {
+        const onOpenInNewWindow = vi.fn();
+        const {props} = setup({onOpenInNewWindow});
+        fireEvent.click(screen.getByRole('option', {name: /Beta/}), {metaKey: true});
+        expect(onOpenInNewWindow).toHaveBeenCalledWith('Beta.md');
+        expect(props.onBrowse).not.toHaveBeenCalled();
+    });
+
+    it('a plain click still browses even when the callback is present', () => {
+        const onOpenInNewWindow = vi.fn();
+        const {props} = setup({onOpenInNewWindow});
+        fireEvent.click(screen.getByRole('option', {name: /Beta/}));
+        expect(props.onBrowse).toHaveBeenCalledWith('Beta.md');
+        expect(onOpenInNewWindow).not.toHaveBeenCalled();
+    });
+
+    it('⌘-click without the callback (web build) falls back to a normal browse', () => {
+        const {props} = setup();
+        fireEvent.click(screen.getByRole('option', {name: /Beta/}), {metaKey: true});
+        expect(props.onBrowse).toHaveBeenCalledWith('Beta.md');
+    });
+});
+
 describe('NoteList — right-click context menu', () => {
     it('opens the row action menu on right-click and runs an action', async () => {
         const user = userEvent.setup();
@@ -495,10 +567,14 @@ describe('NoteList — right-click context menu', () => {
         expect(props.onRequestMove).toHaveBeenCalledWith('Alpha.md');
     });
 
-    it('previews the right-clicked note (so the menu acts on what you clicked)', () => {
+    it('right-click leaves the selection/preview untouched (the menu carries its own target)', async () => {
+        const user = userEvent.setup();
         const {props} = setup({selectedId: 'Alpha.md'});
         fireEvent.contextMenu(screen.getByRole('option', {name: /Beta/}));
-        expect(props.onBrowse).toHaveBeenCalledWith('Beta.md');
+        expect(props.onBrowse).not.toHaveBeenCalled();
+        // …and the menu still acts on the note that was right-clicked, not the selected one.
+        await user.click(await screen.findByRole('menuitem', {name: /Duplicate/}));
+        expect(props.onDuplicate).toHaveBeenCalledWith('Beta.md');
     });
 });
 
diff --git a/src/components/NoteList.tsx b/src/components/NoteList.tsx
index bbf09b7..9e36435 100644
--- a/src/components/NoteList.tsx
+++ b/src/components/NoteList.tsx
@@ -9,9 +9,15 @@ import {
     useRef,
     useState,
 } from 'react';
-import type {KeyboardEvent as ReactKeyboardEvent, ReactNode, RefObject} from 'react';
+import type {
+    KeyboardEvent as ReactKeyboardEvent,
+    MouseEvent as ReactMouseEvent,
+    ReactNode,
+    RefObject,
+} from 'react';
 
 import {
+    ArrowUpRightFromSquare,
     Copy,
     Ellipsis,
     Folder,
@@ -88,6 +94,11 @@ export interface NoteListProps {
     onRequestMove: (id: string) => void;
     /** Duplicate a note (shares its attachments). */
     onDuplicate: (id: string) => void;
+    /**
+     * Open a note in its own single-note window — desktop shell only (absent = menu item hidden
+     * and ⌘↵ on a row inert).
+     */
+    onOpenInNewWindow?: (id: string) => void;
     /** Reveal a note in Finder — present only on the native desktop backend (else hidden). */
     onReveal?: (id: string) => void;
     onRename: (id: string, nextTitle: string) => void;
@@ -128,6 +139,20 @@ function highlightTerms(text: string, terms: string[]): ReactNode {
     );
 }
 
+/**
+ * ⌘/Ctrl with no other modifier — the open-in-new-window chord, on ↵ and on click alike
+ * (see onOpenInNewWindow). On macOS a Ctrl+click never reaches the click handler (WebKit turns it
+ * into the contextmenu event), so in practice the mouse path means ⌘-click.
+ */
+function isOpenInNewWindowChord(event: {
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+}): boolean {
+    return (event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey;
+}
+
 /** Compact list date: 24-hour time for today, otherwise `DD.MM.YY`. Exported for unit tests. */
 export function formatNoteDate(ts: number | undefined): string {
     if (!ts) return '';
@@ -167,7 +192,7 @@ interface NoteRowProps {
     /** Toggle the list's one shared icon-picker popup, anchored to this row's glyph button. */
     onOpenIconPicker: (id: string, anchor: HTMLElement) => void;
     showIcons: boolean;
-    onClickRow: (id: string) => void;
+    onClickRow: (id: string, event: ReactMouseEvent<HTMLDivElement>) => void;
     onContextMenuRow: (note: NoteMeta, x: number, y: number) => void;
     onKeyDownRow: (event: ReactKeyboardEvent<HTMLDivElement>, id: string) => void;
     onOpenMenu: (note: NoteMeta, anchor: HTMLElement) => void;
@@ -220,7 +245,14 @@ const NoteRow = memo(function NoteRow({
                 e.dataTransfer.setData(NOTE_MIME, note.id);
                 e.dataTransfer.setData('text/plain', note.id);
             }}
-            onClick={() => onClickRow(note.id)}
+            onClick={(e) => onClickRow(note.id, e)}
+            onMouseDown={(e) => {
+                // Right-click and ⌘-click act on a row WITHOUT selecting it — block the mousedown
+                // default so the focusable row doesn't grab DOM focus either (the context menu /
+                // new window works off the row id; a plain-click browse focuses explicitly via
+                // focusRowById, so it loses nothing).
+                if (e.button === 2 || isOpenInNewWindowChord(e)) e.preventDefault();
+            }}
             onContextMenu={(e) => {
                 e.preventDefault();
                 onContextMenuRow(note, e.clientX, e.clientY);
@@ -352,6 +384,7 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
         onCreate,
         onRequestMove,
         onDuplicate,
+        onOpenInNewWindow,
         onReveal,
         onRename,
         onDelete,
@@ -424,6 +457,7 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
         onCommit,
         onEscapeList,
         onFocusRail,
+        onOpenInNewWindow,
         onRename,
         onSetIcon,
     });
@@ -437,6 +471,7 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
         onCommit,
         onEscapeList,
         onFocusRail,
+        onOpenInNewWindow,
         onRename,
         onSetIcon,
     };
@@ -576,20 +611,28 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
     }, []);
 
     const onClickRow = useCallback(
-        (id: string) => {
-            if (live.current.editingId !== id) browseRow(id);
+        (id: string, event: ReactMouseEvent<HTMLDivElement>) => {
+            const {editingId: editing, onOpenInNewWindow: openInNew} = live.current;
+            if (editing === id) return;
+            // ⌘-click (desktop): open the note in its own window, leaving this window's selection
+            // alone — the same modifier convention as ⌘↵ here and ⌘-click in the recents submenu.
+            // Without the callback (web) the modifier is ignored and the click browses as usual.
+            if (openInNew && isOpenInNewWindowChord(event)) {
+                openInNew(id);
+                return;
+            }
+            browseRow(id);
         },
         [browseRow],
     );
 
-    const onContextMenuRow = useCallback(
-        (note: NoteMeta, x: number, y: number) => {
-            if (live.current.editingId === note.id) return;
-            browseRow(note.id);
-            setMenu({note, anchor: {getBoundingClientRect: () => new DOMRect(x, y, 0, 0)}});
-        },
-        [browseRow],
-    );
+    // Deliberately NO browse here: right-click acts on the clicked note via the menu's own
+    // `note` payload, without moving the selection/preview off whatever is open (same rule as
+    // ⌘-click / ⌘↵ opening a new window).
+    const onContextMenuRow = useCallback((note: NoteMeta, x: number, y: number) => {
+        if (live.current.editingId === note.id) return;
+        setMenu({note, anchor: {getBoundingClientRect: () => new DOMRect(x, y, 0, 0)}});
+    }, []);
 
     const onOpenMenu = useCallback((note: NoteMeta, anchor: HTMLElement) => {
         setMenu((open) => (open?.note.id === note.id ? null : {note, anchor}));
@@ -654,8 +697,17 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
                         focusRail();
                     }
                     break;
-                case 'Enter':
-                    if (!bare) break; // ⌘/Ctrl+Enter is the global new-note shortcut — let it bubble
+                case 'Enter': {
+                    if (!bare) {
+                        // ⌘↵ (no ⇧): open this row's note in its own desktop window. Everything
+                        // else modified — notably ⌘⇧↵, the global new-note chord — still bubbles.
+                        const {onOpenInNewWindow: openInNew} = live.current;
+                        if (openInNew && isOpenInNewWindowChord(event)) {
+                            event.preventDefault();
+                            openInNew(id);
+                        }
+                        break;
+                    }
                     // From a focused row-level button (icon glyph, ⋯ actions), Enter must activate
                     // the button — preventDefault on the bubbled keydown would cancel the button's
                     // click synthesis and open the note instead.
@@ -663,6 +715,7 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
                     event.preventDefault();
                     commit(id);
                     break;
+                }
                 case 'Escape':
                     event.preventDefault();
                     escape();
@@ -684,6 +737,16 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
     const noteMenuItems = (note: NoteMeta) => {
         const pinned = pinnedSet.has(note.id);
         return [
+            // Desktop only: a per-note window. First, like Apple Notes' context menu (⌘↵ too).
+            ...(onOpenInNewWindow
+                ? [
+                      {
+                          text: 'Open in New Window',
+                          iconStart: <Icon data={ArrowUpRightFromSquare} />,
+                          action: () => onOpenInNewWindow(note.id),
+                      },
+                  ]
+                : []),
             {
                 text: pinned ? 'Unpin' : 'Pin to top',
                 iconStart: <Icon data={pinned ? PinSlash : Pin} />,
diff --git a/src/components/ShortcutsDialog.test.tsx b/src/components/ShortcutsDialog.test.tsx
index a78d0c7..a28eb08 100644
--- a/src/components/ShortcutsDialog.test.tsx
+++ b/src/components/ShortcutsDialog.test.tsx
@@ -7,13 +7,19 @@ import {renderWithProviders} from '../test/render';
 import {ShortcutsDialog} from './ShortcutsDialog';
 
 describe('ShortcutsDialog', () => {
-    it('renders a row for every shortcut in the descriptor', () => {
+    it('renders a row for every shortcut in the descriptor (sans desktop-only, on the web)', () => {
         renderWithProviders(<ShortcutsDialog open onClose={vi.fn()} />);
+        // jsdom is the web build (no Tauri shell), so desktop-shell-only rows are filtered out.
+        const visible = SHORTCUTS.filter((shortcut) => !shortcut.desktopOnly);
+        expect(visible.length).toBeLessThan(SHORTCUTS.length); // the filter has something to do
         // One row per descriptor; descriptions can repeat (e.g. two chords both make a New note).
-        expect(document.querySelectorAll('.shortcuts-dialog__row')).toHaveLength(SHORTCUTS.length);
-        for (const shortcut of SHORTCUTS) {
+        expect(document.querySelectorAll('.shortcuts-dialog__row')).toHaveLength(visible.length);
+        for (const shortcut of visible) {
             expect(screen.getAllByText(shortcut.description).length).toBeGreaterThan(0);
         }
+        for (const shortcut of SHORTCUTS.filter((s) => s.desktopOnly)) {
+            expect(screen.queryByText(shortcut.description)).not.toBeInTheDocument();
+        }
     });
 
     it('includes the previously-missing rows', () => {
diff --git a/src/components/ShortcutsDialog.tsx b/src/components/ShortcutsDialog.tsx
index e5c6e0c..214db6e 100644
--- a/src/components/ShortcutsDialog.tsx
+++ b/src/components/ShortcutsDialog.tsx
@@ -1,5 +1,6 @@
 import {Dialog, Hotkey, Text} from '@gravity-ui/uikit';
 
+import {isTauri} from '../isTauri';
 import {SHORTCUTS, SHORTCUT_GROUPS} from '../shortcuts';
 
 import './ShortcutsDialog.css';
@@ -19,7 +20,11 @@ export function ShortcutsDialog({open, onClose}: ShortcutsDialogProps) {
             <Dialog.Body>
                 <div className="shortcuts-dialog">
                     {SHORTCUT_GROUPS.map((group) => {
-                        const rows = SHORTCUTS.filter((shortcut) => shortcut.group === group);
+                        // Desktop-shell-only rows (per-note windows, ⌘0) are noise in the browser.
+                        const rows = SHORTCUTS.filter(
+                            (shortcut) =>
+                                shortcut.group === group && (!shortcut.desktopOnly || isTauri),
+                        );
                         if (rows.length === 0) return null;
                         return (
                             <div key={group} className="shortcuts-dialog__group">
diff --git a/src/components/Workspace.test.tsx b/src/components/Workspace.test.tsx
index 2674a0c..65eb29d 100644
--- a/src/components/Workspace.test.tsx
+++ b/src/components/Workspace.test.tsx
@@ -36,10 +36,12 @@ function workspaceProps() {
         workspaceId: 'test-ws',
         storageLabel: 'notes',
         workspaces: [],
+        initialNoteId: null,
         themePref: 'light' as const,
         onChangeThemePref: vi.fn(),
         onOpenWorkspace: vi.fn(async () => true),
         onOpenWorkspaceInNewWindow: vi.fn(async () => {}),
+        onOpenNoteInNewWindow: vi.fn(async () => {}),
         onRemoveWorkspace: vi.fn(async () => {}),
         onRefreshWorkspaces: vi.fn(async () => {}),
         onOpenFolder: vi.fn(),
diff --git a/src/components/Workspace.tsx b/src/components/Workspace.tsx
index a696b3d..bf85c25 100644
--- a/src/components/Workspace.tsx
+++ b/src/components/Workspace.tsx
@@ -22,7 +22,7 @@ import {
     useWorkspaceSettings,
 } from '../hooks/useSettings';
 import {useShortcuts} from '../hooks/useShortcuts';
-import {isMainWindow, isTauri} from '../isTauri';
+import {isMainWindow, isNoteWindow, isTauri} from '../isTauri';
 import {orderNotes, trashEntryOriginalId} from '../storage/metadata';
 import {dirname, sanitizeTitle, titleFromFileName} from '../storage/noteText';
 import {exportNotes, importNotes} from '../storage/transfer';
@@ -56,12 +56,19 @@ interface WorkspaceProps {
     storageLabel: string | null;
     /** Known workspaces, most recently opened first — feeds the recents menu + ⌃R switcher. */
     workspaces: WorkspaceInfo[];
+    /**
+     * A single-note window's assigned note: opened instead of the last-active restore (and the
+     * window starts with both side panels closed). Null in every other window and on the web.
+     */
+    initialNoteId: string | null;
     themePref: ThemePref;
     onChangeThemePref: (pref: ThemePref) => void;
     /** Switch this window to a workspace; false = it could not be opened (we stay put). */
     onOpenWorkspace: (id: string) => Promise<boolean>;
     /** Desktop only: open a workspace in its own window. */
     onOpenWorkspaceInNewWindow: (id: string) => Promise<void>;
+    /** Desktop only: open a note from this workspace in its own single-note window. */
+    onOpenNoteInNewWindow: (noteId: string, title: string) => Promise<void>;
     /** Drop a workspace from the recents registry. */
     onRemoveWorkspace: (id: string) => Promise<void>;
     /** Re-read the registry (other windows may have opened workspaces since). */
@@ -142,10 +149,12 @@ export function Workspace({
     workspaceId,
     storageLabel,
     workspaces,
+    initialNoteId,
     themePref,
     onChangeThemePref,
     onOpenWorkspace,
     onOpenWorkspaceInNewWindow,
+    onOpenNoteInNewWindow,
     onRemoveWorkspace,
     onRefreshWorkspaces,
     onOpenFolder,
@@ -153,6 +162,12 @@ export function Workspace({
 }: WorkspaceProps) {
     const {add} = useToaster();
 
+    // A single-note desktop window (constant for the window's whole life — it's the label).
+    // Both side panels start closed there, and its transient layout is never persisted to the
+    // workspace-namespaced keys: those belong to the full workspace views, and one localStorage
+    // is shared by every window.
+    const noteWindow = isNoteWindow();
+
     const onError = useCallback(
         (message: string) => {
             add({
@@ -166,7 +181,7 @@ export function Workspace({
         [add],
     );
 
-    const notes = useNotes(store, onError);
+    const notes = useNotes(store, onError, initialNoteId);
 
     // One attachment URL cache per store: resolves `Attachments/…` refs to object URLs for the
     // editor NodeView and preview. `useMemo` keeps a stable cache per store; the previous cache's
@@ -241,16 +256,19 @@ export function Workspace({
     const {backlinks} = useBacklinks(orderedNotes, notes.activeId, corpus);
 
     // The tree is collapsed by default; this persists the folders the user has explicitly expanded
-    // (the exceptions). A toggle rebuilds the set immutably.
+    // (the exceptions). A toggle rebuilds the set immutably. Note windows start from the defaults
+    // and skip both the read (readWorkspaceKey CONSUMES the legacy un-namespaced keys — a note
+    // window must not eat the main window's migration) and the write.
     const [expandedFolders, setExpandedFolders] = useState<Set<string>>(() =>
-        loadExpandedFolders(workspaceId),
+        noteWindow ? new Set() : loadExpandedFolders(workspaceId),
     );
     useEffect(() => {
+        if (noteWindow) return;
         localStorage.setItem(
             nsKey(workspaceId, 'expanded-folders'),
             JSON.stringify([...expandedFolders]),
         );
-    }, [workspaceId, expandedFolders]);
+    }, [noteWindow, workspaceId, expandedFolders]);
     // One-time cleanup of the orphaned pre-inversion key (its semantics flipped, so it's unusable).
     useEffect(() => localStorage.removeItem(LEGACY_COLLAPSED_FOLDERS_KEY), []);
     const toggleCollapse = useCallback((path: string) => {
@@ -262,14 +280,18 @@ export function Workspace({
         });
     }, []);
 
-    // The folder selected in the rail (null = All Notes), persisted across reloads.
+    // The folder selected in the rail (null = All Notes), persisted across reloads. A note window
+    // always starts at All Notes (its list is hidden anyway, and ⌘N should create predictably).
     const [selectedFolder, setSelectedFolder] = useState<string | null>(() =>
-        readWorkspaceKey(workspaceId, 'selected-folder', LEGACY_SELECTED_FOLDER_KEY),
+        noteWindow
+            ? null
+            : readWorkspaceKey(workspaceId, 'selected-folder', LEGACY_SELECTED_FOLDER_KEY),
     );
     useEffect(() => {
+        if (noteWindow) return;
         if (selectedFolder === null) localStorage.removeItem(nsKey(workspaceId, 'selected-folder'));
         else localStorage.setItem(nsKey(workspaceId, 'selected-folder'), selectedFolder);
-    }, [workspaceId, selectedFolder]);
+    }, [noteWindow, workspaceId, selectedFolder]);
     // A selected folder that no longer exists (deleted, or renamed elsewhere) falls back to All Notes.
     useEffect(() => {
         if (selectedFolder !== null && !notes.folders.includes(selectedFolder)) {
@@ -278,13 +300,16 @@ export function Workspace({
     }, [notes.folders, selectedFolder]);
 
     // Whether the folder rail is shown. Off by default, so the app stays a 2-pane nvALT view
-    // until you reach for folders; persisted across reloads.
+    // until you reach for folders; persisted across reloads (never in a note window — closed).
     const [railOpen, setRailOpen] = useState(
-        () => readWorkspaceKey(workspaceId, 'rail-open', LEGACY_RAIL_OPEN_KEY) === 'true',
+        () =>
+            !noteWindow &&
+            readWorkspaceKey(workspaceId, 'rail-open', LEGACY_RAIL_OPEN_KEY) === 'true',
     );
     useEffect(() => {
+        if (noteWindow) return;
         localStorage.setItem(nsKey(workspaceId, 'rail-open'), String(railOpen));
-    }, [workspaceId, railOpen]);
+    }, [noteWindow, workspaceId, railOpen]);
     const toggleRail = useCallback(() => setRailOpen((open) => !open), []);
 
     // Drive list MODE (ranked search vs folder scope) off the debounced query, so the list flips in
@@ -520,11 +545,14 @@ export function Workspace({
         return () => window.removeEventListener('scroll', onScroll, true);
     }, []);
     const [collapsed, setCollapsed] = useState(
-        () => readWorkspaceKey(workspaceId, 'sidebar-collapsed', LEGACY_SIDEBAR_KEY) === 'true',
+        () =>
+            noteWindow ||
+            readWorkspaceKey(workspaceId, 'sidebar-collapsed', LEGACY_SIDEBAR_KEY) === 'true',
     );
     useEffect(() => {
+        if (noteWindow) return;
         localStorage.setItem(nsKey(workspaceId, 'sidebar-collapsed'), String(collapsed));
-    }, [workspaceId, collapsed]);
+    }, [noteWindow, workspaceId, collapsed]);
     const toggleCollapsed = useCallback(() => setCollapsed((c) => !c), []);
 
     // Transient overlay reveal of the collapsed sidebar (⌘⇧'); not persisted. Only meaningful
@@ -581,10 +609,43 @@ export function Workspace({
         navigate: historyNavigate,
     });
 
-    // Land in the search box on first load (nvALT: ready to type); a restored note is previewed unfocused.
+    // Land in the search box on first load (nvALT: ready to type); a restored note is previewed
+    // unfocused. A note window exists to edit its one note, so it lands in the editor body instead
+    // (below, once the note has loaded and the editor mounted).
     useEffect(() => {
-        searchInputRef.current?.focus();
+        if (!noteWindow) searchInputRef.current?.focus();
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only (noteWindow is constant)
     }, []);
+    const initialEditorFocusRef = useRef(false);
+    useEffect(() => {
+        if (!noteWindow || initialEditorFocusRef.current || !notes.note) return;
+        initialEditorFocusRef.current = true;
+        editorRef.current?.focus();
+    }, [noteWindow, notes.note]);
+
+    // A note window's native title tracks its open note (rename included), falling back to the
+    // workspace label once no note is open; it also keeps the shell's label→note assignment
+    // current, so a later "open in new window" for the note now shown here focuses this window
+    // instead of duplicating it — and stops matching a note this window has navigated away from.
+    // `notes.note` only changes identity on open/reload (edits flow through refs), so it's a
+    // stable-enough dep.
+    const openNote = notes.note;
+    useEffect(() => {
+        if (!noteWindow) return;
+        void (async () => {
+            try {
+                const {invoke} = await import('@tauri-apps/api/core');
+                await invoke('set_window_note', {noteId: openNote?.id ?? null});
+                const {getCurrentWindow} = await import('@tauri-apps/api/window');
+                await getCurrentWindow().setTitle(
+                    openNote?.title ??
+                        (storageLabel ? `${storageLabel} — Gravity Notes` : 'Gravity Notes'),
+                );
+            } catch {
+                // Best-effort: a failure only leaves the title stale / focus-if-open duplicable.
+            }
+        })();
+    }, [noteWindow, openNote, storageLabel]);
 
     // Global Esc fallback: when focus is somewhere that doesn't handle Esc itself (the top
     // bar, the document body), send it back to the note list so keyboard nav resumes. When the
@@ -676,6 +737,48 @@ export function Workspace({
         [onOpenWorkspaceInNewWindow, onError],
     );
 
+    // ⌘0 / Window ▸ Main Window: the shell asks the FOCUSED window (this one) to surface the full
+    // workspace view for ITS workspace. Reusing the workspace-window opener gives the right
+    // semantics for free: it focuses the existing main/ws-N window showing this workspace
+    // (un-hiding a ⌘W-hidden main), creates one when none exists, and never lands on a note
+    // window — so ⌘0 stays within the current workspace instead of dragging forward a main
+    // window parked on some other one. In a full workspace window it self-focuses (a no-op).
+    useEffect(() => {
+        if (!isTauri) return undefined;
+        let unlisten: (() => void) | undefined;
+        let disposed = false;
+        void import('@tauri-apps/api/webviewWindow').then(({getCurrentWebviewWindow}) =>
+            getCurrentWebviewWindow()
+                .listen('menu:main-window', () => handleOpenWorkspaceInNewWindow(workspaceId))
+                .then((fn) => {
+                    if (disposed) fn();
+                    else unlisten = fn;
+                }),
+        );
+        return () => {
+            disposed = true;
+            unlisten?.();
+        };
+    }, [workspaceId, handleOpenWorkspaceInNewWindow]);
+
+    // Open a note in its own single-note window (row menu / ⌘↵ in the list). Unlike a workspace
+    // window, flush first: the new window reads the note from DISK, so a pending edit here (this
+    // note may well be the open one) must land before that page loads.
+    const handleOpenNoteInNewWindow = useCallback(
+        (id: string) => {
+            void (async () => {
+                await notes.flushPending();
+                const title = notes.notes.find((n) => n.id === id)?.title ?? titleFromFileName(id);
+                try {
+                    await onOpenNoteInNewWindow(id, title);
+                } catch (err) {
+                    onError(err instanceof Error ? err.message : 'Could not open a new window');
+                }
+            })();
+        },
+        [notes, onOpenNoteInNewWindow, onError],
+    );
+
     const handleRemoveWorkspace = useCallback(
         (id: string) => {
             onRemoveWorkspace(id).catch((err) =>
@@ -1174,6 +1277,7 @@ export function Workspace({
                             onCreate={handleCreate}
                             onRequestMove={setMovingNoteId}
                             onDuplicate={handleDuplicate}
+                            onOpenInNewWindow={isTauri ? handleOpenNoteInNewWindow : undefined}
                             onReveal={handleReveal}
                             onRename={handleRename}
                             onDelete={handleDelete}
@@ -1239,11 +1343,15 @@ export function Workspace({
                                 />
                             </>
                         ) : (
-                            <div className="workspace__placeholder">
-                                <Text variant="body-2" color="secondary">
-                                    Select a note, or create a new one to start writing.
-                                </Text>
-                            </div>
+                            // Only once loading settled: flashing the placeholder before the
+                            // restored note lands read as a blink on every new window.
+                            notes.ready && (
+                                <div className="workspace__placeholder">
+                                    <Text variant="body-2" color="secondary">
+                                        Select a note, or create a new one to start writing.
+                                    </Text>
+                                </div>
+                            )
                         )}
                     </main>
                 </div>
diff --git a/src/hooks/useNotes.test.tsx b/src/hooks/useNotes.test.tsx
index edc489c..ec69315 100644
--- a/src/hooks/useNotes.test.tsx
+++ b/src/hooks/useNotes.test.tsx
@@ -167,6 +167,52 @@ describe('useNotes — single note', () => {
         expect(hook.result.current.note).toBeNull();
     });
 
+    it('an initialNoteId (single-note window) overrides the restore and spares the sidecar', async () => {
+        const onError = vi.fn();
+        const dir = new FakeDirectoryHandle();
+        dir.seedFile('A.md', 'a', 100);
+        dir.seedFile('B.md', 'b', 200);
+        const metadata = JSON.stringify({
+            version: 1,
+            sort: 'updated',
+            pinned: [],
+            created: {},
+            active: 'A.md',
+        });
+        dir.seedFile(METADATA_FILENAME, metadata);
+        const store = new FileSystemNoteStore(asDirectoryHandle(dir));
+        const hook = renderHook(() => useNotes(store, onError, 'B.md'));
+        // The window's assigned note opens, not the sidecar's last-active pointer…
+        await waitFor(() => expect(hook.result.current.activeId).toBe('B.md'));
+        expect(hook.result.current.note?.content).toBe('b');
+        expect(hook.result.current.sessionId).toBeGreaterThan(0);
+        // …and the sidecar keeps pointing at A.md: the main window's restore must not be
+        // hijacked just because a note window opened.
+        expect((await store.readMetadata()).active).toBe('A.md');
+    });
+
+    it('a missing initialNoteId opens nothing and leaves the sidecar pointer intact', async () => {
+        const onError = vi.fn();
+        const dir = new FakeDirectoryHandle();
+        dir.seedFile('A.md', 'a', 100);
+        dir.seedFile(
+            METADATA_FILENAME,
+            JSON.stringify({
+                version: 1,
+                sort: 'updated',
+                pinned: [],
+                created: {},
+                active: 'A.md',
+            }),
+        );
+        const store = new FileSystemNoteStore(asDirectoryHandle(dir));
+        const hook = renderHook(() => useNotes(store, onError, 'Deleted.md'));
+        await waitFor(() => expect(hook.result.current.notes).toHaveLength(1));
+        expect(hook.result.current.note).toBeNull();
+        // A.md may still be perfectly valid for the main window — no heal-write here.
+        expect((await store.readMetadata()).active).toBe('A.md');
+    });
+
     it('closing clears the active note', async () => {
         const {hook, store} = await setup((dir) => dir.seedFile('A.md', 'a', 100));
         await waitFor(() => expect(hook.result.current.notes).toHaveLength(1));
diff --git a/src/hooks/useNotes.ts b/src/hooks/useNotes.ts
index 9107d51..9725b1a 100644
--- a/src/hooks/useNotes.ts
+++ b/src/hooks/useNotes.ts
@@ -8,7 +8,6 @@ import {
     withCreatedStamp,
     withIcon,
     withNoteAppearance,
-    withTrashedAppearance,
     withPinToggled,
     withRemoved,
     withRenamed,
@@ -16,6 +15,7 @@ import {
     withSortMode,
     withTrashEmptied,
     withTrashed,
+    withTrashedAppearance,
     withoutTrashEntry,
 } from '../storage/metadata';
 import {dirname, previewFromContent, titleFromFileName} from '../storage/noteText';
@@ -79,6 +79,12 @@ const SAVE_TIMEOUT_MS = 15_000;
 /** Retry a transient save failure a few times (capped backoff) before leaving it to the user. */
 const MAX_SAVE_RETRIES = 5;
 const RETRY_MAX_DELAY = 30_000;
+/**
+ * Minimum gap between focus-driven list refreshes. Regaining focus re-lists the store (the same
+ * folder can be open in several desktop windows — main + single-note windows — and in other apps),
+ * but focus can flap when ⌘-tabbing through windows, and a full list() walks the whole store.
+ */
+const FOCUS_REFRESH_MIN_GAP_MS = 2_000;
 
 /** A detected external change to the open note. */
 export interface NoteConflict {
@@ -201,8 +207,16 @@ export interface UseNotes {
  * autosave for a given `NoteStore`. Editing is decoupled from React state: keystrokes
  * flow into a ref + timer (not `setState`), so the editor is never re-created mid-typing.
  * Switching notes (`open`) flushes the outgoing note's pending edit first.
+ *
+ * `initialNoteId` (a single-note desktop window's assigned note) overrides the restore: that note
+ * is opened instead of the sidecar's last-`active` pointer, and the sidecar is NOT healed/written
+ * during the load — the last-active pointer belongs to the main window's next-launch restore.
  */
-export function useNotes(store: NoteStore, onError: (message: string) => void): UseNotes {
+export function useNotes(
+    store: NoteStore,
+    onError: (message: string) => void,
+    initialNoteId?: string | null,
+): UseNotes {
     const [notes, setNotes] = useState<NoteMeta[]>([]);
     const [folders, setFolders] = useState<string[]>([]);
     const [trashedNotes, setTrashedNotes] = useState<TrashedNote[]>([]);
@@ -1071,10 +1085,12 @@ export function useNotes(store: NoteStore, onError: (message: string) => void):
                 const meta = reconcile(raw, [...list.map((n) => n.id), ...folderList], {
                     recursive: store.listsRecursively,
                 });
+                // A note window restores its ASSIGNED note, not the (shared) last-active pointer.
+                const restoreId = initialNoteId ?? meta.active;
                 let loaded: Note | null = null;
-                if (meta.active) {
+                if (restoreId) {
                     try {
-                        loaded = await store.get(meta.active);
+                        loaded = await store.get(restoreId);
                     } catch {
                         loaded = null;
                     }
@@ -1085,7 +1101,7 @@ export function useNotes(store: NoteStore, onError: (message: string) => void):
                 const {trashed, display} = buildTrashView(meta.trashed, trashList);
                 const reconciled: NotesMetadata = {
                     ...meta,
-                    active: loaded ? meta.active : null,
+                    active: loaded ? restoreId : null,
                     trashed,
                 };
                 setNotes(list);
@@ -1097,8 +1113,12 @@ export function useNotes(store: NoteStore, onError: (message: string) => void):
                     setNote(loaded);
                     bumpSession();
                 }
-                if (reconciled.active !== meta.active) {
-                    void store.writeMetadata(reconciled); // heal the dotfile if active vanished
+                // Heal the dotfile if active vanished — but never from an initialNoteId override:
+                // in-memory `active` then deliberately differs from disk, and writing it would
+                // clobber the pointer the MAIN window restores from (whether the override loaded
+                // or turned out deleted).
+                if (!initialNoteId && reconciled.active !== meta.active) {
+                    void store.writeMetadata(reconciled);
                 }
                 // Signal that the sidecar is loaded — gates work that must not race the load above
                 // (e.g. Workspace's legacy-appearance migration, which read-modify-writes it).
@@ -1113,7 +1133,7 @@ export function useNotes(store: NoteStore, onError: (message: string) => void):
         return () => {
             cancelled = true;
         };
-    }, [store, applyMetadata, bumpSession, onError]);
+    }, [store, initialNoteId, applyMetadata, bumpSession, onError]);
 
     // Clear pending timers (autosave + the throttled metadata write) when the hook unmounts.
     useEffect(() => {
@@ -1217,6 +1237,27 @@ export function useNotes(store: NoteStore, onError: (message: string) => void):
         };
     }, [store]);
 
+    // Re-list on window focus: the check above covers only the OPEN note, but with single-note
+    // windows the same folder is routinely shown in several windows at once, so a returning window
+    // must also pick up notes created/edited/renamed elsewhere (another window, another app).
+    // Gated on `ready` so it can't interleave with the initial load, throttled against focus flap,
+    // and skipped mid-move like the conflict check.
+    useEffect(() => {
+        if (!ready) return undefined;
+        let last = 0;
+        const onFocus = () => {
+            if (document.visibilityState !== 'visible' || moveInProgressRef.current) return;
+            const now = Date.now();
+            if (now - last < FOCUS_REFRESH_MIN_GAP_MS) return;
+            last = now;
+            refresh().catch(() => {
+                // A transient read failure keeps the current list; the next focus retries.
+            });
+        };
+        window.addEventListener('focus', onFocus);
+        return () => window.removeEventListener('focus', onFocus);
+    }, [ready, refresh]);
+
     return {
         notes,
         folders,
diff --git a/src/hooks/useNotesStorage.ts b/src/hooks/useNotesStorage.ts
index e31e524..5bd5a43 100644
--- a/src/hooks/useNotesStorage.ts
+++ b/src/hooks/useNotesStorage.ts
@@ -1,6 +1,6 @@
 import {useCallback, useEffect, useRef, useState} from 'react';
 
-import {isTauri} from '../isTauri';
+import {isNoteWindow, isTauri} from '../isTauri';
 import {FileSystemNoteStore} from '../storage/fileSystemStore';
 import {IndexedDbNoteStore} from '../storage/indexedDbStore';
 import {TauriNoteStore} from '../storage/tauriStore';
@@ -76,6 +76,39 @@ const PROBE_TIMEOUT_MS = 10_000;
 interface OpenOpts {
     seq: number;
     isBootstrap?: boolean;
+    /**
+     * Skip the folder liveness probe: the workspace was assigned to this window by the shell
+     * moments ago (a fresh ws-/note- window spawned from a LIVE workspace), so the folder was
+     * just verified by the opener — re-walking it here only delays the new window's first paint.
+     */
+    skipProbe?: boolean;
+}
+
+/**
+ * The desktop shell's per-window assignment: the workspace this window was created for (ws-/note-
+ * windows, set before the page loaded), plus — for single-note windows — the note to open. Null
+ * when unassigned (the main window at launch) or outside the shell. A failed note read degrades
+ * to workspace-only rather than discarding the workspace.
+ */
+async function readWindowAssignment(): Promise<{
+    workspaceId: string;
+    noteId: string | null;
+} | null> {
+    if (!isTauri) return null;
+    try {
+        const {invoke} = await import('@tauri-apps/api/core');
+        const workspaceId = await invoke<string | null>('window_workspace');
+        if (!workspaceId) return null;
+        let noteId: string | null = null;
+        try {
+            noteId = await invoke<string | null>('window_note');
+        } catch {
+            // Without the note assignment this window still opens its workspace normally.
+        }
+        return {workspaceId, noteId};
+    } catch {
+        return null;
+    }
 }
 
 /** The user-facing message for a failed folder probe. */
@@ -98,6 +131,12 @@ export interface NotesStorage {
     storageLabel: string | null;
     /** The active workspace's registry id, or null until `ready`. */
     activeWorkspaceId: string | null;
+    /**
+     * This desktop window's note assignment (single-note windows only): the workspace it was
+     * created for and the note to open instead of the last-active restore. Read once at bootstrap;
+     * null in every other window and on the web.
+     */
+    windowNote: {workspaceId: string; noteId: string} | null;
     /** Known workspaces, most recently opened first (includes the active one). */
     workspaces: WorkspaceInfo[];
     error: string | null;
@@ -123,6 +162,11 @@ export interface NotesStorage {
     openWorkspace(id: string): Promise<boolean>;
     /** Desktop only: open a workspace in its own window (focused if already open somewhere). */
     openInNewWindow(id: string): Promise<void>;
+    /**
+     * Desktop only: open a note from the ACTIVE workspace in its own single-note window (focused
+     * if that note is already open in one). `title` seeds the native window title.
+     */
+    openNoteInNewWindow(noteId: string, title: string): Promise<void>;
     /** Drop a workspace from the registry (its notes on disk are untouched). */
     removeWorkspace(id: string): Promise<void>;
     /** Re-read the registry (e.g. before showing a recents list — other windows may have written). */
@@ -141,6 +185,9 @@ export function useNotesStorage(): NotesStorage {
     const [backend, setBackend] = useState<StorageBackend | null>(null);
     const [storageLabel, setStorageLabel] = useState<string | null>(null);
     const [activeWorkspaceId, setActiveWorkspaceId] = useState<string | null>(null);
+    const [windowNote, setWindowNote] = useState<{workspaceId: string; noteId: string} | null>(
+        null,
+    );
     const [workspaces, setWorkspaces] = useState<WorkspaceInfo[]>([]);
     const [error, setError] = useState<string | null>(null);
     // Full registry entries (with handles) backing the exposed WorkspaceInfo list.
@@ -193,6 +240,9 @@ export function useNotesStorage(): NotesStorage {
                 // Without the registration this window just won't be focus-if-open targetable.
             }
             if (isStale(seq)) return;
+            // A single-note window's native title tracks its open NOTE (owned by Workspace's
+            // title-sync effect), not the workspace — don't fight over it.
+            if (isNoteWindow()) return;
             try {
                 const {getCurrentWindow} = await import('@tauri-apps/api/window');
                 if (isStale(seq)) return;
@@ -230,26 +280,28 @@ export function useNotesStorage(): NotesStorage {
             // re-pick, rather than stranding them on a broken workspace. The probe is
             // time-bounded: a huge/strange folder (home dir, a network mount) makes the
             // recursive walk hang instead of throw, which would otherwise leave the app stuck
-            // on the loading spinner — where the choice buttons are disabled — forever.
-            try {
-                await withTimeout(tauriStore.list(), PROBE_TIMEOUT_MS, 'Folder probe');
-            } catch (err) {
-                if (isStale(seq)) return false;
-                const timedOut = err instanceof TimeoutError;
-                // A bootstrap timeout means the folder is effectively unusable (too large /
-                // too slow), so forget the launch pointer — otherwise the next launch re-hangs
-                // on the same path. The registry entry itself is kept (removable in the UI).
-                if (timedOut && isBootstrap) await clearLastActive().catch(() => {});
+            // on the loading screen forever. Skipped for shell-assigned windows (see OpenOpts).
+            if (!opts.skipProbe) {
+                try {
+                    await withTimeout(tauriStore.list(), PROBE_TIMEOUT_MS, 'Folder probe');
+                } catch (err) {
+                    if (isStale(seq)) return false;
+                    const timedOut = err instanceof TimeoutError;
+                    // A bootstrap timeout means the folder is effectively unusable (too large /
+                    // too slow), so forget the launch pointer — otherwise the next launch re-hangs
+                    // on the same path. The registry entry itself is kept (removable in the UI).
+                    if (timedOut && isBootstrap) await clearLastActive().catch(() => {});
+                    if (isStale(seq)) return false;
+                    // Surface the error either way: on bootstrap it also routes to the choice
+                    // screen; on a switch it stays on the current workspace but the message must
+                    // still show (the FolderGate recents list reads `error` and has no toaster of
+                    // its own, so without this a click on a gone folder would silently do nothing).
+                    setError(probeFailureMessage(err, timedOut));
+                    if (isBootstrap) setState('choosing');
+                    return false;
+                }
                 if (isStale(seq)) return false;
-                // Surface the error either way: on bootstrap it also routes to the choice screen;
-                // on a switch it stays on the current workspace but the message must still show
-                // (the FolderGate recents list reads `error` and has no toaster of its own, so
-                // without this a click on a gone folder would silently do nothing).
-                setError(probeFailureMessage(err, timedOut));
-                if (isBootstrap) setState('choosing');
-                return false;
             }
-            if (isStale(seq)) return false;
             activate(entry, tauriStore, seq);
             return true;
         },
@@ -327,16 +379,17 @@ export function useNotesStorage(): NotesStorage {
                 entriesRef.current = entries;
                 setWorkspaces(entries.map(toInfo));
                 // A desktop window created via "open in new window" was assigned its workspace
-                // before its page loaded; the main window has no assignment at launch.
-                let targetId: string | undefined;
-                if (isTauri) {
-                    try {
-                        const {invoke} = await import('@tauri-apps/api/core');
-                        targetId = (await invoke<string | null>('window_workspace')) ?? undefined;
-                    } catch {
-                        targetId = undefined;
-                    }
-                    if (bail()) return;
+                // before its page loaded; the main window has no assignment at launch. A
+                // single-note window additionally carries the note it was opened for — Workspace
+                // opens that instead of the sidecar's last-active restore.
+                const assignment = await readWindowAssignment();
+                if (bail()) return;
+                let targetId = assignment?.workspaceId;
+                if (assignment?.noteId) {
+                    setWindowNote({
+                        workspaceId: assignment.workspaceId,
+                        noteId: assignment.noteId,
+                    });
                 }
                 if (!targetId) {
                     targetId = await loadLastActiveId();
@@ -349,7 +402,13 @@ export function useNotesStorage(): NotesStorage {
                     setState('choosing');
                     return;
                 }
-                const opened = await openEntry(entry, {seq, isBootstrap: true});
+                const opened = await openEntry(entry, {
+                    seq,
+                    isBootstrap: true,
+                    // A shell-assigned workspace was verified seconds ago by the window that
+                    // spawned this one — skip the probe so the new window paints sooner.
+                    skipProbe: assignment !== null,
+                });
                 if (bail()) return;
                 // A restored entry that couldn't be opened but set no state itself (e.g. a
                 // malformed entry missing its path/handle) must not strand the app on the
@@ -533,6 +592,15 @@ export function useNotesStorage(): NotesStorage {
         });
     }, []);
 
+    const openNoteInNewWindow = useCallback(async (noteId: string, title: string) => {
+        if (!isTauri) return;
+        // The note belongs to THIS window's workspace — the shell assigns both to the new window.
+        const wsId = activeIdRef.current;
+        if (!wsId) return;
+        const {invoke} = await import('@tauri-apps/api/core');
+        await invoke('open_note_window', {wsId, noteId, title});
+    }, []);
+
     const removeWorkspace = useCallback(
         async (id: string) => {
             await removeWorkspaceEntry(id);
@@ -547,6 +615,7 @@ export function useNotesStorage(): NotesStorage {
         backend,
         storageLabel,
         activeWorkspaceId,
+        windowNote,
         workspaces,
         error,
         isTauri,
@@ -558,6 +627,7 @@ export function useNotesStorage(): NotesStorage {
         reset,
         openWorkspace,
         openInNewWindow,
+        openNoteInNewWindow,
         removeWorkspace,
         refreshWorkspaces,
     };
diff --git a/src/hooks/useShortcuts.ts b/src/hooks/useShortcuts.ts
index d37338e..f0a1ddb 100644
--- a/src/hooks/useShortcuts.ts
+++ b/src/hooks/useShortcuts.ts
@@ -1,5 +1,6 @@
 import {useEffect, useRef} from 'react';
 
+import {isTauri} from '../isTauri';
 import {type GlobalBinding, SHORTCUTS, type ShortcutAction} from '../shortcuts';
 
 export type ShortcutActions = Record<ShortcutAction, () => void>;
@@ -56,8 +57,9 @@ export function useShortcuts(actions: ShortcutActions): void {
             // own listeners, not this hook.
             if (document.querySelector('[role="dialog"]')) return;
             const typing = isTypingTarget(document.activeElement);
-            for (const {global: binding} of SHORTCUTS) {
+            for (const {global: binding, desktopOnly} of SHORTCUTS) {
                 if (!binding) continue;
+                if (desktopOnly && !isTauri) continue; // desktop-shell chords stay free on the web
                 if (Boolean(binding.capture) !== capturePhase) continue;
                 const allowInTyping = binding.inTyping ?? binding.trigger !== 'bare';
                 if (typing && !allowInTyping) continue;
diff --git a/src/isTauri.ts b/src/isTauri.ts
index 7121a8a..a0d2e29 100644
--- a/src/isTauri.ts
+++ b/src/isTauri.ts
@@ -34,3 +34,17 @@ export function currentWindowLabel(): string {
 export function isMainWindow(): boolean {
     return currentWindowLabel() === MAIN_WINDOW_LABEL;
 }
+
+/**
+ * Label prefix of single-note windows (`note-1`, `note-2`, …) created by the shell's
+ * `open_note_window`. Mirrors `NOTE_WINDOW_PREFIX` in `src-tauri/src/lib.rs` — keep them in sync.
+ * Like ws-N windows they really close on ⌘W; unlike them they open with both side panels closed,
+ * restore their assigned note instead of the sidecar's last-active pointer, and are excluded from
+ * workspace-level focus-if-open.
+ */
+export const NOTE_WINDOW_PREFIX = 'note-';
+
+/** Whether this window is a single-note window (see {@link NOTE_WINDOW_PREFIX}); false on web/tests. */
+export function isNoteWindow(): boolean {
+    return currentWindowLabel().startsWith(NOTE_WINDOW_PREFIX);
+}
diff --git a/src/shortcuts.ts b/src/shortcuts.ts
index 52f19b1..f22fe99 100644
--- a/src/shortcuts.ts
+++ b/src/shortcuts.ts
@@ -59,6 +59,11 @@ export interface ShortcutDescriptor {
     group: 'Navigation' | 'Editing' | 'General';
     /** Present when the global handler (useShortcuts) owns this key; absent for list-scoped keys. */
     global?: GlobalBinding;
+    /**
+     * Only meaningful in the desktop shell: hidden from the help dialog in the browser build, and
+     * a `global` binding (if any) is skipped there by useShortcuts.
+     */
+    desktopOnly?: boolean;
 }
 
 /** Single source of truth for both the global handler and the help dialog. */
@@ -108,6 +113,22 @@ export const SHORTCUTS: ShortcutDescriptor[] = [
         description: 'Edit the selected note (in the title → jump to the body)',
         group: 'Navigation',
     },
+    {
+        keys: 'mod+enter',
+        description: 'Open the selected note in a new window (or ⌘-click it)',
+        group: 'Navigation',
+        // List-scoped: handled by the focused row in NoteList, like plain Enter — no global binding.
+        desktopOnly: true,
+    },
+    {
+        keys: 'mod+0',
+        description: 'Show this workspace’s main window',
+        group: 'Navigation',
+        // Bound NATIVELY (Window ▸ Main Window carries the CmdOrCtrl+0 accelerator — see
+        // build_menu in src-tauri/src/lib.rs), so it works from any window regardless of focus;
+        // this row exists for discoverability only.
+        desktopOnly: true,
+    },
     {keys: 'esc', description: 'Editor → list, then close (or clear search)', group: 'Navigation'},
     // No global binding: focusing search is the tail of the Esc ladder (escapeList focuses
     // the search box).

From ba39b9e7bbeee584ac05c37a8fe86e2a115d1585 Mon Sep 17 00:00:00 2001
From: Gadzhi Gadzhiev <168296+resure@users.noreply.github.com>
Date: Sun, 5 Jul 2026 15:55:25 +0300
Subject: [PATCH 2/5] =?UTF-8?q?fix:=20field-testing=20round=20=E2=80=94=20?=
 =?UTF-8?q?markup=20undo=20isolation,=20live=20URLs,=20popup=20gating,=20i?=
 =?UTF-8?q?Cloud,=20window=20polish?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Editor correctness:
- Markup-mode ⌘Z could walk back into the PREVIOUS note (the one reused
  CodeMirror instance records replace() in its history, and addToHistory:false
  only remaps old events). A pristine CM state snapshotted at mount now
  templates a fresh per-note state on every swap (editor/markupHistory.ts;
  @codemirror/state+commands become direct deps — single deduped copies).
- Wiki tooltip/suggest popups no longer pop on note open (stuck top-left):
  gated through swappingRef — which now also starts TRUE at mount, since a
  fresh window never runs the swap path — plus a detached-anchor guard, and a
  caret at a link's LEFT edge no longer counts as inside it.
- WKWebView occasionally left a stale paint of the caret line (a "doubled"
  ghost line, few px offset): .editor-pane gets its own compositing layer.

Live URLs (fuzzy off everywhere — .md is a real TLD; a Notes.md mention must
never linkify or be rewritten on disk):
- md.linkify in the WYSIWYG editor (bare URLs normalize once to <url> on save),
  mirrored in the preview transform; preview link clicks route through
  openExternalUrl instead of navigating the surface.
- Typed URLs linkify on the trailing space via an InputRule that sets the
  editor's raw-link attr — typed links round-trip as the bare url.

iCloud Drive: the bulk walks skip dataless (SF_DATALESS) file content instead
of blocking on download-on-demand — a non-downloaded folder lists instantly
with empty previews; an explicit note open still materializes the file.

Windows & workspace UX:
- Note windows cascade centered on the opener's monitor (opener+28px glued
  them onto the main window — read as a doubled editor).
- "Open Folder…" honors ⌘ (switcher ⌘↵/⌘-click, orb menu ⌘-click): picks a
  folder into its OWN window via pickFolderForNewWindow (registry entry
  persisted before the window spawns).
- Read-only preview shows a floating chip (hover: "Exit preview"; click exits).
- A folder scope chip names the filter when the rail is closed (click opens
  the rail, ✕ back to All Notes without switching notes).
- Typing a search while the sidebar is collapsed auto-peeks the list without
  stealing focus from the box; clearing or committing tucks it away.

Docs: CLAUDE.md + README caught up (per-note windows, ⌘0, live URLs, chips).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md                                     | 118 +++++++++++++-----
 README.md                                     |  41 +++---
 package-lock.json                             |   6 +-
 package.json                                  |   2 +
 src-tauri/src/lib.rs                          |  58 +++++++--
 src/App.tsx                                   |   1 +
 src/components/EditorPane.css                 |   7 ++
 src/components/EditorPane.tsx                 |  66 +++++++++-
 src/components/FolderGate.test.tsx            |   1 +
 src/components/NoteList.css                   |  12 ++
 src/components/NoteList.test.tsx              |  35 ++++++
 src/components/NoteList.tsx                   |  38 +++++-
 src/components/NotePreview.test.tsx           |  47 ++++++-
 src/components/NotePreview.tsx                |  33 ++++-
 src/components/TopBar.tsx                     |  13 +-
 src/components/Workspace.css                  |  23 ++++
 src/components/Workspace.test.tsx             |  41 ++++++
 src/components/Workspace.tsx                  |  86 ++++++++++++-
 .../WorkspaceSwitcherDialog.test.tsx          |  34 ++++-
 src/components/WorkspaceSwitcherDialog.tsx    |   8 +-
 src/components/editor/linkifyTypedUrls.ts     |  55 ++++++++
 src/components/editor/markupHistory.test.ts   |  62 +++++++++
 src/components/editor/markupHistory.ts        |  53 ++++++++
 src/components/editor/wikiLinkExtension.ts    |  24 +++-
 src/components/editor/wikiSuggest.ts          |  10 +-
 src/hooks/useNotesStorage.ts                  |  36 ++++++
 26 files changed, 832 insertions(+), 78 deletions(-)
 create mode 100644 src/components/editor/linkifyTypedUrls.ts
 create mode 100644 src/components/editor/markupHistory.test.ts
 create mode 100644 src/components/editor/markupHistory.ts

diff --git a/CLAUDE.md b/CLAUDE.md
index a8d80c0..4118f6a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -26,23 +26,40 @@ time). Both work across all three backends.
 Every opened folder/store is a **workspace**: an IndexedDB registry (`src/storage/workspaceRegistry.ts`)
 remembers them all with recency, feeding the orb menu's "Open Recent" submenu, the **⌃R switcher
 dialog**, and — desktop only — **one native window per workspace** (several at once; ⌘-click a recent
-or ⌘↵ in the switcher). Per-workspace UI layout (sidebar/rail/selected folder) lives under
-workspace-namespaced localStorage keys; the sidecar metadata is per-folder anyway.
+or ⌘↵ in the switcher — the modifier also works on "Open Folder…", picking a folder straight into a
+new window). Desktop also has **per-note windows** (Apple-Notes-style): ⌘↵ / ⌘-click a list row or
+its ⋯ menu opens that note in its own `note-N` window — both side panels closed, focus in the editor
+body, native title = the note title, per-note focus-if-open — and **⌘0** (Window ▸ Main Window, a
+native accelerator) surfaces the full workspace window for THAT window's workspace, un-hiding or
+creating one as needed. Per-workspace UI layout (sidebar/rail/selected folder) lives under
+workspace-namespaced localStorage keys — note windows neither read nor write those (their transient
+layout must not clobber the full views', and reading would eat the legacy-key migration); the sidecar
+metadata is per-folder anyway.
 
 Notes also move between backends via `.md` export/import (`src/storage/transfer.ts`). The Rust shell
 lives in `src-tauri/` (only `src-tauri/src/lib.rs` carries app code: `notes_*` + `attachment_*` fs
-commands, the folder ops, `reveal_path`, and the **workspace-window commands** — a label→workspace map
-powering `window_workspace`/`set_window_workspace`/`focus_workspace_window`/`open_workspace_window`
-(`ws-N` windows cloned from the main window's config); it also registers the **updater** + **process**
-plugins, sets the macOS window chrome (factored as `apply_macos_chrome`, applied to every window: a
-theme-aware native background for anti-flash, plus an empty unified-compact **NSToolbar** that makes
-the title bar tall with SYSTEM-positioned traffic lights — macOS 26 re-runs title-bar layout on every
-pass and reverts hand-set button frames, so never position the lights manually), and builds a
-**custom app menu** whose macOS "About" item emits `menu:about`
-to the FOCUSED window so the frontend can open its own `AboutDialog`). **Close flow:** the main window
-hides on ⌘W (Rust-side, macOS convention) while `ws-N` windows really close — `useNotes`'s
-`onCloseRequested` handler flushes pending edits then calls `preventDefault()` ONLY for `main`; the JS
-wrapper's `destroy()` needs the `core:window:allow-destroy` capability, so those two must stay in sync.
+commands (the bulk walks skip iCloud **dataless** files' content — `SF_DATALESS` in `st_flags` —
+because reading one blocks on download; they list by name/mtime with empty previews, and an explicit
+single-note open still materializes), the folder ops, `reveal_path`, and the **window commands** — a
+label→workspace map plus a label→note map powering
+`window_workspace`/`set_window_workspace`/`focus_workspace_window`/`open_workspace_window` and
+`window_note`/`set_window_note`/`open_note_window` (`ws-N` and `note-N` windows cloned from the main
+window's config; note windows are 760×640, cascade centered on the opener's monitor, get their
+workspace AND note assigned before the page loads, and are EXCLUDED from workspace-level
+focus-if-open — `NOTE_WINDOW_PREFIX` is mirrored in `src/isTauri.ts`, keep in sync); it also registers
+the **updater** + **process** plugins, sets the macOS window chrome (factored as
+`apply_macos_chrome`, applied to every window: a theme-aware native background for anti-flash, plus an
+empty unified-compact **NSToolbar** that makes the title bar tall with SYSTEM-positioned traffic
+lights — macOS 26 re-runs title-bar layout on every pass and reverts hand-set button frames, so never
+position the lights manually), and builds a **custom app menu**: the macOS "About" item emits
+`menu:about` to the FOCUSED window so the frontend can open its own `AboutDialog`, and "Main Window"
+(`CmdOrCtrl+0`) emits `menu:main-window` the same way — the focused window's frontend then
+focuses-or-creates the workspace window for ITS OWN workspace (never dragging forward a main window
+parked on another one). **Close flow:** the main window hides on ⌘W (Rust-side, macOS convention)
+while `ws-N`/`note-N` windows really close — `useNotes`'s `onCloseRequested` handler flushes pending
+edits then calls `preventDefault()` ONLY for `main`; the JS wrapper's `destroy()` needs the
+`core:window:allow-destroy` capability (granted to `main`, `ws-*`, and `note-*`), so those must stay
+in sync.
 
 The desktop app ships **in-app auto-update** via the official Tauri 2 updater, delivered through GitHub
 Releases (`src/hooks/useAppUpdater.ts`; cut a release with the `/release` runbook in `.claude/skills/release`).
@@ -162,12 +179,19 @@ Key modules:
   never a blob URL.
 - `src/hooks/useNotesStorage.ts` — the workspace lifecycle (state machine:
   `loading`/`choosing`/`needs-permission`/`ready`); yields a ready `NoteStore` plus the recents list.
-  Bootstrap order: the shell's per-window assignment (`invoke('window_workspace')`, set before a
-  `ws-N` window's page loads) → the last-active pointer → `choosing`. `openWorkspace(id)` switches in
-  place (probe-guarded; desktop first asks `focus_workspace_window` so a workspace already shown
-  elsewhere is focused, not duplicated; a failed switch leaves the current workspace mounted);
-  `openInNewWindow(id)` invokes `open_workspace_window`; activation touches the registry, registers
-  the window's workspace, and sets the native title. Detects the Tauri shell (`__TAURI_INTERNALS__`):
+  Bootstrap order: the shell's per-window assignment (`readWindowAssignment`: `window_workspace` +
+  `window_note`, both set before a `ws-N`/`note-N` window's page loads; a shell-assigned workspace
+  SKIPS the folder probe — the opener verified it seconds ago — so new windows paint fast) → the
+  last-active pointer → `choosing`. A note window's assignment surfaces as `windowNote`
+  ({workspaceId, noteId}), which App forwards to `Workspace` as `initialNoteId` only while the window
+  still shows that workspace. `openWorkspace(id)` switches in place (probe-guarded; desktop first asks
+  `focus_workspace_window` so a workspace already shown elsewhere is focused, not duplicated; a failed
+  switch leaves the current workspace mounted); `openInNewWindow(id)` invokes `open_workspace_window`;
+  `openNoteInNewWindow(noteId, title)` invokes `open_note_window` for the ACTIVE workspace;
+  `pickFolderForNewWindow()` picks a folder and opens it as its own window — persisting the registry
+  entry FIRST, since that's what the new window's bootstrap reads. Activation touches the registry,
+  registers the window's workspace, and sets the native title (skipped in note windows — their title
+  tracks the open note, owned by `Workspace`). Detects the Tauri shell (`__TAURI_INTERNALS__`):
   there `pickFolder()` uses the native dialog and `tauri-fs` opens go straight to `ready` (no
   `needs-permission`; an FSA _switch_ tries `requestPermission` inline — it runs off a gesture —
   before falling back to the grant gate). `supportsFolders` (= native app OR browser FSA) drives
@@ -182,8 +206,13 @@ Key modules:
   not `setState`, so the markdown editor instance is never re-created mid-typing. Pending edits are
   flushed before every lifecycle transition (open/create/rename/remove/close/change-storage) and on
   `visibilitychange` / `beforeunload`; `open()` is guarded by a generation counter (wrong-note race) and
-  short-circuits the already-open note (no remount). Exposes `flushPending()` (teardown) and
-  `refresh()` (re-list after import). Takes a `NoteStore` — agnostic to which backend it is.
+  short-circuits the already-open note (no remount). An optional `initialNoteId` (a note window's
+  assignment) overrides the restore: that note loads instead of the sidecar's last-`active` pointer,
+  and the sidecar is NOT written during the load — the pointer belongs to the main window's
+  next-launch restore. Re-lists on window focus (2 s throttle, `ready`-gated) — main + note windows
+  routinely show the same folder now, so a returning window picks up notes created/edited elsewhere.
+  Exposes `flushPending()` (teardown) and `refresh()` (re-list after import). Takes a `NoteStore` —
+  agnostic to which backend it is.
 - `src/hooks/useCorpus.ts` — the **shared body corpus**, loaded once (lazily, while a query is live or a
   note is open) and shared by full-text search AND backlinks, so `getAll()` runs once (one big IPC on
   desktop) and every body is held once. Derives `contentById` (raw, for snippets), `lowerById`
@@ -225,13 +254,21 @@ Key modules:
   adds a manual "Check for Updates…" item; `UpdateDialog` renders the flow.
 - `src/components/` — `FolderGate` (first-run storage choice + folder re-permission gate + a recents
   list so a failed probe is never a dead end; **desktop is folder-first** — in-browser storage is
-  offered on the web only), `Workspace` (top bar + layout + nav wiring; takes the
+  offered on the web only; the transient `loading` state renders NO gate UI — just a 300 ms-delayed
+  spinner — so fresh windows don't flash the welcome card), `Workspace` (top bar + layout + nav
+  wiring; takes the
   `NoteStore` and a `workspaceId` — App remounts it `key`ed per workspace, so switches start clean;
   owns export/import and the flush-then-confirm guard before any workspace switch; per-workspace UI
   layout persists under `gravity-notes:<wsId>:*` localStorage keys, adopting the legacy un-namespaced
-  value once), `TopBar` (nvALT search box + orb menu [export / import / manage attachments / trash /
-  **Open Recent submenu** (click = switch in place, ⌘-click = new window on desktop; "Workspaces…"
-  opens the ⌃R switcher) / **Open Folder…**] + theme/help controls + save-status dot),
+  value once — note windows skip both the read and the write, start with panels closed + editor
+  focused, and sync their native title + `set_window_note` assignment to the open note; also owns the
+  floating **Preview badge** (read-only preview is otherwise invisible; hover swaps it to "Exit
+  preview", click or ⌘⇧P leaves) and the **search auto-peek** — typing a query while the sidebar is
+  collapsed peeks the list WITHOUT stealing focus from the box, and clearing the query or committing a
+  match tucks it away), `TopBar` (nvALT search box + orb menu [export / import / manage attachments /
+  trash / **Open Recent submenu** (click = switch in place, ⌘-click = new window on desktop;
+  "Workspaces…" opens the ⌃R switcher) / **Open Folder…** (⌘-click = new window)] + theme/help
+  controls + save-status dot),
   `WorkspaceSwitcherDialog` (the ⌃R recents switcher; shares the keyboard model with MoveToDialog via
   `useListboxNav`: filter + ↑/↓ + ↵ open / ⌘↵ new window / ⌘⌫ remove; OTHER workspaces lead by recency
   with the current one parked last, and the top row is pre-highlighted, so ⌃R↵ ⌃R↵ ping-pongs between
@@ -240,7 +277,12 @@ Key modules:
   strands), `FolderRail` (collapsible
   nested-folder tree left of the list — select/scope,
   drag-and-drop, rename, pin; toggle ⌘⇧\), `NoteList` (sidebar with create/rename/delete/move, pin,
-  sort; **virtualized** via `@tanstack/react-virtual`, with a `rangeExtractor` that keeps the
+  sort, **Open in New Window** (row ⋯/context menu, ⌘↵, ⌘-click — desktop only, gated by the optional
+  `onOpenInNewWindow` prop); right-click and ⌘-click deliberately NEVER move the selection (the menu
+  acts via its own payload, and a row `onMouseDown` blocks the focus grab); a **folder-scope chip**
+  names the filter when a folder is selected while the rail is closed (click opens the rail, ✕ clears
+  to All Notes without switching notes); **virtualized** via `@tanstack/react-virtual`, with a
+  `rangeExtractor` that keeps the
   keyboard-focused row and any open row popover's anchor row (⋯ menu / icon picker) mounted; rows
   render only an `IconPickerButton` glyph and share ONE `IconPickerPopup` — like the one shared row
   menu — so a closed picker costs nothing per row and scrolling can't unmount an open one), `MoveToDialog` (the ⌘⇧M move-to-folder picker — the chord is
@@ -248,7 +290,23 @@ Key modules:
   `useListboxNav` with the workspace switcher),
   `EditorPane` (wraps the Gravity markdown editor; re-created per editing session via a stable
   `useNotes.sessionId`, so a rename doesn't remount it; saves/restores per-note **scroll + caret** on
-  switch — the reused editor would otherwise carry the previous note's scrollTop; the floating
+  switch — the reused editor would otherwise carry the previous note's scrollTop; a note switch also
+  hard-resets BOTH undo histories — ProseMirror via a fresh `EditorState`, and markup-mode CodeMirror
+  via `editor/markupHistory.ts` (a pristine CM state snapshotted at mount becomes the template for
+  fresh per-note states — `replace()` is a history-recorded dispatch and `addToHistory:false` only
+  REMAPS old events, so without the template reset ⌘Z in markup mode walked into the previous note's
+  content); **linkify**: `md: {linkify: true}` with fuzzy matching OFF via `configureMd`
+  (`fuzzyLink/fuzzyEmail: false` — `.md` is a real TLD, so fuzzy would rewrite a `Notes.md` mention
+  on disk; bare URLs normalize once to `<url>` on save) plus `editor/linkifyTypedUrls.ts`, an
+  InputRule that linkifies a just-typed URL on trailing whitespace with the `raw-link` attr (typed
+  links round-trip as the BARE url); the wiki tooltip/suggest popups are gated by `swappingRef`
+  (exposed as `isSwapping` to the extension) which starts TRUE at mount and brackets every content
+  swap — mid-swap anchors get detached by the swap's own redraw (a popup pinned to a detached element
+  renders stuck at the viewport's top-left), and a restored caret inside a `[[link]]` must not pop UI
+  unasked (the caret at a link's LEFT edge doesn't count as inside it, matching `inclusive: false`);
+  `.editor-pane` carries `transform: translateZ(0)` — its own compositing layer — because WKWebView
+  otherwise occasionally leaves a stale paint of the caret line behind after a swap/resize (a ghost
+  "doubled" line); the floating
   **selection toolbar is a vendored fixed copy** (`editor/selectionContextFix.ts` — the stock plugin
   never re-arms its flags after the plugin-view recreation every note switch triggers, going
   permanently dead; the bundle's own is disabled via `selectionContext: {config: []}` and the fixed
@@ -258,7 +316,9 @@ Key modules:
   `ToolbarSelect` wires `onOpenChange` to the editor `focus()`, which re-closes the dropdown the
   instant it opens inside the floating toolbar; the local version omits that wiring so the menu
   opens) with `NoteTitle` and
-  `NotePreview`, `AttachmentsDialog` (manage attachments — list/usage/sort/
+  `NotePreview` (read-only render via `@diplodoc/transform`, mirroring the editor's linkify +
+  fuzzy-off config; every link click routes through `openExternalUrl` instead of navigating the
+  surface), `AttachmentsDialog` (manage attachments — list/usage/sort/
   delete + full-size view; virtualized list), `Lightbox` (shared full-size image overlay with
   pinch/scroll zoom + drag-pan), the editor's custom image NodeView (`editor/attachmentImageView` +
   `attachmentImageExtension`: resize, caption, click-to-zoom, broken state), the `[[wiki link]]` editor
diff --git a/README.md b/README.md
index 72302c9..a4189df 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,11 @@ Markdown files, and they are yours.
   the storage menu (the `⋯` orb)
 - **Full-text search** across note titles _and_ bodies, ranked by relevance, with the matching
   passage shown as a snippet in the list (multi-word queries match all terms)
-- Gravity Markdown editor (WYSIWYG + markup modes) with a read-only **preview** mode
+- Gravity Markdown editor (WYSIWYG + markup modes) with a read-only **preview** mode (a floating
+  "Preview" chip shows while it's on — click it to exit)
+- **Live URLs**: bare `https://…` links render as real links in the editor and the preview (typing one
+  linkifies on the trailing space), and open in your browser via ⌘-click (or a plain click in
+  preview). Explicit schemes only — a stray `Notes.md` never turns into a link or gets rewritten
 - **`[[wiki links]]`** between notes: type `[[` for a note picker, or write them by hand. They render
   like links (no brackets) and ⌘-click follows them — creating the note if it doesn't exist yet;
   unresolved links are dimmed. Stored verbatim as `[[Title]]`, so they're Obsidian-compatible
@@ -48,7 +52,11 @@ Markdown files, and they are yours.
   accent color, and the text-column width — app-wide, per workspace, or per note (the `⋯` button or
   `⌘⇧I`). Per-note choices live in the folder's metadata, so they survive renames and moves
 - **Multiple workspaces**: open several note folders and switch with `⌃R` (or the orb menu's Open
-  Recent) — on the desktop, each workspace can have its own window
+  Recent) — on the desktop, each workspace can have its own window (`⌘-click` a recent, `⌘↵` in the
+  switcher — works on "Open Folder…" too)
+- **Per-note windows** (desktop): `⌘↵` or `⌘-click` a note in the list (or "Open in New Window" from
+  its menu) to open just that note in a small window with the panels tucked away — reopening the same
+  note focuses its existing window, and `⌘0` brings back the workspace's main window
 - **Automatic updates** (desktop app): the macOS app checks for a newer release on launch and installs
   it in place once you confirm — plus a manual **Check for Updates…** in the storage menu. Updates are
   delivered through GitHub Releases and verified by signature
@@ -65,6 +73,8 @@ Markdown files, and they are yours.
 | `⌘J` / `⌘K`               | Preview next / previous note (works while editing)                                                                                      |
 | `⌘[` / `⌘]`               | Go back / forward through visited notes (browser-style history)                                                                         |
 | `Enter`                   | Edit the selected note                                                                                                                  |
+| `⌘Enter` / `⌘-click`      | Open the selected note in its own window (desktop)                                                                                      |
+| `⌘0`                      | Show this workspace's main window (desktop; also in Window ▸ Main Window)                                                               |
 | `Esc`                     | Editor → list → search (then close / clear)                                                                                             |
 | `⌘L`                      | Jump to the search box (`⌘L` in the desktop app; browsers reserve it)                                                                   |
 | `⌘⇧Enter` / `⌘N`          | New note (`⌘N` in the desktop app; browsers reserve it)                                                                                 |
@@ -88,7 +98,9 @@ menu the row's `⋯` button opens, at the cursor.
 
 A **folder rail** (toggle with `⌘⇧\`) lists your folders left of the notes list; it's off by default,
 so the app stays a two-pane view until you want it. Selecting a folder scopes the notes list to it
-(**All Notes** shows everything), while search stays global. **New note** (`⌘N`) lands in the selected
+(**All Notes** shows everything), while search stays global. With the rail closed, a small **folder
+chip** above the list names the active scope (click it to open the rail, ✕ to go back to All Notes).
+**New note** (`⌘N`) lands in the selected
 folder. Drag a note onto a folder to file it, or drag a folder onto another to nest it (onto **All
 Notes** to move it back to the root). Double-click or `F2` renames a folder; with a folder focused, `n`
 makes a subfolder and `⌫` removes an empty one.
@@ -177,21 +189,14 @@ Key modules:
 
 ### Backlog
 
-Bugs (testing notes, 2026-07-05):
-
-- iCloud Drive: opening a folder whose files aren't downloaded yet hangs the app (probe/walk
-  blocks on download-on-demand materialization; needs async download handling or a clear error)
-- Plain URLs in note text aren't highlighted as links — not even in preview mode
-- Opening a note that begins with a `[[wiki link]]` sometimes pops the link tooltip immediately,
-  anchored top-left and stuck (likely a caret-lands-inside-link position race; sometimes fine)
-- Markup (CodeMirror) mode: the undo/redo stack appears shared across notes — undo after
-  switching can revert the previous note's edits (WYSIWYG resets history on swap; CM may not)
-
-UI wishes:
-
-- Indicate that read-only preview mode is active (some visible state, not just the frozen editor)
-- Indicate the selected folder scope when the folder rail is closed (the list silently stays
-  filtered)
+- Bare-URL highlighting while EDITING (preview linkifies since 2026-07-05). Blocked on a safe
+  config: the editor serializes linkified URLs to `<url>` on save, and markdown-it's FUZZY
+  linkify would rewrite bare-domain text — `.md` is a real TLD, so a `Notes.md` mention would
+  become `[Notes.md](http://notes.md)` on disk. Needs linkify with `fuzzyLink: false` reachable
+  through the editor's options (or an upstream RawLink parse), plus a round-trip test.
+- iCloud dataless files: previews/search stay empty until a file is downloaded (the walks now
+  skip evicted content instead of hanging). Consider `startDownloadingUbiquitousItemAtURL` to
+  kick off downloads in the background + an "downloading…" preview state.
 
 - Search index update on external file updates (+ reload workspace menu item?)
 - Density (line spacing) setting to complement the per-note font/width overrides?
diff --git a/package-lock.json b/package-lock.json
index 58ed78b..95d7d63 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,13 +1,15 @@
 {
   "name": "gravity-notes",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "gravity-notes",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "dependencies": {
+        "@codemirror/commands": "^6.10.3",
+        "@codemirror/state": "^6.6.0",
         "@diplodoc/color-extension": "^0.1.1",
         "@diplodoc/cut-extension": "^1.0.0",
         "@diplodoc/file-extension": "^0.2.1",
diff --git a/package.json b/package.json
index c73e0dc..fe5dbc8 100644
--- a/package.json
+++ b/package.json
@@ -23,6 +23,8 @@
     "tauri:build": "tauri build"
   },
   "dependencies": {
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/state": "^6.6.0",
     "@diplodoc/color-extension": "^0.1.1",
     "@diplodoc/cut-extension": "^1.0.0",
     "@diplodoc/file-extension": "^0.2.1",
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 168ad3d..7887785 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -161,6 +161,24 @@ fn modified_ms(meta: &fs::Metadata) -> f64 {
         .unwrap_or(0.0)
 }
 
+/// Whether a file's content is evicted to the cloud (macOS APFS "dataless" files — iCloud Drive's
+/// download-on-demand). READING such a file blocks until the system has downloaded it, so the bulk
+/// walks (list previews, the search corpus) must skip their content instead of stalling the whole
+/// app on a folder that isn't downloaded — its metadata (name, mtime) is always local. An explicit
+/// single-note open still reads (and thereby downloads) the file.
+#[cfg(target_os = "macos")]
+fn is_dataless(meta: &fs::Metadata) -> bool {
+    use std::os::macos::fs::MetadataExt;
+    // SF_DATALESS from <sys/stat.h> ("file is dataless object"); not exposed by libc consts.
+    const SF_DATALESS: u32 = 0x4000_0000;
+    meta.st_flags() & SF_DATALESS != 0
+}
+
+#[cfg(not(target_os = "macos"))]
+fn is_dataless(_meta: &fs::Metadata) -> bool {
+    false
+}
+
 /// Write bytes durably: write a sibling temp file, then atomically rename it over the
 /// target (same-filesystem rename is atomic on macOS), so a crash mid-write never
 /// truncates the original. Replaces the web backend's `createWritable()`/`close()`
@@ -246,7 +264,13 @@ fn collect_md(root: &Path, current: &Path, full: bool, out: &mut Vec<Found>) ->
                 .unwrap_or(&path)
                 .to_string_lossy()
                 .replace('\\', "/");
-            let body = if full {
+            // A not-yet-downloaded iCloud file: list it by name/mtime but DON'T read its content —
+            // that would block until the system downloads it, turning a walk over a non-downloaded
+            // folder into a hang. Its preview/corpus body stays empty until it lands on disk
+            // (the focus-driven refresh picks it up); explicitly opening the note still reads it.
+            let body = if is_dataless(&meta) {
+                String::new()
+            } else if full {
                 String::from_utf8_lossy(&fs::read(&path)?).into_owned()
             } else {
                 let mut buf = Vec::new();
@@ -725,6 +749,10 @@ static NEXT_WS_WINDOW: AtomicU32 = AtomicU32::new(1);
 /// Monotonic suffix for `note-N` window labels (same one-run lifetime story as `NEXT_WS_WINDOW`).
 static NEXT_NOTE_WINDOW: AtomicU32 = AtomicU32::new(1);
 
+/// Single-note window size (logical px) — a single column of prose, not a three-pane workspace.
+const NOTE_WINDOW_WIDTH: f64 = 760.0;
+const NOTE_WINDOW_HEIGHT: f64 = 640.0;
+
 /// Label prefix of single-note windows. Mirrors `NOTE_WINDOW_PREFIX` in `src/isTauri.ts` — keep
 /// them in sync. A note window carries a workspace assignment in `labels` like any window (its
 /// page bootstraps through the same `window_workspace` ask), but workspace-level focus-if-open
@@ -913,13 +941,14 @@ fn set_window_note(
 #[tauri::command]
 async fn open_note_window(
     app: tauri::AppHandle,
+    window: tauri::WebviewWindow,
     state: tauri::State<'_, WindowWorkspaces>,
     ws_id: String,
     note_id: String,
     title: String,
 ) -> Result<bool, String> {
     let pending_key = note_pending_key(&ws_id, &note_id);
-    let label = {
+    let (label, cascade_step) = {
         let mut st = state.0.lock().unwrap();
         // This exact note's window is already being built — don't spawn a second (mirrors the
         // workspace path's pending guard).
@@ -950,24 +979,35 @@ async fn open_note_window(
             st.labels.remove(&found);
             st.notes.remove(&found);
         }
-        let label = format!(
-            "{NOTE_WINDOW_PREFIX}{}",
-            NEXT_NOTE_WINDOW.fetch_add(1, Ordering::SeqCst)
-        );
+        let n = NEXT_NOTE_WINDOW.fetch_add(1, Ordering::SeqCst);
+        let label = format!("{NOTE_WINDOW_PREFIX}{n}");
         // Assign workspace AND note before the window exists (the page's first asks can't race),
         // and mark the build pending — same discipline as `open_workspace_window`.
         st.labels.insert(label.clone(), ws_id.clone());
         st.notes.insert(label.clone(), note_id.clone());
         st.pending.insert(pending_key.clone());
-        label
+        (label, n)
     };
     // Clone the main window's config like workspace windows do, sized down: this window shows a
     // single note (both side panels closed), not a whole three-pane workspace.
     let mut config = app.config().app.windows[0].clone();
     config.label = label.clone();
     config.title = title;
-    config.width = 760.0;
-    config.height = 640.0;
+    config.width = NOTE_WINDOW_WIDTH;
+    config.height = NOTE_WINDOW_HEIGHT;
+    // Position: centered-ish on the opener's monitor (a third down, like a system dialog),
+    // cascading down-right per note window so consecutive opens don't stack exactly. Anchored to
+    // the SCREEN, not the opener: gluing the new window onto the opener's corner buried the main
+    // window under a nearly-aligned copy of the same note — which reads as a "doubled" editor.
+    // Wraps after 8 steps; without monitor info the window just centers (from_config default).
+    if let Ok(Some(monitor)) = window.current_monitor() {
+        let scale = monitor.scale_factor();
+        let mpos: tauri::LogicalPosition<f64> = monitor.position().to_logical(scale);
+        let msize: tauri::LogicalSize<f64> = monitor.size().to_logical(scale);
+        let step = f64::from((cascade_step - 1) % 8) * 28.0;
+        config.x = Some(mpos.x + ((msize.width - NOTE_WINDOW_WIDTH).max(0.0) / 2.0) + step);
+        config.y = Some(mpos.y + ((msize.height - NOTE_WINDOW_HEIGHT).max(0.0) / 3.0) + step);
+    }
     let built = tauri::WebviewWindowBuilder::from_config(&app, &config)
         .and_then(|builder| builder.build());
     {
diff --git a/src/App.tsx b/src/App.tsx
index 5549782..407ee74 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -90,6 +90,7 @@ export function App() {
                                 onRemoveWorkspace={storage.removeWorkspace}
                                 onRefreshWorkspaces={storage.refreshWorkspaces}
                                 onOpenFolder={() => void storage.pickFolder()}
+                                onOpenFolderInNewWindow={storage.pickFolderForNewWindow}
                                 supportsFolders={storage.supportsFolders}
                             />
                         ) : (
diff --git a/src/components/EditorPane.css b/src/components/EditorPane.css
index be8a62b..19d391a 100644
--- a/src/components/EditorPane.css
+++ b/src/components/EditorPane.css
@@ -155,6 +155,13 @@
     min-height: 0;
     overflow-y: auto;
     overscroll-behavior: contain; /* keep scroll momentum inside the editor (no chaining to the shell) */
+    /* Own compositing layer. WKWebView occasionally leaves a STALE PAINT of a single line behind
+       after a content swap / pane resize — a ghost copy of the caret line, offset a few px, that
+       reads as "doubled/blurred text" (2026-07-05 report, sidebar open). A promoted layer makes
+       WebKit invalidate the pane wholesale instead of per-tile. The transform's containing-block
+       side effect is safe here: nothing inside uses position:fixed (the Lightbox portals to
+       <body>), and the floating editor popups portal out too. */
+    transform: translateZ(0);
 }
 
 .editor-pane__body {
diff --git a/src/components/EditorPane.tsx b/src/components/EditorPane.tsx
index d92fde6..fa393a6 100644
--- a/src/components/EditorPane.tsx
+++ b/src/components/EditorPane.tsx
@@ -1,5 +1,6 @@
 import {forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState} from 'react';
 
+import type {EditorState as CmEditorState} from '@codemirror/state';
 import {
     MarkdownEditorView,
     useMarkdownEditor,
@@ -17,6 +18,8 @@ import {NoteTitle, type NoteTitleHandle} from './NoteTitle';
 import {WikiLinkSuggest} from './editor/WikiLinkSuggest';
 import {WikiLinkTooltip} from './editor/WikiLinkTooltip';
 import {attachmentImageExtension} from './editor/attachmentImageExtension';
+import {linkifyTypedUrls} from './editor/linkifyTypedUrls';
+import {freshMarkupState, markupEditorOf} from './editor/markupHistory';
 import {openLinkExtension} from './editor/openLinkExtension';
 import {fixedSelectionContext} from './editor/selectionContextFix';
 import {
@@ -242,10 +245,31 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
     const wikiViewRef = useRef<EditorView | null>(null);
     const [wikiSuggest, setWikiSuggest] = useState<WikiLinkSuggestState | null>(null);
     const [wikiTooltip, setWikiTooltip] = useState<WikiLinkTooltipState | null>(null);
+    // True while a note-switch content swap is in flight (replace + history reset), so the change
+    // handler treats the load echo (and any echo from the state reset) as a load, not a user edit —
+    // and the wiki popups neither open from the swap's transactions nor stay pinned to elements the
+    // swap's redraw detached. Declared before the editor so its extensions can close over it.
+    // Starts TRUE: the mount itself is a "swap" for popup purposes — the plugin views' initial
+    // push runs while the fresh view's layout is still settling, so a doc that starts with a
+    // [[link]] popped the tooltip at a wrong anchor in every new window. Cleared in the effect
+    // below (child effects — where the editor view mounts — run first, so the init push is gated).
+    const swappingRef = useRef(true);
+    useEffect(() => {
+        swappingRef.current = false;
+        return () => {
+            // Refs persist across a StrictMode unmount→remount; re-arm so the remounted editor
+            // view's init push is gated exactly like the first one.
+            swappingRef.current = true;
+        };
+    }, []);
 
     const editor = useMarkdownEditor(
         {
-            md: {html: false},
+            // linkify renders bare URLs as real links in WYSIWYG. Round-trip cost (accepted, like
+            // preserveEmptyRows below): a bare URL re-serializes as the `<url>` autolink on the
+            // next save — one-time, then stable. Fuzzy matching is disabled in configureMd below;
+            // WITHOUT that this option would be unshippable (see the comment there).
+            md: {html: false, linkify: true},
             initial: {markup: note.content, mode: 'wysiwyg'},
             // Keep intentionally-blank lines through the WYSIWYG round-trip. Without this the
             // serializer drops empty paragraphs (Markdown can't represent a bare blank line), so
@@ -274,9 +298,19 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
                 // Resolve Attachments/ image srcs to displayable object URLs (keeps Markdown clean),
                 // and let ⌘/Ctrl-click on a link open it instead of opening the link-edit tooltip.
                 extensions: (builder) => {
+                    // Linkify (enabled via `md.linkify` above) must NOT fuzzy-match bare domains:
+                    // parsed links re-serialize on save, and `.md` is a real TLD (Moldova), so a
+                    // plain mention of `Notes.md` would be REWRITTEN on disk to
+                    // `[Notes.md](http://notes.md)`. With fuzzy off only explicit schemes
+                    // (https://…, mailto:…) match — same config as the preview (NotePreview.tsx).
+                    builder.configureMd((md) => {
+                        md.linkify.set({fuzzyLink: false, fuzzyEmail: false});
+                        return md;
+                    });
                     fixedSelectionContext(builder, {config: SELECTION_MENU_CONFIG});
                     attachmentImageExtension(builder);
                     openLinkExtension(builder);
+                    linkifyTypedUrls(builder);
                     wikiLinkExtension(builder, {
                         getNotes: () => wikiNotesRef.current,
                         getCurrentId: () => noteIdRef.current,
@@ -284,6 +318,7 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
                         viewRef: wikiViewRef,
                         onSuggest: setWikiSuggest,
                         onTooltip: setWikiTooltip,
+                        isSwapping: () => swappingRef.current,
                     });
                 },
             },
@@ -292,13 +327,21 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
     );
 
     const previewRef = useRef<HTMLDivElement>(null);
+    // The markup (CodeMirror) editor's PRISTINE state — captured at mount, when the lazy markup
+    // editor is first instantiated and its undo history is still empty. Every note switch rebuilds
+    // the markup state from this template (fresh doc, same extensions, NO history), because the one
+    // CodeMirror instance otherwise lives across notes and ⌘Z in markup mode could walk back into
+    // the previous note's content. See editor/markupHistory.ts for the full story.
+    const cmTemplateRef = useRef<CmEditorState | null>(null);
+    useEffect(() => {
+        if (!cmTemplateRef.current) {
+            cmTemplateRef.current = markupEditorOf(editor)?.cm.state ?? null;
+        }
+    }, [editor]);
     // The editor emits a no-op 'change' as the initial markup loads; suppress only that FIRST emit,
     // not every value that equals the original — otherwise undoing back to the loaded content within
     // the autosave window leaves a stale pending edit that writes the pre-undo value to disk.
     const settledRef = useRef(false);
-    // True while a note-switch content swap is in flight (replace + history reset), so the change
-    // handler treats the load echo (and any echo from the state reset) as a load, not a user edit.
-    const swappingRef = useRef(false);
 
     useImperativeHandle(
         ref,
@@ -408,6 +451,7 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
         try {
             if (contentChanged) editor.replace(note.content);
             resetHistory(); // fresh undo stack; also resets the selection to doc start
+            resetMarkupHistory(); // the markup (CodeMirror) twin — its history survives replace()
             // Restore the saved caret only on a REAL switch — on a same-note disk reload the saved
             // caret came from the pre-reload doc, so replaying it lands at a meaningless offset in the
             // new content; leave the doc-start `resetHistory()` produced instead.
@@ -460,6 +504,20 @@ const EditorBody = forwardRef<EditorBodyHandle, EditorBodyProps>(function Editor
         view.updateState(EditorState.create({doc: view.state.doc, plugins: view.state.plugins}));
     }
 
+    /**
+     * The markup-mode twin of {@link resetHistory}: give the (single, reused) CodeMirror instance a
+     * fresh state holding this note's content with an EMPTY undo history, built on the pristine
+     * template captured at mount. Runs on every swap regardless of the current mode — it also keeps
+     * the hidden markup buffer in sync, so entering markup mode later doesn't diff against a stale
+     * doc. No-op when the markup editor isn't reachable (template capture failed).
+     */
+    function resetMarkupHistory() {
+        const markup = markupEditorOf(editor);
+        const template = cmTemplateRef.current;
+        if (!markup || !template) return;
+        markup.cm.setState(freshMarkupState(template, note.content));
+    }
+
     /** Restore a note's saved caret, clamped to the freshly-loaded doc (no-op for a first open). */
     function restoreSelection(id: string) {
         const view = wikiViewRef.current;
diff --git a/src/components/FolderGate.test.tsx b/src/components/FolderGate.test.tsx
index 7aa4d1d..ab04299 100644
--- a/src/components/FolderGate.test.tsx
+++ b/src/components/FolderGate.test.tsx
@@ -24,6 +24,7 @@ function makeStorage(over: Partial<NotesStorage> = {}): NotesStorage {
         // Default to consistency with the other flags unless a test overrides it explicitly.
         supportsFolders: over.supportsFolders ?? (isTauri || supportsFileSystem),
         pickFolder: vi.fn(async () => {}),
+        pickFolderForNewWindow: vi.fn(async () => {}),
         useBrowserStorage: vi.fn(async () => {}),
         grantPermission: vi.fn(async () => {}),
         reset: vi.fn(async () => {}),
diff --git a/src/components/NoteList.css b/src/components/NoteList.css
index 54fc6cd..c3d4ab1 100644
--- a/src/components/NoteList.css
+++ b/src/components/NoteList.css
@@ -23,6 +23,18 @@
     min-width: 0;
 }
 
+/* The folder-scope chip row (rail closed + a folder selected — see the render-site comment). */
+.note-list__scope {
+    display: flex;
+    padding: 6px 12px;
+    border-bottom: 1px solid var(--g-color-line-generic);
+    flex-shrink: 0;
+}
+
+.note-list__scope-chip {
+    max-width: 100%;
+}
+
 .note-list__items {
     flex: 1;
     overflow-y: auto;
diff --git a/src/components/NoteList.test.tsx b/src/components/NoteList.test.tsx
index 09397ce..a8f8568 100644
--- a/src/components/NoteList.test.tsx
+++ b/src/components/NoteList.test.tsx
@@ -558,6 +558,41 @@ describe('NoteList — open in new window (desktop)', () => {
     });
 });
 
+describe('NoteList — folder scope chip (rail closed)', () => {
+    const scoped = {scopeLabel: 'Work', railOpen: false, onClearScope: vi.fn()};
+
+    it('names the invisible folder scope and clears it via ×', async () => {
+        const user = userEvent.setup();
+        const onClearScope = vi.fn();
+        setup({...scoped, onClearScope});
+        expect(screen.getByText('Work')).toBeInTheDocument();
+        await user.click(screen.getByRole('button', {name: 'Show all notes'}));
+        expect(onClearScope).toHaveBeenCalledTimes(1);
+    });
+
+    it('clicking the chip opens the folder rail', async () => {
+        const user = userEvent.setup();
+        const {props} = setup({...scoped});
+        await user.click(screen.getByText('Work'));
+        expect(props.onToggleRail).toHaveBeenCalledTimes(1);
+    });
+
+    it('hides the chip when the rail already shows the scope', () => {
+        setup({...scoped, railOpen: true});
+        expect(screen.queryByText('Work')).not.toBeInTheDocument();
+    });
+
+    it('hides the chip while a search is live (the list is global then)', () => {
+        setup({...scoped, query: 'find me'});
+        expect(screen.queryByText('Work')).not.toBeInTheDocument();
+    });
+
+    it('renders no chip at All Notes (no scope)', () => {
+        setup({...scoped, scopeLabel: null});
+        expect(screen.queryByText('Work')).not.toBeInTheDocument();
+    });
+});
+
 describe('NoteList — right-click context menu', () => {
     it('opens the row action menu on right-click and runs an action', async () => {
         const user = userEvent.setup();
diff --git a/src/components/NoteList.tsx b/src/components/NoteList.tsx
index 9e36435..e239e62 100644
--- a/src/components/NoteList.tsx
+++ b/src/components/NoteList.tsx
@@ -29,7 +29,16 @@ import {
     Plus,
     TrashBin,
 } from '@gravity-ui/icons';
-import {Button, Dialog, DropdownMenu, Icon, Select, Text, TextInput} from '@gravity-ui/uikit';
+import {
+    Button,
+    Dialog,
+    DropdownMenu,
+    Icon,
+    Label,
+    Select,
+    Text,
+    TextInput,
+} from '@gravity-ui/uikit';
 import {defaultRangeExtractor, useVirtualizer} from '@tanstack/react-virtual';
 
 import {useHeldValue} from '../hooks/useHeldValue';
@@ -115,6 +124,11 @@ export interface NoteListProps {
     railOpen: boolean;
     /** Show / hide the folder rail. */
     onToggleRail: () => void;
+    /**
+     * Back to All Notes (clear the folder scope). Drives the scope chip shown when a folder is
+     * selected while the rail is CLOSED — the only state where the scoping is otherwise invisible.
+     */
+    onClearScope?: () => void;
     /** Move focus into the folder rail (← on a row, when the rail is open). */
     onFocusRail: () => void;
 }
@@ -397,6 +411,7 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
         showIcons,
         railOpen,
         onToggleRail,
+        onClearScope,
         onFocusRail,
     },
     ref,
@@ -847,6 +862,27 @@ export const NoteList = forwardRef<NoteListHandle, NoteListProps>(function NoteL
                 </Button>
             </div>
 
+            {/* Scope chip: with the rail closed, a selected folder silently filters the list — name
+                the scope, click-through to the folder tree, × back to All Notes. Hidden while a
+                search is live (the list is global then) and whenever the rail already shows it. */}
+            {!railOpen && scopeLabel && !query.trim() && onClearScope ? (
+                <div className="note-list__scope">
+                    <Label
+                        className="note-list__scope-chip"
+                        size="xs"
+                        type="close"
+                        icon={<Icon data={Folder} size={12} />}
+                        interactive
+                        onClick={onToggleRail}
+                        onCloseClick={onClearScope}
+                        closeButtonLabel="Show all notes"
+                        title={`Showing “${scopeLabel}” — click to open folders`}
+                    >
+                        {scopeLabel}
+                    </Label>
+                </div>
+            ) : null}
+
             <div
                 ref={scrollRef}
                 className="note-list__items virtual-scroll"
diff --git a/src/components/NotePreview.test.tsx b/src/components/NotePreview.test.tsx
index ccc1cda..74557a2 100644
--- a/src/components/NotePreview.test.tsx
+++ b/src/components/NotePreview.test.tsx
@@ -1,7 +1,8 @@
 import transform from '@diplodoc/transform';
-import {screen} from '@testing-library/react';
+import {fireEvent, screen} from '@testing-library/react';
 import {describe, expect, it, vi} from 'vitest';
 
+import {openExternalUrl} from '../openExternal';
 import {renderWithProviders} from '../test/render';
 
 import {NotePreview, withWikiLinks} from './NotePreview';
@@ -10,6 +11,8 @@ import {NotePreview, withWikiLinks} from './NotePreview';
 // transform or force a throw; the module is otherwise driven by the real impl.
 // (vi.mock is hoisted above the imports above by Vitest.)
 vi.mock('@diplodoc/transform', () => ({default: vi.fn()}));
+// Link clicks must route through the external opener (never navigate the page).
+vi.mock('../openExternal', () => ({openExternalUrl: vi.fn()}));
 
 const transformMock = vi.mocked(transform);
 
@@ -82,6 +85,48 @@ describe('NotePreview', () => {
         expect(container.querySelector('.note-preview__body')).toBeNull();
         expect(screen.getByText(/Couldn.t render/)).toBeInTheDocument();
     });
+
+    it('linkifies bare URLs with an explicit scheme', async () => {
+        transformMock.mockImplementation(await realTransform());
+
+        const {container} = renderWithProviders(
+            <NotePreview markup="see https://example.com/docs for more" />,
+        );
+
+        const link = requireBody(container).querySelector('a[href="https://example.com/docs"]');
+        expect(link).not.toBeNull();
+        expect(link?.textContent).toBe('https://example.com/docs');
+    });
+
+    it('never fuzzy-links bare domains (a `Notes.md` mention is text, not a link)', async () => {
+        transformMock.mockImplementation(await realTransform());
+
+        const {container} = renderWithProviders(
+            <NotePreview markup="rename Notes.md and mail me@example.com about clck.ru/M9iCj" />,
+        );
+
+        const body = requireBody(container);
+        // .md and .ru are real TLDs — with fuzzy matching all three would become links (and the
+        // editor's identical linkify would then rewrite them on disk).
+        expect(body.querySelector('a')).toBeNull();
+        expect(body.textContent).toContain('Notes.md');
+    });
+
+    it('routes link clicks through the external opener instead of navigating', async () => {
+        transformMock.mockImplementation(await realTransform());
+
+        const {container} = renderWithProviders(
+            <NotePreview markup="[docs](https://example.com/docs)" />,
+        );
+
+        const link = requireBody(container).querySelector('a[href="https://example.com/docs"]');
+        expect(link).not.toBeNull();
+        const click = fireEvent.click(link as HTMLAnchorElement);
+        // preventDefault fired (fireEvent returns false) — the surface never navigates…
+        expect(click).toBe(false);
+        // …and the URL went to the shared opener (OS browser on desktop, new tab on web).
+        expect(vi.mocked(openExternalUrl)).toHaveBeenCalledWith('https://example.com/docs');
+    });
 });
 
 describe('withWikiLinks', () => {
diff --git a/src/components/NotePreview.tsx b/src/components/NotePreview.tsx
index ee2ea1e..1272806 100644
--- a/src/components/NotePreview.tsx
+++ b/src/components/NotePreview.tsx
@@ -11,6 +11,7 @@ import transform from '@diplodoc/transform';
 import {Text} from '@gravity-ui/uikit';
 
 import {type AttachmentUrlCache, useAttachmentCache} from '../attachments';
+import {openExternalUrl} from '../openExternal';
 import {attachmentRefsIn, isAttachmentRef} from '../storage/noteText';
 
 // Local preview styles + the cut runtime stylesheet (which styles `.yfm-cut`).
@@ -46,13 +47,25 @@ type PluginFactory = (options?: unknown) => unknown;
 const colorPlugin = resolveCjsExport(colorExtension, 'colorPlugin');
 const cutTransform = resolveCjsExport(cutExtension, 'transform') as PluginFactory;
 
+/**
+ * markdown-it plugin: keep linkify to EXPLICIT schemes only (https://…, mailto:…). Fuzzy matching
+ * would render bare domains as links — and `.md` is a real TLD, so every `Notes.md` mention would
+ * look like a link here (and, worse, the editor's identical linkify would REWRITE it on save).
+ * Must mirror the editor's configureMd in EditorPane.tsx so the two surfaces agree.
+ */
+function noFuzzyLinkify(md: {linkify: {set(opts: Record<string, boolean>): unknown}}): void {
+    md.linkify.set({fuzzyLink: false, fuzzyEmail: false});
+}
+
 const TRANSFORM_OPTIONS = {
     // `bundle: false` is load-bearing: the cut factory otherwise defaults to bundling its runtime
     // assets to disk via Node `fs`, which throws in the browser (fs is externalized) and fails the
     // whole transform. We ship the runtime ourselves (the side-effect import above), so no bundling.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- markdown-it plugins vs diplodoc's ExtendedPluginWithCollect type
-    plugins: [colorPlugin, cutTransform({bundle: false})].filter(Boolean) as any[],
+    plugins: [colorPlugin, cutTransform({bundle: false}), noFuzzyLinkify].filter(Boolean) as any[],
     disableCommonAnchors: true,
+    // Render bare URLs as links (explicit schemes only — see noFuzzyLinkify), matching the editor.
+    linkify: true,
 };
 
 interface NotePreviewProps {
@@ -60,6 +73,21 @@ interface NotePreviewProps {
     markup: string;
 }
 
+/**
+ * Route a click on any rendered `<a href>` through {@link openExternalUrl} (the OS browser on
+ * desktop, a new tab on the web) instead of letting the surface navigate. Without this, a link
+ * click walks the WHOLE APP away from itself in the web build, and goes nowhere useful in
+ * WKWebView. Non-openable hrefs (relative paths, footnote `#` anchors, disallowed schemes) are
+ * swallowed — preview never navigates. Delegated from the container so it covers every link the
+ * HTML re-renders produce.
+ */
+function handlePreviewClick(event: React.MouseEvent<HTMLDivElement>): void {
+    const target = event.target instanceof Element ? event.target.closest('a[href]') : null;
+    if (!(target instanceof HTMLAnchorElement)) return;
+    event.preventDefault();
+    openExternalUrl(target.href);
+}
+
 /**
  * Rewrite every attachment `<img src>` in the rendered HTML to its resolved `blob:` object URL.
  * `@diplodoc/transform` leaves image srcs verbatim (its `images` plugin isn't in the default set),
@@ -194,7 +222,8 @@ export const NotePreview = forwardRef<HTMLDivElement, NotePreviewProps>(function
     }, [markup, cache]);
 
     return (
-        <div ref={ref} className="note-preview" tabIndex={-1}>
+        // eslint-disable-next-line jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events -- delegated link-open only; the links inside are the interactive elements and stay keyboard-activatable natively
+        <div ref={ref} className="note-preview" tabIndex={-1} onClick={handlePreviewClick}>
             {rendered.error ? (
                 // Surface a transform failure instead of a silent blank pane; the editor body keeps
                 // the actual content, so the user can switch back and keep working.
diff --git a/src/components/TopBar.tsx b/src/components/TopBar.tsx
index 6132f53..3dca5ba 100644
--- a/src/components/TopBar.tsx
+++ b/src/components/TopBar.tsx
@@ -52,6 +52,8 @@ export interface TopBarProps {
     onOpenWorkspaceInNewWindow: (id: string) => void;
     /** Open the folder picker (adds/opens a workspace in this window). */
     onOpenFolder: () => void;
+    /** Desktop only: pick a folder and open it as its own window (⌘-click on "Open Folder…"). */
+    onOpenFolderInNewWindow?: () => void;
     /** Open the ⌃R workspace switcher dialog. */
     onOpenSwitcher: () => void;
     /** The orb menu just opened — a chance to refresh the recents it shows. */
@@ -143,6 +145,7 @@ export function TopBar({
     onOpenWorkspace,
     onOpenWorkspaceInNewWindow,
     onOpenFolder,
+    onOpenFolderInNewWindow,
     onOpenSwitcher,
     onMenuOpen,
     onExport,
@@ -387,7 +390,15 @@ export function TopBar({
                       {
                           text: 'Open Folder…',
                           iconStart: <Icon data={FolderOpen} />,
-                          action: onOpenFolder,
+                          // ⌘-click / ⌘↵ (desktop) opens the picked folder in its OWN window —
+                          // the same modifier convention as the recents above.
+                          action: (event: ReactMouseEvent<HTMLElement> | KeyboardEvent) => {
+                              if (isDesktop && event.metaKey && onOpenFolderInNewWindow) {
+                                  onOpenFolderInNewWindow();
+                              } else {
+                                  onOpenFolder();
+                              }
+                          },
                       },
                   ]
                 : []),
diff --git a/src/components/Workspace.css b/src/components/Workspace.css
index 928f765..d05df8c 100644
--- a/src/components/Workspace.css
+++ b/src/components/Workspace.css
@@ -42,10 +42,33 @@
 }
 
 .workspace__panes {
+    position: relative; /* anchors the floating preview badge */
     flex: 1;
     min-height: 0;
 }
 
+/* Read-only-preview state chip, floated over the editor pane's top-right corner (the pane itself
+   scrolls, so the badge anchors to this non-scrolling wrapper and stays put). The label swaps to
+   the ACTION ("Exit preview") on hover — it grows under the cursor, so no hover flicker. */
+.workspace__preview-badge {
+    position: absolute;
+    top: 10px;
+    right: 18px;
+    z-index: 3;
+}
+
+.workspace__preview-badge .workspace__preview-badge-hover {
+    display: none;
+}
+
+.workspace__preview-badge:hover .workspace__preview-badge-idle {
+    display: none;
+}
+
+.workspace__preview-badge:hover .workspace__preview-badge-hover {
+    display: inline;
+}
+
 .editor-pane {
     height: 100%;
 }
diff --git a/src/components/Workspace.test.tsx b/src/components/Workspace.test.tsx
index 65eb29d..d8dd1e3 100644
--- a/src/components/Workspace.test.tsx
+++ b/src/components/Workspace.test.tsx
@@ -45,6 +45,7 @@ function workspaceProps() {
         onRemoveWorkspace: vi.fn(async () => {}),
         onRefreshWorkspaces: vi.fn(async () => {}),
         onOpenFolder: vi.fn(),
+        onOpenFolderInNewWindow: vi.fn(async () => {}),
         supportsFolders: true,
     };
 }
@@ -503,6 +504,46 @@ describe('Workspace — nvALT navigation', () => {
         await waitFor(() => expect(document.querySelector('.workspace__body_peeked')).toBeNull());
     });
 
+    it('typing a search auto-peeks the collapsed sidebar without stealing focus', async () => {
+        const user = userEvent.setup();
+        renderWorkspace();
+        await screen.findByRole('option', {name: /Alpha/});
+        await toggleSidebarViaMenu(user);
+        await waitFor(() =>
+            expect(document.querySelector('.workspace__body_collapsed')).not.toBeNull(),
+        );
+        // Type into the search box: results must become visible (peek opens)…
+        const search = screen.getByRole('textbox', {name: 'Search or create a note'});
+        search.focus();
+        fireEvent.change(search, {target: {value: 'Alp'}});
+        await waitFor(() =>
+            expect(document.querySelector('.workspace__body_peeked')).not.toBeNull(),
+        );
+        // …while focus STAYS in the box (unlike the deliberate ⌘' peek, which enters the list).
+        expect(document.activeElement).toBe(search);
+        // Clearing the query tucks the peek back away.
+        fireEvent.change(search, {target: {value: ''}});
+        await waitFor(() => expect(document.querySelector('.workspace__body_peeked')).toBeNull());
+    });
+
+    it('Enter on a search match while auto-peeked opens the note and closes the peek', async () => {
+        const user = userEvent.setup();
+        renderWorkspace();
+        await screen.findByRole('option', {name: /Alpha/});
+        await toggleSidebarViaMenu(user);
+        await waitFor(() =>
+            expect(document.querySelector('.workspace__body_collapsed')).not.toBeNull(),
+        );
+        const search = screen.getByRole('textbox', {name: 'Search or create a note'});
+        search.focus();
+        fireEvent.change(search, {target: {value: 'Alpha'}});
+        await waitFor(() =>
+            expect(document.querySelector('.workspace__body_peeked')).not.toBeNull(),
+        );
+        fireEvent.keyDown(search, {key: 'Enter'});
+        await waitFor(() => expect(document.querySelector('.workspace__body_peeked')).toBeNull());
+    });
+
     it('docking with ⌘\\ clears the peek', async () => {
         const user = userEvent.setup();
         renderWorkspace();
diff --git a/src/components/Workspace.tsx b/src/components/Workspace.tsx
index bf85c25..5e599ac 100644
--- a/src/components/Workspace.tsx
+++ b/src/components/Workspace.tsx
@@ -1,6 +1,7 @@
 import {useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState} from 'react';
 
-import {Text, useToaster} from '@gravity-ui/uikit';
+import {Eye} from '@gravity-ui/icons';
+import {Icon, Label, Text, useToaster} from '@gravity-ui/uikit';
 
 import {AttachmentUrlCache, AttachmentsContext} from '../attachments';
 import {useAppUpdater} from '../hooks/useAppUpdater';
@@ -75,6 +76,8 @@ interface WorkspaceProps {
     onRefreshWorkspaces: () => Promise<void>;
     /** Open the folder picker (adds/opens a workspace in this window). */
     onOpenFolder: () => void;
+    /** Desktop only: pick a folder and open it as its own window (this window stays put). */
+    onOpenFolderInNewWindow: () => Promise<void>;
     /** Whether folder-on-disk workspaces are available (native app, or FSA in the browser). */
     supportsFolders: boolean;
 }
@@ -158,6 +161,7 @@ export function Workspace({
     onRemoveWorkspace,
     onRefreshWorkspaces,
     onOpenFolder,
+    onOpenFolderInNewWindow,
     supportsFolders,
 }: WorkspaceProps) {
     const {add} = useToaster();
@@ -561,10 +565,38 @@ export function Workspace({
     useEffect(() => {
         if (!collapsed && peeked) setPeeked(false);
     }, [collapsed, peeked]);
-    // When the peek opens, move focus into the list so arrow / ⌘J⌘K nav works immediately.
+    // True while the peek being opened is the automatic search peek below — it must NOT move
+    // focus into the list (the user is mid-typing in the search box).
+    const autoPeekRef = useRef(false);
+    // When the peek opens, move focus into the list so arrow / ⌘J⌘K nav works immediately —
+    // except for an auto-peek (see above), which leaves focus in the search box.
     useEffect(() => {
-        if (peeked) listRef.current?.focusSelected();
+        if (!peeked) return;
+        if (autoPeekRef.current) {
+            autoPeekRef.current = false;
+            return;
+        }
+        listRef.current?.focusSelected();
     }, [peeked]);
+    // Auto-peek while searching with the sidebar collapsed: the results would otherwise render
+    // into a hidden list, so typing looked like it did nothing. Opens on a query appearing (or
+    // resuming — each keystroke re-opens a dismissed peek, since typing means "show me matches"),
+    // closes when the query clears. Keyed on QUERY TRANSITIONS only: re-runs caused by
+    // peeked/collapsed flips compare equal and bail, so dismissing the overlay (outside click,
+    // committing a note) isn't instantly undone.
+    const prevSearchRef = useRef(query);
+    useEffect(() => {
+        const prev = prevSearchRef.current;
+        prevSearchRef.current = query;
+        if (query === prev || !collapsed) return;
+        const has = query.trim().length > 0;
+        if (has && !peeked) {
+            autoPeekRef.current = true;
+            setPeeked(true);
+        } else if (!has && prev.trim().length > 0 && peeked) {
+            setPeeked(false);
+        }
+    }, [query, collapsed, peeked]);
     // While peeked, a pointerdown anywhere outside the sidebar closes it (e.g. clicking the editor).
     // pointerdown (not mousedown) so touch/pen also dismiss the overlay.
     useEffect(() => {
@@ -797,6 +829,14 @@ export function Workspace({
         })();
     }, [confirmLeaveSafe, onOpenFolder]);
 
+    // ⌘↵ / ⌘-click on "Open Folder…": the picked folder opens in its OWN window, so this one
+    // stays put — no flush guard needed (nothing here is left).
+    const handleOpenFolderInNewWindow = useCallback(() => {
+        onOpenFolderInNewWindow().catch((err) =>
+            onError(err instanceof Error ? err.message : 'Could not open the folder'),
+        );
+    }, [onOpenFolderInNewWindow, onError]);
+
     // The ⌃R switcher. Refresh the registry BEFORE opening, so recents written by other windows are
     // already in the list when the dialog seeds its pre-highlight — otherwise a late refresh could
     // reorder the rows under a highlight the user already saw (opening the wrong workspace on ↵).
@@ -1175,6 +1215,8 @@ export function Workspace({
                     onOpenWorkspace={handleOpenWorkspace}
                     onOpenWorkspaceInNewWindow={handleOpenWorkspaceInNewWindow}
                     onOpenFolder={handleOpenFolder}
+                    // TopBar fires this only on desktop ⌘-click (and the hook no-ops on web).
+                    onOpenFolderInNewWindow={handleOpenFolderInNewWindow}
                     onOpenSwitcher={openSwitcher}
                     onMenuOpen={() => void onRefreshWorkspaces()}
                     onExport={handleExport}
@@ -1213,7 +1255,12 @@ export function Workspace({
                     // the debounce; flag that gap so the keyboard model doesn't act on a stale list.
                     searchPending={query !== debouncedQuery}
                     selectedId={nav.selectedId}
-                    onCommit={nav.commit}
+                    onCommit={(id) => {
+                        // Enter on a search match: tuck the (auto-)peeked sidebar back away —
+                        // focus moves to the editor, and the overlay has served its purpose.
+                        nav.commit(id);
+                        setPeeked(false);
+                    }}
                     onCreate={(title) => handleCreate(title, '')}
                     onClose={nav.closeFromSearch}
                     onEnterList={enterList}
@@ -1290,6 +1337,9 @@ export function Workspace({
                             showIcons={settings.showNoteIcons}
                             railOpen={railOpen}
                             onToggleRail={toggleRail}
+                            // Straight setSelectedFolder — unlike rail selection this must NOT
+                            // preview the first note (clearing a filter shouldn't switch notes).
+                            onClearScope={() => setSelectedFolder(null)}
                             onFocusRail={() => railRef.current?.focusSelected()}
                         />
                     </aside>
@@ -1316,6 +1366,28 @@ export function Workspace({
                                     </div>
                                 ) : null}
                                 <div className="workspace__panes">
+                                    {previewMode ? (
+                                        // Floating state chip: read-only preview is otherwise
+                                        // invisible (the surface just stops responding to edits).
+                                        // Clicking it (or ⌘⇧P) returns to editing.
+                                        <Label
+                                            className="workspace__preview-badge"
+                                            theme="info"
+                                            size="s"
+                                            icon={<Icon data={Eye} size={13} />}
+                                            interactive
+                                            onClick={() => setPreviewMode(false)}
+                                            title="Read-only preview — click (or ⌘⇧P) to edit"
+                                        >
+                                            {/* Text swaps to the action on hover (CSS). */}
+                                            <span className="workspace__preview-badge-idle">
+                                                Preview
+                                            </span>
+                                            <span className="workspace__preview-badge-hover">
+                                                Exit preview
+                                            </span>
+                                        </Label>
+                                    ) : null}
                                     <EditorPane
                                         ref={editorRef}
                                         note={notes.note}
@@ -1426,6 +1498,12 @@ export function Workspace({
                         setSwitcherOpen(false);
                         handleOpenFolder();
                     }}
+                    // The dialog routes here only on desktop ⌘↵/⌘-click (its commit gates on
+                    // isDesktop); the hook additionally no-ops on web.
+                    onOpenFolderInNewWindow={() => {
+                        setSwitcherOpen(false);
+                        handleOpenFolderInNewWindow();
+                    }}
                     onRemove={handleRemoveWorkspace}
                     onClose={() => setSwitcherOpen(false)}
                 />
diff --git a/src/components/WorkspaceSwitcherDialog.test.tsx b/src/components/WorkspaceSwitcherDialog.test.tsx
index f9c150c..bc5196c 100644
--- a/src/components/WorkspaceSwitcherDialog.test.tsx
+++ b/src/components/WorkspaceSwitcherDialog.test.tsx
@@ -20,6 +20,7 @@ function setup(over: Partial<WorkspaceSwitcherDialogProps> = {}) {
     const onOpen = vi.fn();
     const onOpenInNewWindow = vi.fn();
     const onOpenFolder = vi.fn();
+    const onOpenFolderInNewWindow = vi.fn();
     const onRemove = vi.fn();
     const onClose = vi.fn();
     const props: WorkspaceSwitcherDialogProps = {
@@ -31,12 +32,13 @@ function setup(over: Partial<WorkspaceSwitcherDialogProps> = {}) {
         onOpen,
         onOpenInNewWindow,
         onOpenFolder,
+        onOpenFolderInNewWindow,
         onRemove,
         onClose,
         ...over,
     };
     renderWithProviders(<WorkspaceSwitcherDialog {...props} />);
-    return {onOpen, onOpenInNewWindow, onOpenFolder, onRemove, onClose};
+    return {onOpen, onOpenInNewWindow, onOpenFolder, onOpenFolderInNewWindow, onRemove, onClose};
 }
 
 const filter = () => screen.getByRole('combobox', {name: 'Filter workspaces'});
@@ -186,6 +188,36 @@ describe('WorkspaceSwitcherDialog', () => {
         expect(onOpen).not.toHaveBeenCalled();
     });
 
+    it('⌘Enter on the Open Folder row picks a folder for a NEW window (desktop)', () => {
+        const {onOpenFolder, onOpenFolderInNewWindow} = setup();
+        // Walk down to the action row: [Work] → In this app → Open Folder….
+        press('ArrowDown');
+        press('ArrowDown');
+        press('Enter', {metaKey: true});
+        expect(onOpenFolderInNewWindow).toHaveBeenCalledTimes(1);
+        expect(onOpenFolder).not.toHaveBeenCalled();
+    });
+
+    it('⌘-click on the Open Folder row also targets a new window (desktop)', () => {
+        const {onOpenFolder, onOpenFolderInNewWindow} = setup();
+        fireEvent.click(screen.getByRole('option', {name: /Open Folder/}), {metaKey: true});
+        expect(onOpenFolderInNewWindow).toHaveBeenCalledTimes(1);
+        expect(onOpenFolder).not.toHaveBeenCalled();
+    });
+
+    it('⌘Enter on Open Folder falls back to an in-place pick on the web', () => {
+        const {onOpenFolder, onOpenFolderInNewWindow} = setup({
+            isDesktop: false,
+            workspaces: WORKSPACES.filter((ws) => ws.backend !== 'indexeddb'),
+        });
+        // Web, in-app row synthesized: [Work] → In this browser → Open Folder….
+        press('ArrowDown');
+        press('ArrowDown');
+        press('Enter', {metaKey: true});
+        expect(onOpenFolder).toHaveBeenCalledTimes(1);
+        expect(onOpenFolderInNewWindow).not.toHaveBeenCalled();
+    });
+
     it('hides the Open Folder action when folder storage is unavailable', () => {
         setup({supportsFolders: false, isDesktop: false});
         expect(screen.queryByRole('option', {name: /Open Folder/})).toBeNull();
diff --git a/src/components/WorkspaceSwitcherDialog.tsx b/src/components/WorkspaceSwitcherDialog.tsx
index 68c9341..26c04a4 100644
--- a/src/components/WorkspaceSwitcherDialog.tsx
+++ b/src/components/WorkspaceSwitcherDialog.tsx
@@ -26,6 +26,8 @@ export interface WorkspaceSwitcherDialogProps {
     onOpenInNewWindow: (id: string) => void;
     /** Pick a brand-new folder (opens in this window). */
     onOpenFolder: () => void;
+    /** Desktop only: pick a folder and open it as its own window (⌘↵/⌘-click on the action row). */
+    onOpenFolderInNewWindow?: () => void;
     /** Drop from the recents list (notes on disk are untouched). */
     onRemove: (id: string) => void;
     onClose: () => void;
@@ -59,6 +61,7 @@ export function WorkspaceSwitcherDialog({
     onOpen,
     onOpenInNewWindow,
     onOpenFolder,
+    onOpenFolderInNewWindow,
     onRemove,
     onClose,
 }: WorkspaceSwitcherDialogProps) {
@@ -121,7 +124,10 @@ export function WorkspaceSwitcherDialog({
     const commit = (row: Row | undefined, newWindow: boolean) => {
         if (!row || row.disabled) return;
         if (row.openFolder) {
-            onOpenFolder();
+            // ⌘↵/⌘-click means "in a new window" for this row too — the picked folder opens in
+            // its own window and the current workspace stays put.
+            if (newWindow && isDesktop && onOpenFolderInNewWindow) onOpenFolderInNewWindow();
+            else onOpenFolder();
             return;
         }
         // A synthesized row exists nowhere yet, so a new window couldn't be assigned to it —
diff --git a/src/components/editor/linkifyTypedUrls.ts b/src/components/editor/linkifyTypedUrls.ts
new file mode 100644
index 0000000..5245c30
--- /dev/null
+++ b/src/components/editor/linkifyTypedUrls.ts
@@ -0,0 +1,55 @@
+import {type ExtensionBuilder} from '@gravity-ui/markdown-editor';
+import {InputRule} from 'prosemirror-inputrules';
+
+/**
+ * Marks the URL being disallowed from re-linking: already a link, inline code, or a wiki link.
+ * (Block code is excluded by the rule's `inCodeMark` option, mirroring the wiki-link input rule.)
+ */
+const DISALLOWED_MARKS = new Set(['link', 'code', 'wiki_link']);
+
+/**
+ * Typing-time linkify: turn a just-typed bare `https://…` into a real link the moment whitespace
+ * follows it. The load-time linkify (`md.linkify` + fuzzy off, see EditorPane) only runs at PARSE,
+ * so without this a URL typed into an open note stayed plain text until the note was reloaded.
+ *
+ * The mark is created with the editor's `raw-link` attr, which its serializer honors by emitting
+ * the BARE url — so a typed link round-trips byte-identical on disk (no `<url>` wrapping, unlike
+ * parse-path links). Explicit http(s) only, mirroring the fuzzy-off parse config: a bare
+ * `Notes.md` must never become a link.
+ */
+export function linkifyTypedUrls(builder: ExtensionBuilder): void {
+    builder.addInputRules(({schema}) => {
+        const markType = schema.marks.link;
+        if (!markType) return {rules: []};
+        return {
+            rules: [
+                new InputRule(
+                    // A URL right before the caret, terminated by the whitespace being typed. The
+                    // leading boundary keeps `foohttps://…` from matching mid-word.
+                    /(?:^|\s)(https?:\/\/[^\s]+)(\s)$/,
+                    (state, match, start, end) => {
+                        const url = match[1];
+                        const from = end - url.length; // the trailing \s is the char being typed
+                        if (from < start) return null; // defensive: boundary math went sideways
+                        // Don't relink text that is already a link / code / wiki link. `marksAcross`
+                        // isn't needed — a URL is one text run; the marks at its start describe it.
+                        const marks = state.doc.resolve(from + 1).marks();
+                        if (marks.some((mark) => DISALLOWED_MARKS.has(mark.type.name))) {
+                            return null;
+                        }
+                        return (
+                            state.tr
+                                .addMark(from, end, markType.create({href: url, 'raw-link': true}))
+                                // The rule's transaction REPLACES the default insertion, so type the
+                                // whitespace ourselves — outside the mark (no stored mark carried).
+                                .insertText(match[2], end)
+                                .removeStoredMark(markType)
+                        );
+                    },
+                    // Never inside code blocks — same option the wiki-link input rule uses.
+                    {inCodeMark: false},
+                ),
+            ],
+        };
+    });
+}
diff --git a/src/components/editor/markupHistory.test.ts b/src/components/editor/markupHistory.test.ts
new file mode 100644
index 0000000..fe17725
--- /dev/null
+++ b/src/components/editor/markupHistory.test.ts
@@ -0,0 +1,62 @@
+import {history, redoDepth, undoDepth} from '@codemirror/commands';
+import {EditorState} from '@codemirror/state';
+import {describe, expect, it} from 'vitest';
+
+import {freshMarkupState, markupEditorOf} from './markupHistory';
+
+/** A minimal state with undo history enabled — the aspect of the real markup config under test. */
+function stateWith(doc: string): EditorState {
+    return EditorState.create({doc, extensions: [history()]});
+}
+
+/** Apply a user-style edit (recorded in history). */
+function type(state: EditorState, at: number, insert: string): EditorState {
+    return state.update({changes: {from: at, insert}, userEvent: 'input.type'}).state;
+}
+
+describe('freshMarkupState', () => {
+    it('starts the new note with an empty undo/redo history', () => {
+        const template = stateWith('first note');
+        const fresh = freshMarkupState(template, 'second note');
+        expect(fresh.doc.toString()).toBe('second note');
+        expect(undoDepth(fresh)).toBe(0);
+        expect(redoDepth(fresh)).toBe(0);
+        // Caret parked at the start, matching the ProseMirror reset's doc-start selection.
+        expect(fresh.selection.main.anchor).toBe(0);
+    });
+
+    it('contrast: a plain replace keeps the previous note reachable via undo (the bug)', () => {
+        // The reused CodeMirror instance after edits in note A…
+        let state = stateWith('note A');
+        state = type(state, 6, ' plus edits');
+        // …then a note switch done as a plain replace (what editor.replace() dispatches).
+        state = state.update({
+            changes: {from: 0, to: state.doc.length, insert: 'note B'},
+        }).state;
+        // Undo history still reaches back across the switch — this is exactly what the fresh
+        // template state prevents.
+        expect(undoDepth(state)).toBeGreaterThan(0);
+    });
+
+    it('drops history accumulated before the swap even for a same-length doc', () => {
+        let template = stateWith('abc');
+        // The template must be captured PRISTINE; but even if edits happened on some other state
+        // derived from it, building from the pristine template ignores them.
+        const edited = type(template, 3, 'def');
+        expect(undoDepth(edited)).toBe(1);
+        template = stateWith('abc'); // pristine capture
+        const fresh = freshMarkupState(template, 'xyz');
+        expect(undoDepth(fresh)).toBe(0);
+        expect(fresh.doc.toString()).toBe('xyz');
+    });
+});
+
+describe('markupEditorOf', () => {
+    it('reaches a bundle-editor-shaped object and rejects anything else', () => {
+        const cm = {state: stateWith(''), setState: () => {}};
+        expect(markupEditorOf({markupEditor: {cm}})).toEqual({cm});
+        expect(markupEditorOf({})).toBeNull();
+        expect(markupEditorOf({markupEditor: {}})).toBeNull();
+        expect(markupEditorOf({markupEditor: {cm: {}}})).toBeNull();
+    });
+});
diff --git a/src/components/editor/markupHistory.ts b/src/components/editor/markupHistory.ts
new file mode 100644
index 0000000..4eefa5c
--- /dev/null
+++ b/src/components/editor/markupHistory.ts
@@ -0,0 +1,53 @@
+import {type EditorState, Transaction} from '@codemirror/state';
+
+/**
+ * Markup-mode (CodeMirror) undo isolation for the note-switch content swap.
+ *
+ * The Gravity editor keeps ONE CodeMirror instance for markup mode, created lazily on first use
+ * and reused for the editor's whole life — and its `replace()` is a plain dispatched change, so
+ * every note switch lands in the undo history: ⌘Z in markup mode could walk BACK INTO THE
+ * PREVIOUS NOTE's content, which the change handler would then autosave into the current file
+ * (silent cross-note corruption — the markup twin of the ProseMirror reset in EditorPane).
+ *
+ * There is no sanctioned "clear history" in CM6, and dispatching the swap with
+ * `addToHistory: false` is NOT enough: old events are then *remapped* through the replacement,
+ * and an insertion-type inverse (undo of a deletion) survives a whole-document mapping — ⌘Z
+ * would still paste old-note fragments. The reliable reset is a fresh `EditorState`, which
+ * needs the editor's full extension list — private to the bundle. So EditorPane snapshots the
+ * CodeMirror state at creation time, while it is PRISTINE (empty history), and every switch
+ * rebuilds the new note's state from that template: same extensions, new doc, no history.
+ */
+
+/**
+ * The bundle editor's markup half, reachable at runtime but absent from the public
+ * `MarkdownEditorInstance` type (`editor.markupEditor.cm` is the CodeMirror `EditorView`; the
+ * getter lazily CREATES the markup editor on first access — EditorPane leans on that to obtain
+ * the pristine template at mount). Kept to the two members we touch.
+ */
+export interface MarkupEditorHandle {
+    cm: {
+        state: EditorState;
+        setState(state: EditorState): void;
+    };
+}
+
+/** Reach the markup (CodeMirror) half of the bundle editor; null when the shape ever changes. */
+export function markupEditorOf(editor: unknown): MarkupEditorHandle | null {
+    const markup = (editor as {markupEditor?: MarkupEditorHandle}).markupEditor;
+    return markup && typeof markup.cm?.setState === 'function' ? markup : null;
+}
+
+/**
+ * A state holding `content` with an EMPTY undo history, built on `template` (a pristine state
+ * captured at CodeMirror-creation time, so it carries the editor's full extension set). The
+ * replace is annotated `addToHistory: false` out of caution — the template's history is empty,
+ * so there is nothing to remap either way — and the selection lands at the doc start (the swap
+ * caller restores the per-note caret separately where it applies).
+ */
+export function freshMarkupState(template: EditorState, content: string): EditorState {
+    return template.update({
+        changes: {from: 0, to: template.doc.length, insert: content},
+        selection: {anchor: 0},
+        annotations: Transaction.addToHistory.of(false),
+    }).state;
+}
diff --git a/src/components/editor/wikiLinkExtension.ts b/src/components/editor/wikiLinkExtension.ts
index dea0fbf..8e78324 100644
--- a/src/components/editor/wikiLinkExtension.ts
+++ b/src/components/editor/wikiLinkExtension.ts
@@ -30,6 +30,14 @@ export interface WikiLinkOptions {
     onSuggest?: WikiLinkSuggestSink;
     /** Drive the edit tooltip shown while the caret sits in a link (state pushed up to EditorPane). */
     onTooltip?: WikiLinkTooltipSink;
+    /**
+     * True while a note-switch content swap is replaying transactions (EditorPane's swappingRef).
+     * The tooltip/suggest popups close and stay closed for those: they aren't user caret movement,
+     * and anchors computed mid-swap are detached by the swap's own redraw — a popup pinned to a
+     * detached element renders at the viewport's top-left and never repositions. A restored caret
+     * that lands inside a `[[link]]` must not pop editing UI the user didn't ask for, either.
+     */
+    isSwapping?: () => boolean;
 }
 
 /** A snapshot the editor pushes to EditorPane to render the `[[` suggestion popup, or null to hide it. */
@@ -97,7 +105,11 @@ function wikiLinkRange(state: EditorState): {from: number; to: number; target: s
             if (run && run.to === from)
                 run.to = to; // extend the contiguous run in place
             else run = {from, to};
-            if (pos >= run.from && pos <= run.to) hit = run; // caret touches this run (incl. edges)
+            // Caret inside the run or at its RIGHT edge. The LEFT edge is deliberately out: the
+            // mark is `inclusive: false`, so a caret there isn't "in" the link for typing — and a
+            // doc that STARTS with a link would otherwise pop the tooltip the moment a fresh
+            // window opens with the caret parked at doc start.
+            if (pos > run.from && pos <= run.to) hit = run;
         } else {
             run = null;
         }
@@ -369,9 +381,14 @@ export function wikiLinkExtension(builder: ExtensionBuilder, opts: WikiLinkOptio
                             to: number;
                         } | null = null;
                         const push = () => {
-                            const range = wikiLinkRange(editorView.state);
+                            // Mid-swap updates close the tooltip and never open it (see
+                            // WikiLinkOptions.isSwapping); a detached anchor closes it too —
+                            // whatever it was pinned to is gone from the document.
+                            const range = opts.isSwapping?.()
+                                ? null
+                                : wikiLinkRange(editorView.state);
                             const anchor = range && wikiAnchorAt(editorView, range.from);
-                            if (!range || !anchor) {
+                            if (!range || !anchor?.isConnected) {
                                 if (last !== null) {
                                     last = null;
                                     onTooltip(null);
@@ -427,6 +444,7 @@ export function wikiLinkExtension(builder: ExtensionBuilder, opts: WikiLinkOptio
             getNotes: opts.getNotes,
             getCurrentId: opts.getCurrentId,
             onSuggest: opts.onSuggest,
+            isSwapping: opts.isSwapping,
         });
     }
 }
diff --git a/src/components/editor/wikiSuggest.ts b/src/components/editor/wikiSuggest.ts
index 9c0720e..493d025 100644
--- a/src/components/editor/wikiSuggest.ts
+++ b/src/components/editor/wikiSuggest.ts
@@ -16,6 +16,8 @@ export interface WikiSuggestOptions {
     getNotes(): NoteMeta[];
     getCurrentId(): string;
     onSuggest: WikiLinkSuggestSink;
+    /** True mid note-swap — the popup closes and won't open then (see WikiLinkOptions.isSwapping). */
+    isSwapping?: () => boolean;
 }
 
 interface SuggestState {
@@ -69,7 +71,7 @@ function insertLink(view: EditorView, markName: string, from: number, to: number
  * pushed through `onSuggest`. The ranked list itself is the pure `suggestWikiTargets`.
  */
 export function wikiSuggestPlugin(builder: ExtensionBuilder, opts: WikiSuggestOptions): void {
-    const {markName, getNotes, getCurrentId, onSuggest} = opts;
+    const {markName, getNotes, getCurrentId, onSuggest, isSwapping} = opts;
     const items = (st: SuggestState): NoteMeta[] =>
         st.active ? suggestWikiTargets(st.query, getNotes(), getCurrentId(), LIMIT) : [];
 
@@ -160,7 +162,11 @@ export function wikiSuggestPlugin(builder: ExtensionBuilder, opts: WikiSuggestOp
                         to: number;
                     } | null = null;
                     const push = () => {
-                        const st = KEY.getState(editorView.state);
+                        // Mid-swap updates close the popup and never open it: a restored caret
+                        // sitting after an unclosed `[[query` isn't the user typing one, and an
+                        // anchor computed mid-swap is detached by the swap's own redraw (a popup
+                        // pinned to a detached element renders at the viewport's top-left).
+                        const st = isSwapping?.() ? null : KEY.getState(editorView.state);
                         const list = st ? items(st) : [];
                         const anchor = editorView.dom.querySelector('.wiki-suggest');
                         if (!st?.active || list.length === 0 || !(anchor instanceof HTMLElement)) {
diff --git a/src/hooks/useNotesStorage.ts b/src/hooks/useNotesStorage.ts
index 5bd5a43..5189afb 100644
--- a/src/hooks/useNotesStorage.ts
+++ b/src/hooks/useNotesStorage.ts
@@ -148,6 +148,12 @@ export interface NotesStorage {
     supportsFolders: boolean;
     /** Open the system folder picker (must be triggered by a user gesture). */
     pickFolder(): Promise<void>;
+    /**
+     * Desktop only: pick a folder and open it as its OWN workspace window, leaving this window
+     * untouched (⌘↵/⌘-click on "Open Folder…"). Rejections surface to the caller (toast);
+     * dismissing the picker resolves quietly.
+     */
+    pickFolderForNewWindow(): Promise<void>;
     /** Use in-browser (IndexedDB) storage. */
     useBrowserStorage(): Promise<void>;
     /** Re-request permission for the remembered folder (user gesture). */
@@ -487,6 +493,35 @@ export function useNotesStorage(): NotesStorage {
         }
     }, [activate, beginOp, isStale]);
 
+    const pickFolderForNewWindow = useCallback(async () => {
+        if (!isTauri) return;
+        const {open} = await import('@tauri-apps/plugin-dialog');
+        const selected = await open({
+            directory: true,
+            multiple: false,
+            title: 'Choose your notes folder',
+        });
+        if (typeof selected !== 'string') return; // dismissed
+        const entry: WorkspaceEntry = {
+            id: workspaceIdForPath(selected),
+            backend: 'tauri-fs',
+            name: folderNameFromPath(selected),
+            lastOpenedAt: Date.now(),
+            path: selected,
+        };
+        // The new window bootstraps by looking its assigned workspace up in the REGISTRY, so the
+        // entry must be persisted before that page loads (deterministic tauri:<path> id — picking
+        // an already-known folder just refreshes its entry, and open_workspace_window focuses the
+        // window already showing it instead of duplicating).
+        await touchWorkspace(entry);
+        await refreshWorkspaces();
+        const {invoke} = await import('@tauri-apps/api/core');
+        await invoke('open_workspace_window', {
+            wsId: entry.id,
+            title: `${displayName(entry)} — Gravity Notes`,
+        });
+    }, [refreshWorkspaces]);
+
     const useBrowserStorage = useCallback(async () => {
         const seq = beginOp();
         setError(null);
@@ -622,6 +657,7 @@ export function useNotesStorage(): NotesStorage {
         supportsFileSystem,
         supportsFolders,
         pickFolder,
+        pickFolderForNewWindow,
         useBrowserStorage,
         grantPermission,
         reset,

From 3aa5f9f621dad5b812a7f2878be726838630ea45 Mon Sep 17 00:00:00 2001
From: Gadzhi Gadzhiev <168296+resure@users.noreply.github.com>
Date: Sun, 5 Jul 2026 17:01:09 +0300
Subject: [PATCH 3/5] =?UTF-8?q?fix:=20review=20follow-ups=20=E2=80=94=20ve?=
 =?UTF-8?q?t=20the=20literal=20preview=20href,=20pin=20linkifyTypedUrls?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two items from the note-windows branch review:

- NotePreview's click handler now vets target.getAttribute('href') instead
  of target.href, which resolves relative paths and footnote # anchors
  against the document base into openable http(s) URLs — so a relative
  [x](foo) opened a junk tab instead of being swallowed as the doc comment
  promised. Test added.
- linkifyTypedUrls gets the unit test every other new module had: the
  regex boundaries (^/\s, explicit scheme only, whitespace terminator) and
  the from = end - url.length mark math (URL marked exactly, raw-link attr
  set, typed space outside the inclusive:false mark), plus the
  link/code/wiki_link skip paths — driven through the same stub-builder +
  inputRules harness as the wikiLinkExtension test.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/components/NotePreview.test.tsx           |  15 ++
 src/components/NotePreview.tsx                |   8 +-
 .../editor/linkifyTypedUrls.test.ts           | 134 ++++++++++++++++++
 3 files changed, 154 insertions(+), 3 deletions(-)
 create mode 100644 src/components/editor/linkifyTypedUrls.test.ts

diff --git a/src/components/NotePreview.test.tsx b/src/components/NotePreview.test.tsx
index 74557a2..ca3ce72 100644
--- a/src/components/NotePreview.test.tsx
+++ b/src/components/NotePreview.test.tsx
@@ -127,6 +127,21 @@ describe('NotePreview', () => {
         // …and the URL went to the shared opener (OS browser on desktop, new tab on web).
         expect(vi.mocked(openExternalUrl)).toHaveBeenCalledWith('https://example.com/docs');
     });
+
+    it('hands the opener the LITERAL href, so a relative path stays swallowed', async () => {
+        transformMock.mockImplementation(await realTransform());
+
+        const {container} = renderWithProviders(<NotePreview markup="[local](foo/bar.md)" />);
+
+        const link = requireBody(container).querySelector('a[href="foo/bar.md"]');
+        expect(link).not.toBeNull();
+        const click = fireEvent.click(link as HTMLAnchorElement);
+        expect(click).toBe(false);
+        // The literal (relative) href reaches the opener, which rejects non-absolute URLs —
+        // `target.href` would instead resolve it against the document base into an openable
+        // http(s) URL and pop a junk tab.
+        expect(vi.mocked(openExternalUrl)).toHaveBeenCalledWith('foo/bar.md');
+    });
 });
 
 describe('withWikiLinks', () => {
diff --git a/src/components/NotePreview.tsx b/src/components/NotePreview.tsx
index 1272806..29144a4 100644
--- a/src/components/NotePreview.tsx
+++ b/src/components/NotePreview.tsx
@@ -78,14 +78,16 @@ interface NotePreviewProps {
  * desktop, a new tab on the web) instead of letting the surface navigate. Without this, a link
  * click walks the WHOLE APP away from itself in the web build, and goes nowhere useful in
  * WKWebView. Non-openable hrefs (relative paths, footnote `#` anchors, disallowed schemes) are
- * swallowed — preview never navigates. Delegated from the container so it covers every link the
- * HTML re-renders produce.
+ * swallowed — preview never navigates. The LITERAL attribute is what gets vetted: `target.href`
+ * would resolve a relative path or `#` anchor against the document base into a perfectly
+ * openable http(s) URL, opening a junk tab instead of swallowing. Delegated from the container
+ * so it covers every link the HTML re-renders produce.
  */
 function handlePreviewClick(event: React.MouseEvent<HTMLDivElement>): void {
     const target = event.target instanceof Element ? event.target.closest('a[href]') : null;
     if (!(target instanceof HTMLAnchorElement)) return;
     event.preventDefault();
-    openExternalUrl(target.href);
+    openExternalUrl(target.getAttribute('href') ?? '');
 }
 
 /**
diff --git a/src/components/editor/linkifyTypedUrls.test.ts b/src/components/editor/linkifyTypedUrls.test.ts
new file mode 100644
index 0000000..eba7979
--- /dev/null
+++ b/src/components/editor/linkifyTypedUrls.test.ts
@@ -0,0 +1,134 @@
+import {type InputRule, inputRules} from 'prosemirror-inputrules';
+import {type Mark, Schema} from 'prosemirror-model';
+import {EditorState, TextSelection} from 'prosemirror-state';
+import {describe, expect, it} from 'vitest';
+
+import {linkifyTypedUrls} from './linkifyTypedUrls';
+
+// A minimal schema with the marks the input rule inspects: `link` (what it creates — the attrs and
+// `inclusive: false` mirror the editor's LinkSpecs, so the typed whitespace must land OUTSIDE the
+// mark) plus `code` and `wiki_link` (which it must never fire inside). The real Gravity editor
+// can't run in jsdom, so — like the wikiLinkExtension test — we drive the extension's input rule
+// through a lightweight schema + the stock `inputRules` plugin.
+const schema = new Schema({
+    nodes: {
+        doc: {content: 'block+'},
+        paragraph: {group: 'block', content: 'inline*', toDOM: () => ['p', 0]},
+        text: {group: 'inline'},
+    },
+    marks: {
+        link: {
+            attrs: {href: {}, 'raw-link': {default: false}},
+            inclusive: false,
+            toDOM: () => ['a'],
+        },
+        code: {code: true, toDOM: () => ['code', 0]}, // spec.code → inline code
+        wiki_link: {toDOM: () => ['a', {class: 'wiki-link'}]},
+    },
+});
+
+/**
+ * Drive the real `linkifyTypedUrls` through a stub builder, capturing only the input-rules callback
+ * (the bit under test), then return the constructed `InputRule[]` resolved against `schema`.
+ */
+function rulesFromExtension(): InputRule[] {
+    let captured: InputRule[] = [];
+    const builder = {
+        addInputRules(factory: (deps: {schema: Schema}) => {rules: InputRule[]}) {
+            captured = factory({schema}).rules;
+            return builder;
+        },
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- structural stub of ExtensionBuilder
+    linkifyTypedUrls(builder as any);
+    return captured;
+}
+
+/** Type `lastChar` at the caret with the extension's input rule active; returns the new state, or null. */
+function typeWithRule(
+    textBefore: string,
+    lastChar: string,
+    marks: readonly Mark[] = [],
+): EditorState | null {
+    const plugin = inputRules({rules: rulesFromExtension()});
+    const para = schema.nodes.paragraph.create(null, schema.text(textBefore, [...marks]));
+    const doc = schema.nodes.doc.create(null, para);
+    let state = EditorState.create({schema, doc, plugins: [plugin]});
+    const caret = textBefore.length + 1; // inside the paragraph, after the existing text
+    state = state.apply(state.tr.setSelection(TextSelection.create(state.doc, caret)));
+    let next: EditorState | null = null;
+    const view = {
+        state,
+        composing: false,
+        dispatch: (tr: typeof state.tr) => {
+            next = state.apply(tr);
+        },
+    };
+    const handler = plugin.props.handleTextInput as unknown as
+        | ((view: unknown, from: number, to: number, text: string) => boolean)
+        | undefined;
+    handler?.(view, caret, caret, lastChar);
+    return next;
+}
+
+/** The paragraph's text runs with their link-mark facts, for exact boundary assertions (null → []). */
+function runsOf(state: EditorState | null): Array<{text: string; href?: string; raw?: boolean}> {
+    const runs: Array<{text: string; href?: string; raw?: boolean}> = [];
+    state?.doc.firstChild?.forEach((child) => {
+        const link = child.marks.find((mark) => mark.type.name === 'link');
+        runs.push({
+            text: child.text ?? '',
+            ...(link ? {href: link.attrs.href, raw: link.attrs['raw-link']} : {}),
+        });
+    });
+    return runs;
+}
+
+describe('linkifyTypedUrls input rule', () => {
+    it('marks exactly the typed URL on trailing space — boundary text and whitespace stay bare', () => {
+        const result = typeWithRule('see https://example.com', ' ');
+        // The `raw-link: true` attr is what makes the serializer emit the BARE url on disk.
+        expect(runsOf(result)).toEqual([
+            {text: 'see '},
+            {text: 'https://example.com', href: 'https://example.com', raw: true},
+            {text: ' '},
+        ]);
+    });
+
+    it('fires at paragraph start too (the ^ boundary), for http as well as https', () => {
+        const result = typeWithRule('http://example.com/a?b=c', ' ');
+        expect(runsOf(result)).toEqual([
+            {text: 'http://example.com/a?b=c', href: 'http://example.com/a?b=c', raw: true},
+            {text: ' '},
+        ]);
+    });
+
+    it('does NOT fire mid-word — foohttps://… stays plain', () => {
+        expect(typeWithRule('foohttps://example.com', ' ')).toBeNull();
+    });
+
+    it('does NOT fire on bare domains — explicit scheme only, mirroring fuzzy-off parse', () => {
+        // `.md` is a real TLD; a fuzzy match here would rewrite `Notes.md` mentions on disk.
+        expect(typeWithRule('rename Notes.md', ' ')).toBeNull();
+        expect(typeWithRule('example.com', ' ')).toBeNull();
+    });
+
+    it('does NOT fire on a non-whitespace character', () => {
+        expect(typeWithRule('https://example.co', 'm')).toBeNull();
+    });
+
+    it('skips text that is already a link (no re-linking)', () => {
+        const linked = schema.marks.link.create({href: 'https://example.com'});
+        expect(typeWithRule('https://example.com', ' ', [linked])).toBeNull();
+    });
+
+    it('skips URLs inside a wiki link', () => {
+        const wiki = schema.marks.wiki_link.create();
+        expect(typeWithRule('https://example.com', ' ', [wiki])).toBeNull();
+    });
+
+    it('skips URLs inside inline code ({inCodeMark: false})', () => {
+        const code = schema.marks.code.create();
+        expect(typeWithRule('https://example.com', ' ', [code])).toBeNull();
+    });
+});

From fd5584bc24ccfdfe6367d206a62991e6d93c6398 Mon Sep 17 00:00:00 2001
From: Gadzhi Gadzhiev <168296+resure@users.noreply.github.com>
Date: Sun, 5 Jul 2026 21:46:14 +0300
Subject: [PATCH 4/5] =?UTF-8?q?fix:=20code-review=20hardening=20=E2=80=94?=
 =?UTF-8?q?=20sidecar-pointer=20isolation,=20=E2=8C=980=20listener=20leak,?=
 =?UTF-8?q?=20linkify/iCloud=20edges?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Second xhigh /code-review pass over the note-windows branch (15 verified findings)
plus field-test follow-ups.

Correctness:
- useNotes: a note window's in-memory `active` pointer no longer leaks to the shared
  sidecar — writeMetadataNow substitutes the live on-disk value at the write boundary,
  so pins/appearance/navigation/close can't hijack the main window's restore pointer.
  onCloseRequested keeps a window open when its flush hit an unresolved conflict
  (instead of destroying it and dropping the edit).
- ⌘0 (Window ▸ Main Window): move the menu:main-window listener from workspace-keyed
  Workspace (remounts on every ⌃R switch → duplicate listeners → ⌘0 opened several
  workspaces at once) to App (one stable listener per window). window_note_renamed
  re-keys note-window focus-if-open on cross-window rename/move; all focus paths
  unminimize before show/focus; openInNewWindow fails loudly when the workspace left
  the registry; windowNote clears on the first in-place switch.
- linkifyTypedUrls: bail when the typed whitespace replaces a selection (offsets would
  mis-mark and leave the selection undeleted); trim trailing punctuation from the URL.
- useNotesStorage: skipProbe excludes the main window (its assignment is stale after a
  webview reload) and pickFolderForNewWindow probes the folder before touching the
  registry.
- useCorpus: re-read an iCloud-dataless file once its list preview materializes
  (download leaves mtime unchanged, so the updatedAt-keyed refresh missed it).
- NotePreview: middle-click (auxclick) also routes through the vetted external opener.
- Search Enter with the sidebar collapsed returns to the editor, not a hidden list.

Tooling/docs:
- eslint.config.js + .prettierignore: ignore stray root .vite/ cache and .claude/
  worktrees (gitignored full-repo copies that made `eslint .` hang / report phantoms).
- CLAUDE.md/README caught up; completed backlog items removed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .prettierignore                               |  2 +
 CLAUDE.md                                     | 56 ++++++++++----
 README.md                                     | 20 ++---
 eslint.config.js                              |  7 +-
 src-tauri/src/lib.rs                          | 76 +++++++++++++++++++
 src/App.tsx                                   | 42 +++++++++-
 src/components/NotePreview.tsx                | 14 +++-
 src/components/Workspace.tsx                  | 67 ++++++++--------
 .../editor/linkifyTypedUrls.test.ts           | 49 +++++++++++-
 src/components/editor/linkifyTypedUrls.ts     | 42 +++++++++-
 src/hooks/useCorpus.ts                        | 21 +++--
 src/hooks/useNotes.test.tsx                   | 40 ++++++++++
 src/hooks/useNotes.ts                         | 47 ++++++++++--
 src/hooks/useNotesStorage.ts                  | 69 +++++++++++++----
 14 files changed, 457 insertions(+), 95 deletions(-)

diff --git a/.prettierignore b/.prettierignore
index 6e35d98..8f6af8a 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -6,3 +6,5 @@ src-tauri/gen
 
 # Local, machine-specific Claude Code settings (gitignored) — not part of the codebase to format.
 .claude/settings.local.json
+# Isolation-mode worktrees are gitignored full-repo copies — don't format duplicated sources.
+.claude/worktrees
diff --git a/CLAUDE.md b/CLAUDE.md
index 4118f6a..11a2a6c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -43,7 +43,12 @@ because reading one blocks on download; they list by name/mtime with empty previ
 single-note open still materializes), the folder ops, `reveal_path`, and the **window commands** — a
 label→workspace map plus a label→note map powering
 `window_workspace`/`set_window_workspace`/`focus_workspace_window`/`open_workspace_window` and
-`window_note`/`set_window_note`/`open_note_window` (`ws-N` and `note-N` windows cloned from the main
+`window_note`/`set_window_note`/`window_note_renamed`/`open_note_window`, plus `focus_main_window`
+(the ⌘0 fallback App invokes when no Workspace is mounted to listen). `window_note_renamed` re-keys
+note-window assignments when a rename/move changes a note's rel-path (`useNotes.rename`/`move` fire
+it, fire-and-forget), so per-note focus-if-open doesn't go stale and spawn duplicate windows. All
+three focus-if-open paths `unminimize()` before `show()`+`set_focus()` — set_focus alone leaves a
+minimized window in the Dock. (`ws-N` and `note-N` windows are cloned from the main
 window's config; note windows are 760×640, cascade centered on the opener's monitor, get their
 workspace AND note assigned before the page loads, and are EXCLUDED from workspace-level
 focus-if-open — `NOTE_WINDOW_PREFIX` is mirrored in `src/isTauri.ts`, keep in sync); it also registers
@@ -57,7 +62,9 @@ position the lights manually), and builds a **custom app menu**: the macOS "Abou
 focuses-or-creates the workspace window for ITS OWN workspace (never dragging forward a main window
 parked on another one). **Close flow:** the main window hides on ⌘W (Rust-side, macOS convention)
 while `ws-N`/`note-N` windows really close — `useNotes`'s `onCloseRequested` handler flushes pending
-edits then calls `preventDefault()` ONLY for `main`; the JS wrapper's `destroy()` needs the
+edits then calls `preventDefault()` for `main` AND for any window whose flush could not land its
+edit (an unresolved conflict re-queued it — destroying then would silently drop the edit, so the
+window stays open with its conflict banner); the JS wrapper's `destroy()` needs the
 `core:window:allow-destroy` capability (granted to `main`, `ws-*`, and `note-*`), so those must stay
 in sync.
 
@@ -180,15 +187,22 @@ Key modules:
 - `src/hooks/useNotesStorage.ts` — the workspace lifecycle (state machine:
   `loading`/`choosing`/`needs-permission`/`ready`); yields a ready `NoteStore` plus the recents list.
   Bootstrap order: the shell's per-window assignment (`readWindowAssignment`: `window_workspace` +
-  `window_note`, both set before a `ws-N`/`note-N` window's page loads; a shell-assigned workspace
-  SKIPS the folder probe — the opener verified it seconds ago — so new windows paint fast) → the
+  `window_note`, both set before a `ws-N`/`note-N` window's page loads; a shell-assigned `ws-`/`note-`
+  window SKIPS the folder probe — the opener verified it moments ago — so new windows paint fast;
+  NOT the main window, whose assignment is registered on every in-place open and can be hours stale
+  after a webview reload) → the
   last-active pointer → `choosing`. A note window's assignment surfaces as `windowNote`
   ({workspaceId, noteId}), which App forwards to `Workspace` as `initialNoteId` only while the window
-  still shows that workspace. `openWorkspace(id)` switches in place (probe-guarded; desktop first asks
+  still shows that workspace — and is cleared for good on the first explicit `openWorkspace` switch,
+  so returning to the original workspace later restores its own last-active note, not the stale
+  assignment. `openWorkspace(id)` switches in place (probe-guarded; desktop first asks
   `focus_workspace_window` so a workspace already shown elsewhere is focused, not duplicated; a failed
-  switch leaves the current workspace mounted); `openInNewWindow(id)` invokes `open_workspace_window`;
-  `openNoteInNewWindow(noteId, title)` invokes `open_note_window` for the ACTIVE workspace;
-  `pickFolderForNewWindow()` picks a folder and opens it as its own window — persisting the registry
+  switch leaves the current workspace mounted); `openInNewWindow(id)` invokes `open_workspace_window`
+  (refreshing the registry and failing LOUDLY if the workspace is no longer in it — it's also the ⌘0
+  path); `openNoteInNewWindow(noteId, title)` invokes `open_note_window` for the ACTIVE workspace;
+  `pickFolderForNewWindow()` probes the picked folder (timed, BEFORE touching the registry — the new
+  window skips its own probe on the premise the opener verified it, and a dead/huge pick must not
+  become the launch pointer) then opens it as its own window — persisting the registry
   entry FIRST, since that's what the new window's bootstrap reads. Activation touches the registry,
   registers the window's workspace, and sets the native title (skipped in note windows — their title
   tracks the open note, owned by `Workspace`). Detects the Tauri shell (`__TAURI_INTERNALS__`):
@@ -208,8 +222,11 @@ Key modules:
   `visibilitychange` / `beforeunload`; `open()` is guarded by a generation counter (wrong-note race) and
   short-circuits the already-open note (no remount). An optional `initialNoteId` (a note window's
   assignment) overrides the restore: that note loads instead of the sidecar's last-`active` pointer,
-  and the sidecar is NOT written during the load — the pointer belongs to the main window's
-  next-launch restore. Re-lists on window focus (2 s throttle, `ready`-gated) — main + note windows
+  and the pointer belongs to the main window's next-launch restore — the load never writes it, and
+  every later metadata write from that hook (pin, appearance, wiki-link navigation, close) substitutes
+  the LIVE on-disk `active` at the write boundary (`writeMetadataNow` re-reads the sidecar; in-memory
+  `active` keeps tracking the window's own note for the conflict checks). Re-lists on window focus
+  (2 s throttle, `ready`-gated) — main + note windows
   routinely show the same folder now, so a returning window picks up notes created/edited elsewhere.
   Exposes `flushPending()` (teardown) and `refresh()` (re-list after import). Takes a `NoteStore` —
   agnostic to which backend it is.
@@ -217,7 +234,10 @@ Key modules:
   note is open) and shared by full-text search AND backlinks, so `getAll()` runs once (one big IPC on
   desktop) and every body is held once. Derives `contentById` (raw, for snippets), `lowerById`
   (pre-lowercased), and `linksById` (`[[…]]` pre-extracted). Refreshes **incrementally** (re-reads only
-  notes whose `updatedAt` changed) and keeps `linksById`'s identity stable across a non-link edit, so a
+  notes whose `updatedAt` changed — plus any cached with an EMPTY body whose list preview turned
+  non-empty: an iCloud-dataless file materializes without an mtime bump, so the preview flip is the
+  only signal its content became readable; the signature includes that bit) and keeps `linksById`'s
+  identity stable across a non-link edit, so a
   plain autosave doesn't rebuild the backlink graph. Dropped on backend change.
 - `src/hooks/useNoteNavigation.ts` / `useNoteSearch.ts` / `useBacklinks.ts` / `useShortcuts.ts` — list
   cursor + focus ladder (browse/commit/escape); search-or-create scoring against the shared corpus; the
@@ -261,7 +281,11 @@ Key modules:
   owns export/import and the flush-then-confirm guard before any workspace switch; per-workspace UI
   layout persists under `gravity-notes:<wsId>:*` localStorage keys, adopting the legacy un-namespaced
   value once — note windows skip both the read and the write, start with panels closed + editor
-  focused, and sync their native title + `set_window_note` assignment to the open note; also owns the
+  focused (search box when the assigned note failed to load, so the window is never
+  keyboard-orphaned), and sync their native title + `set_window_note` assignment to the open note
+  ONLY once `notes.ready` — the mount run would otherwise push `set_window_note(null)` mid-load and
+  wipe the shell's pre-seeded assignment (a second ⌘↵ during the load would duplicate the window);
+  also owns the
   floating **Preview badge** (read-only preview is otherwise invisible; hover swaps it to "Exit
   preview", click or ⌘⇧P leaves) and the **search auto-peek** — typing a query while the sidebar is
   collapsed peeks the list WITHOUT stealing focus from the box, and clearing the query or committing a
@@ -335,7 +359,13 @@ Key modules:
 - `src/App.tsx` — Gravity providers (theme, mobile, toaster) + theme persistence; wraps the app in
   `ErrorBoundary`. The theme key (`gravity-notes:theme`) is also read by an inline anti-flash
   script in `index.html` that paints the document background in the resolved theme before the bundle
-  loads (so launch doesn't flash white before dark) — keep the two in sync.
+  loads (so launch doesn't flash white before dark) — keep the two in sync. Also owns the **⌘0
+  (`menu:main-window`) listener** — deliberately HERE, not in `Workspace`: App mounts exactly once
+  per window and never remounts, whereas `Workspace` is keyed by workspace and remounts on every
+  ⌃R switch, so registering the listener there leaked a duplicate per switch (a window then fired
+  ⌘0 for several workspaces at once). It reads the live workspace/state via a ref and calls
+  `openInNewWindow(activeWorkspaceId)` (fallback `focus_main_window` when no workspace is mounted —
+  bootstrapping, or parked on the gate).
 - `src/main.tsx` — app-shell + Gravity/markdown-editor stylesheet imports.
 
 ## Conventions
diff --git a/README.md b/README.md
index a4189df..b5791fc 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ Markdown files, and they are yours.
   <img alt="Gravity Notes" src="assets/gravity-notes-dark.png">
 </picture>
 
-## Features (v1)
+## Features
 
 - **Choose your storage** on first run: a folder of plain `.md` files (Chromium browsers, or natively
   in the desktop app), or in-browser/in-app storage that works everywhere
@@ -182,23 +182,19 @@ Key modules:
 - **External changes** to the open note are detected when you return focus to the tab, not live while
   it stays focused.
 - **A selected image shows a faint caret line** beside it in the editor — the browser's native
-  object-selection caret, which resists CSS hiding. Cosmetic only; editing is unaffected. See
-  `TODO.md`.
+  object-selection caret, which resists CSS hiding. Cosmetic only; editing is unaffected.
 - **Auto-update (desktop) starts from the release that introduced it.** A build without the updater
   (≤ 0.2.0) has to be updated by hand once; from there the macOS app updates itself in place. arm64 only.
 
 ### Backlog
 
-- Bare-URL highlighting while EDITING (preview linkifies since 2026-07-05). Blocked on a safe
-  config: the editor serializes linkified URLs to `<url>` on save, and markdown-it's FUZZY
-  linkify would rewrite bare-domain text — `.md` is a real TLD, so a `Notes.md` mention would
-  become `[Notes.md](http://notes.md)` on disk. Needs linkify with `fuzzyLink: false` reachable
-  through the editor's options (or an upstream RawLink parse), plus a round-trip test.
-- iCloud dataless files: previews/search stay empty until a file is downloaded (the walks now
-  skip evicted content instead of hanging). Consider `startDownloadingUbiquitousItemAtURL` to
-  kick off downloads in the background + an "downloading…" preview state.
+- iCloud dataless files: not-yet-downloaded files list by name/mtime with an empty preview/search
+  body, and recover once macOS materializes them (a focus refresh picks up the filled-in preview).
+  Consider `startDownloadingUbiquitousItemAtURL` to kick off downloads in the background + a
+  "downloading…" preview state so it isn't silent.
 
-- Search index update on external file updates (+ reload workspace menu item?)
+- Live file-watching for external edits (today the list + search index refresh when the window
+  regains focus, not while it stays focused) + an explicit "reload workspace" menu item?
 - Density (line spacing) setting to complement the per-note font/width overrides?
 - Restore all workspace windows on relaunch (today only the last-active one comes back)
 
diff --git a/eslint.config.js b/eslint.config.js
index 89f091e..01fd880 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -5,7 +5,12 @@ import importOrderConfig from '@gravity-ui/eslint-config/import-order';
 import prettierConfig from '@gravity-ui/eslint-config/prettier';
 
 export default [
-    {ignores: ['dist', 'coverage', 'src-tauri']},
+    // Flat config does NOT read .gitignore, and its only default ignores are node_modules/.git.
+    // '.vite' matters: a stray root-level Vite dep-cache (340 multi-MB minified chunks) once made
+    // `eslint .` grind for 40+ minutes inside prettier/scope-analysis before anyone saw output.
+    // '.claude' holds machine-local settings + isolation-mode worktrees (full repo copies) — linting
+    // those duplicates the whole tree and reports phantom errors; nothing tracked there is JS/TS.
+    {ignores: ['dist', 'coverage', 'src-tauri', '.vite', '.claude']},
     ...baseConfig,
     ...clientConfig,
     ...importOrderConfig,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 7887785..6aa4662 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -829,6 +829,9 @@ fn focus_workspace_window(
         if let Some(target) = app.get_webview_window(&label) {
             // Don't hold the lock across window ops — they may hop to the main thread.
             drop(st);
+            // Unminimize first — set_focus on a miniaturized window only takes keyboard focus
+            // in the Dock (see show_main_window).
+            let _ = target.unminimize();
             let _ = target.show();
             let _ = target.set_focus();
             return true;
@@ -865,6 +868,9 @@ async fn open_workspace_window(
         while let Some(existing) = window_label_for_workspace(&st.labels, &ws_id, None) {
             if let Some(target) = app.get_webview_window(&existing) {
                 drop(st);
+                // Unminimize first — set_focus alone leaves a minimized window in the Dock
+                // (see show_main_window).
+                let _ = target.unminimize();
                 let _ = target.show();
                 let _ = target.set_focus();
                 return Ok(true);
@@ -972,6 +978,9 @@ async fn open_note_window(
             let Some(found) = found else { break };
             if let Some(target) = app.get_webview_window(&found) {
                 drop(st);
+                // Unminimize first — set_focus alone leaves a minimized window in the Dock
+                // (see show_main_window).
+                let _ = target.unminimize();
                 let _ = target.show();
                 let _ = target.set_focus();
                 return Ok(true);
@@ -1035,6 +1044,51 @@ fn show_main_window(app: &tauri::AppHandle) {
     }
 }
 
+/// Frontend fallback for Window ▸ Main Window (⌘0) when the focused window has no workspace
+/// mounted (still bootstrapping, or parked on the storage gate after a failed probe): there is
+/// nothing workspace-scoped to focus, so plainly re-show the (possibly ⌘W-hidden) main window.
+#[tauri::command]
+fn focus_main_window(app: tauri::AppHandle) {
+    show_main_window(&app);
+}
+
+/// Re-key note-window assignments after a note rename/move: any note window in the CALLER's
+/// workspace showing `old_id` is re-pointed at `new_id`, so per-note focus-if-open keeps
+/// matching. Without this, the map goes stale the moment another window renames the note —
+/// "open in new window" for the new path would then spawn a duplicate while the old window's
+/// entry pointed at a path that no longer exists. The workspace scope comes from the caller's
+/// own label registration (the rename ran in that window), so same rel-paths in OTHER
+/// workspaces are untouched.
+#[tauri::command]
+fn window_note_renamed(
+    window: tauri::WebviewWindow,
+    state: tauri::State<'_, WindowWorkspaces>,
+    old_id: String,
+    new_id: String,
+) {
+    let mut st = state.0.lock().unwrap();
+    let Some(ws_id) = st.labels.get(window.label()).cloned() else {
+        return;
+    };
+    let WindowState { labels, notes, .. } = &mut *st;
+    remap_note_windows(labels, notes, &ws_id, &old_id, &new_id);
+}
+
+/// Pure core of `window_note_renamed`, split out for the unit test.
+fn remap_note_windows(
+    labels: &HashMap<String, String>,
+    notes: &mut HashMap<String, String>,
+    ws_id: &str,
+    old_id: &str,
+    new_id: &str,
+) {
+    for (label, note) in notes.iter_mut() {
+        if note.as_str() == old_id && labels.get(label).map(String::as_str) == Some(ws_id) {
+            new_id.clone_into(note);
+        }
+    }
+}
+
 /// macOS window chrome shared by the main window (at setup) and each workspace window: make the
 /// title bar tall with SYSTEM-positioned traffic lights, and paint the webview backdrop in the
 /// resolved theme so a fresh window doesn't flash white before the page background loads (the
@@ -1285,7 +1339,9 @@ pub fn run() {
             open_workspace_window,
             window_note,
             set_window_note,
+            window_note_renamed,
             open_note_window,
+            focus_main_window,
         ])
         .build(tauri::generate_context!())
         .expect("error while building tauri application")
@@ -1745,4 +1801,24 @@ mod tests {
             Some("ws-2".to_string())
         );
     }
+
+    #[test]
+    fn note_rename_remaps_matching_windows_in_the_same_workspace_only() {
+        let mut labels = HashMap::new();
+        labels.insert("main".to_string(), "tauri:/a".to_string());
+        labels.insert("note-1".to_string(), "tauri:/a".to_string());
+        labels.insert("note-2".to_string(), "tauri:/b".to_string());
+        let mut notes = HashMap::new();
+        notes.insert("note-1".to_string(), "Old.md".to_string());
+        // Same rel-path open in ANOTHER workspace — must not be touched by /a's rename.
+        notes.insert("note-2".to_string(), "Old.md".to_string());
+
+        remap_note_windows(&labels, &mut notes, "tauri:/a", "Old.md", "New.md");
+        assert_eq!(notes.get("note-1").map(String::as_str), Some("New.md"));
+        assert_eq!(notes.get("note-2").map(String::as_str), Some("Old.md"));
+
+        // A rename of a note no window shows is a no-op.
+        remap_note_windows(&labels, &mut notes, "tauri:/a", "Missing.md", "Elsewhere.md");
+        assert_eq!(notes.get("note-1").map(String::as_str), Some("New.md"));
+    }
 }
diff --git a/src/App.tsx b/src/App.tsx
index 407ee74..4293ac5 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,4 @@
-import {useEffect, useState} from 'react';
+import {useEffect, useRef, useState} from 'react';
 
 import {
     MobileProvider,
@@ -58,6 +58,46 @@ export function App() {
             .catch(() => {});
     }, [themePref]);
 
+    // ⌘0 (Window ▸ Main Window): surface the full workspace view for THIS window's workspace. The
+    // listener lives HERE — App mounts exactly once per window and never remounts — rather than in
+    // Workspace, which is keyed by workspace and remounts on every ⌃R switch: registering it there
+    // leaked a duplicate listener per switch (the async listen/unlisten doesn't tear down cleanly
+    // across rapid remounts), so a window ended up firing ⌘0 for several workspaces at once. One
+    // stable listener per window, reading the live workspace/state through a ref, fixes that by
+    // construction. `openInNewWindow` focuses the existing main/ws window for this workspace
+    // (un-hiding a ⌘W-hidden main) or creates one; the fallback re-shows main when there's no
+    // workspace to scope to (still bootstrapping, or parked on the gate after a failed probe).
+    const storageRef = useRef(storage);
+    storageRef.current = storage;
+    useEffect(() => {
+        if (!isTauri) return undefined;
+        let unlisten: (() => void) | undefined;
+        let disposed = false;
+        const showMain = () =>
+            void import('@tauri-apps/api/core').then(({invoke}) =>
+                invoke('focus_main_window').catch(() => {}),
+            );
+        void import('@tauri-apps/api/webviewWindow').then(({getCurrentWebviewWindow}) =>
+            getCurrentWebviewWindow()
+                .listen('menu:main-window', () => {
+                    const st = storageRef.current;
+                    if (st.state === 'ready' && st.activeWorkspaceId) {
+                        st.openInNewWindow(st.activeWorkspaceId).catch(showMain);
+                    } else {
+                        showMain();
+                    }
+                })
+                .then((fn) => {
+                    if (disposed) fn();
+                    else unlisten = fn;
+                }),
+        );
+        return () => {
+            disposed = true;
+            unlisten?.();
+        };
+    }, []);
+
     return (
         <ThemeProvider theme={themePref}>
             <MobileProvider>
diff --git a/src/components/NotePreview.tsx b/src/components/NotePreview.tsx
index 29144a4..1dea99d 100644
--- a/src/components/NotePreview.tsx
+++ b/src/components/NotePreview.tsx
@@ -81,9 +81,13 @@ interface NotePreviewProps {
  * swallowed — preview never navigates. The LITERAL attribute is what gets vetted: `target.href`
  * would resolve a relative path or `#` anchor against the document base into a perfectly
  * openable http(s) URL, opening a junk tab instead of swallowing. Delegated from the container
- * so it covers every link the HTML re-renders produce.
+ * so it covers every link the HTML re-renders produce. Bound to BOTH click and auxclick: a
+ * middle-click fires only `auxclick`, whose browser default (open in new tab) would otherwise
+ * bypass this vetting entirely with the base-resolved URL.
  */
 function handlePreviewClick(event: React.MouseEvent<HTMLDivElement>): void {
+    // auxclick also fires for right-click (button 2) — leave that to the context menu.
+    if (event.type === 'auxclick' && event.button !== 1) return;
     const target = event.target instanceof Element ? event.target.closest('a[href]') : null;
     if (!(target instanceof HTMLAnchorElement)) return;
     event.preventDefault();
@@ -225,7 +229,13 @@ export const NotePreview = forwardRef<HTMLDivElement, NotePreviewProps>(function
 
     return (
         // eslint-disable-next-line jsx-a11y/no-static-element-interactions, jsx-a11y/click-events-have-key-events -- delegated link-open only; the links inside are the interactive elements and stay keyboard-activatable natively
-        <div ref={ref} className="note-preview" tabIndex={-1} onClick={handlePreviewClick}>
+        <div
+            ref={ref}
+            className="note-preview"
+            tabIndex={-1}
+            onClick={handlePreviewClick}
+            onAuxClick={handlePreviewClick}
+        >
             {rendered.error ? (
                 // Surface a transform failure instead of a silent blank pane; the editor body keeps
                 // the actual content, so the user can switch back and keep working.
diff --git a/src/components/Workspace.tsx b/src/components/Workspace.tsx
index 5e599ac..c3b565d 100644
--- a/src/components/Workspace.tsx
+++ b/src/components/Workspace.tsx
@@ -650,20 +650,27 @@ export function Workspace({
     }, []);
     const initialEditorFocusRef = useRef(false);
     useEffect(() => {
-        if (!noteWindow || initialEditorFocusRef.current || !notes.note) return;
+        if (!noteWindow || initialEditorFocusRef.current || !notes.ready) return;
         initialEditorFocusRef.current = true;
-        editorRef.current?.focus();
-    }, [noteWindow, notes.note]);
+        // The assigned note failed to load (renamed/trashed since the window was asked for):
+        // nothing is focusable in a panels-closed window, so land in the search box — the
+        // keyboard stays alive and the placeholder's "create one" is one ⌘N away.
+        if (notes.note) editorRef.current?.focus();
+        else searchInputRef.current?.focus();
+    }, [noteWindow, notes.ready, notes.note]);
 
     // A note window's native title tracks its open note (rename included), falling back to the
     // workspace label once no note is open; it also keeps the shell's label→note assignment
     // current, so a later "open in new window" for the note now shown here focuses this window
     // instead of duplicating it — and stops matching a note this window has navigated away from.
     // `notes.note` only changes identity on open/reload (edits flow through refs), so it's a
-    // stable-enough dep.
+    // stable-enough dep. Gated on `ready`: the mount runs before the assigned note has LOADED,
+    // and pushing `set_window_note(null)` then would wipe the label→note entry the shell seeded
+    // before this page loaded — leaving per-note focus-if-open blind for the whole load (a second
+    // ⌘↵ would duplicate the window) and flashing the native title through the workspace fallback.
     const openNote = notes.note;
     useEffect(() => {
-        if (!noteWindow) return;
+        if (!noteWindow || !notes.ready) return;
         void (async () => {
             try {
                 const {invoke} = await import('@tauri-apps/api/core');
@@ -677,7 +684,7 @@ export function Workspace({
                 // Best-effort: a failure only leaves the title stale / focus-if-open duplicable.
             }
         })();
-    }, [noteWindow, openNote, storageLabel]);
+    }, [noteWindow, notes.ready, openNote, storageLabel]);
 
     // Global Esc fallback: when focus is somewhere that doesn't handle Esc itself (the top
     // bar, the document body), send it back to the note list so keyboard nav resumes. When the
@@ -769,37 +776,26 @@ export function Workspace({
         [onOpenWorkspaceInNewWindow, onError],
     );
 
-    // ⌘0 / Window ▸ Main Window: the shell asks the FOCUSED window (this one) to surface the full
-    // workspace view for ITS workspace. Reusing the workspace-window opener gives the right
-    // semantics for free: it focuses the existing main/ws-N window showing this workspace
-    // (un-hiding a ⌘W-hidden main), creates one when none exists, and never lands on a note
-    // window — so ⌘0 stays within the current workspace instead of dragging forward a main
-    // window parked on some other one. In a full workspace window it self-focuses (a no-op).
-    useEffect(() => {
-        if (!isTauri) return undefined;
-        let unlisten: (() => void) | undefined;
-        let disposed = false;
-        void import('@tauri-apps/api/webviewWindow').then(({getCurrentWebviewWindow}) =>
-            getCurrentWebviewWindow()
-                .listen('menu:main-window', () => handleOpenWorkspaceInNewWindow(workspaceId))
-                .then((fn) => {
-                    if (disposed) fn();
-                    else unlisten = fn;
-                }),
-        );
-        return () => {
-            disposed = true;
-            unlisten?.();
-        };
-    }, [workspaceId, handleOpenWorkspaceInNewWindow]);
+    // ⌘0 / Window ▸ Main Window is handled ONCE PER WINDOW in App (a stable listener there), not
+    // here: Workspace is keyed by workspace and remounts on every ⌃R switch, and registering the
+    // menu listener per mount leaked duplicates that fired ⌘0 for several workspaces at once.
 
     // Open a note in its own single-note window (row menu / ⌘↵ in the list). Unlike a workspace
     // window, flush first: the new window reads the note from DISK, so a pending edit here (this
-    // note may well be the open one) must land before that page loads.
+    // note may well be the open one) must land before that page loads. If the flush could NOT
+    // land it (an unresolved conflict re-queued the edit) and it's THIS note being opened, refuse:
+    // the new window would show the stale disk copy while this one holds a divergent edit — a
+    // silent fork where whichever window autosaves last wins.
     const handleOpenNoteInNewWindow = useCallback(
         (id: string) => {
             void (async () => {
-                await notes.flushPending();
+                const unresolved = await notes.flushPending();
+                if (unresolved && id === notes.activeId) {
+                    onError(
+                        'This note has an unresolved conflict — resolve it before opening it in a new window.',
+                    );
+                    return;
+                }
                 const title = notes.notes.find((n) => n.id === id)?.title ?? titleFromFileName(id);
                 try {
                     await onOpenNoteInNewWindow(id, title);
@@ -1264,7 +1260,14 @@ export function Workspace({
                     onCreate={(title) => handleCreate(title, '')}
                     onClose={nav.closeFromSearch}
                     onEnterList={enterList}
-                    onFocusList={() => listRef.current?.focusSelected()}
+                    onFocusList={() => {
+                        // Enter on an EMPTY search box: step onto the selected note's row — but
+                        // with the sidebar collapsed (and not peeked) there is no visible row to
+                        // land on, so return to the editor body instead; the open note is the
+                        // only thing on screen.
+                        if (collapsed && !peeked && notes.note) editorRef.current?.focus();
+                        else listRef.current?.focusSelected();
+                    }}
                     noteOpen={notes.note !== null}
                     appearanceOpen={appearanceOpen}
                     onToggleAppearance={() => setAppearanceOpen((open) => !open)}
diff --git a/src/components/editor/linkifyTypedUrls.test.ts b/src/components/editor/linkifyTypedUrls.test.ts
index eba7979..260149f 100644
--- a/src/components/editor/linkifyTypedUrls.test.ts
+++ b/src/components/editor/linkifyTypedUrls.test.ts
@@ -44,18 +44,24 @@ function rulesFromExtension(): InputRule[] {
     return captured;
 }
 
-/** Type `lastChar` at the caret with the extension's input rule active; returns the new state, or null. */
+/**
+ * Type `lastChar` at the caret with the extension's input rule active; returns the new state, or
+ * null. `selection` overrides the default collapsed caret after the text — a from<to range drives
+ * the rule the way prosemirror-view does when typing REPLACES a selection.
+ */
 function typeWithRule(
     textBefore: string,
     lastChar: string,
     marks: readonly Mark[] = [],
+    selection?: {from: number; to: number},
 ): EditorState | null {
     const plugin = inputRules({rules: rulesFromExtension()});
     const para = schema.nodes.paragraph.create(null, schema.text(textBefore, [...marks]));
     const doc = schema.nodes.doc.create(null, para);
     let state = EditorState.create({schema, doc, plugins: [plugin]});
-    const caret = textBefore.length + 1; // inside the paragraph, after the existing text
-    state = state.apply(state.tr.setSelection(TextSelection.create(state.doc, caret)));
+    const from = selection?.from ?? textBefore.length + 1; // default: after the existing text
+    const to = selection?.to ?? from;
+    state = state.apply(state.tr.setSelection(TextSelection.create(state.doc, from, to)));
     let next: EditorState | null = null;
     const view = {
         state,
@@ -67,7 +73,7 @@ function typeWithRule(
     const handler = plugin.props.handleTextInput as unknown as
         | ((view: unknown, from: number, to: number, text: string) => boolean)
         | undefined;
-    handler?.(view, caret, caret, lastChar);
+    handler?.(view, from, to, lastChar);
     return next;
 }
 
@@ -131,4 +137,39 @@ describe('linkifyTypedUrls input rule', () => {
         const code = schema.marks.code.create();
         expect(typeWithRule('https://example.com', ' ', [code])).toBeNull();
     });
+
+    it('does NOT fire when the typed whitespace replaces a selection (offsets would mis-mark)', () => {
+        // "see https://example.com(bar)" with "(bar)" selected (doc positions 24–29): the rule's
+        // offsets are caret-relative, and its transaction would supersede the selection-deleting
+        // default — mis-marking the span and leaving "(bar)" undeleted. It must bail instead.
+        expect(
+            typeWithRule('see https://example.com(bar)', ' ', [], {from: 24, to: 29}),
+        ).toBeNull();
+    });
+
+    it('keeps trailing sentence punctuation out of the link, like the parse-path linkify', () => {
+        const result = typeWithRule('see https://example.com,', ' ');
+        expect(runsOf(result)).toEqual([
+            {text: 'see '},
+            {text: 'https://example.com', href: 'https://example.com', raw: true},
+            {text: ', '},
+        ]);
+    });
+
+    it('trims an unbalanced closing paren but keeps a balanced one', () => {
+        expect(runsOf(typeWithRule('(see https://example.com)', ' '))).toEqual([
+            {text: '(see '},
+            {text: 'https://example.com', href: 'https://example.com', raw: true},
+            {text: ') '},
+        ]);
+        const wiki = 'https://en.wikipedia.org/wiki/Foo_(bar)';
+        expect(runsOf(typeWithRule(wiki, ' '))).toEqual([
+            {text: wiki, href: wiki, raw: true},
+            {text: ' '},
+        ]);
+    });
+
+    it('does NOT fire when trimming leaves a bare scheme', () => {
+        expect(typeWithRule('https://...', ' ')).toBeNull();
+    });
 });
diff --git a/src/components/editor/linkifyTypedUrls.ts b/src/components/editor/linkifyTypedUrls.ts
index 5245c30..a4e9ffc 100644
--- a/src/components/editor/linkifyTypedUrls.ts
+++ b/src/components/editor/linkifyTypedUrls.ts
@@ -7,6 +7,28 @@ import {InputRule} from 'prosemirror-inputrules';
  */
 const DISALLOWED_MARKS = new Set(['link', 'code', 'wiki_link']);
 
+/**
+ * Drop trailing punctuation the greedy `[^\s]+` swallowed, mirroring linkify-it's parse rules
+ * (a `,`/`.`/`;`/… before whitespace is sentence punctuation, and an unbalanced `)` closes prose,
+ * not the URL) — so a typed link's boundary matches what a reload's parse-path linkify produces,
+ * and ⌘-click never opens `https://example.com,`.
+ */
+function trimTrailingPunctuation(url: string): string {
+    let end = url.length;
+    for (; end > 0; end--) {
+        const char = url[end - 1];
+        if ('.,;:!?'.includes(char)) continue;
+        if (char === ')') {
+            const body = url.slice(0, end);
+            const opens = body.split('(').length - 1;
+            const closes = body.split(')').length - 1;
+            if (closes > opens) continue; // unbalanced — prose, not part of the URL
+        }
+        break;
+    }
+    return url.slice(0, end);
+}
+
 /**
  * Typing-time linkify: turn a just-typed bare `https://…` into a real link the moment whitespace
  * follows it. The load-time linkify (`md.linkify` + fuzzy off, see EditorPane) only runs at PARSE,
@@ -28,9 +50,19 @@ export function linkifyTypedUrls(builder: ExtensionBuilder): void {
                     // leading boundary keeps `foohttps://…` from matching mid-word.
                     /(?:^|\s)(https?:\/\/[^\s]+)(\s)$/,
                     (state, match, start, end) => {
-                        const url = match[1];
-                        const from = end - url.length; // the trailing \s is the char being typed
+                        // Only at a collapsed caret. When the typed whitespace REPLACES a
+                        // selection, `end` is the selection END while the matched text sits
+                        // before the selection START — the offsets below would mark the wrong
+                        // span, and returning a transaction would supersede the default
+                        // replace-selection insertion (leaving the selected text undeleted).
+                        if (!state.selection.empty) return null;
+                        const url = trimTrailingPunctuation(match[1]);
+                        if (!/^https?:\/\/[^\s]/.test(url)) return null; // trimmed to a bare scheme
+                        const from = end - match[1].length; // the trailing \s is the char being typed
                         if (from < start) return null; // defensive: boundary math went sideways
+                        // The DOM-change input path can hand the rule a multi-char replacement
+                        // (autocorrect); mark only what is verifiably in the doc at these offsets.
+                        if (state.doc.textBetween(from, end) !== match[1]) return null;
                         // Don't relink text that is already a link / code / wiki link. `marksAcross`
                         // isn't needed — a URL is one text run; the marks at its start describe it.
                         const marks = state.doc.resolve(from + 1).marks();
@@ -39,7 +71,11 @@ export function linkifyTypedUrls(builder: ExtensionBuilder): void {
                         }
                         return (
                             state.tr
-                                .addMark(from, end, markType.create({href: url, 'raw-link': true}))
+                                .addMark(
+                                    from,
+                                    from + url.length, // trimmed punctuation stays outside the mark
+                                    markType.create({href: url, 'raw-link': true}),
+                                )
                                 // The rule's transaction REPLACES the default insertion, so type the
                                 // whitespace ourselves — outside the mark (no stored mark carried).
                                 .insertText(match[2], end)
diff --git a/src/hooks/useCorpus.ts b/src/hooks/useCorpus.ts
index 061eb48..d53dc0c 100644
--- a/src/hooks/useCorpus.ts
+++ b/src/hooks/useCorpus.ts
@@ -27,12 +27,15 @@ import {type WikiLinkRef, extractWikiLinks} from '../wikiLinks';
  */
 
 /**
- * Order-independent fingerprint of the note list (id + last-modified). The corpus reloads only when
- * this changes — a note's content/identity changed — not on a re-sort, re-pin, or keystroke.
+ * Order-independent fingerprint of the note list (id + last-modified + has-preview). The corpus
+ * reloads only when this changes — a note's content/identity changed — not on a re-sort, re-pin, or
+ * keystroke. The preview BIT is included for iCloud-dataless files: the bulk walk lists them with an
+ * empty body/preview, and materialization restores the original mtime — so the empty→non-empty
+ * preview flip on a later walk is the only signal that the content is now readable.
  */
 function listSignature(notes: NoteMeta[]): string {
     return notes
-        .map((n) => `${n.id}:${n.updatedAt ?? 0}`)
+        .map((n) => `${n.id}:${n.updatedAt ?? 0}:${n.preview ? 1 : 0}`)
         .sort()
         .join('\n');
 }
@@ -190,9 +193,15 @@ export function useCorpus(store: CorpusSource, notes: NoteMeta[], active: boolea
                 } else {
                     // Incremental: re-read only notes whose updatedAt changed (or are new); reuse the
                     // rest, and drop any that vanished. Avoids a full re-scan when one note is edited.
-                    const stale = currentNotes.filter(
-                        (n) => cachedCorpus.get(n.id)?.updatedAt !== (n.updatedAt ?? 0),
-                    );
+                    const stale = currentNotes.filter((n) => {
+                        const cached = cachedCorpus.get(n.id);
+                        if (!cached || cached.updatedAt !== (n.updatedAt ?? 0)) return true;
+                        // An iCloud-dataless file was cached with an EMPTY body, and downloading
+                        // it doesn't bump mtime — but the list preview flips non-empty once the
+                        // content is local. Re-read then; a still-dataless file keeps an empty
+                        // preview, so this never forces a blocking read of evicted content.
+                        return cached.content === '' && Boolean(n.preview);
+                    });
                     const fetched = await Promise.all(
                         stale.map((n) =>
                             store.get(n.id).then(
diff --git a/src/hooks/useNotes.test.tsx b/src/hooks/useNotes.test.tsx
index ec69315..59b517c 100644
--- a/src/hooks/useNotes.test.tsx
+++ b/src/hooks/useNotes.test.tsx
@@ -191,6 +191,46 @@ describe('useNotes — single note', () => {
         expect((await store.readMetadata()).active).toBe('A.md');
     });
 
+    it('a note-window metadata write (pin, navigation) preserves the on-disk active pointer', async () => {
+        const onError = vi.fn();
+        const dir = new FakeDirectoryHandle();
+        dir.seedFile('A.md', 'a', 100);
+        dir.seedFile('B.md', 'b', 200);
+        dir.seedFile('C.md', 'c', 300);
+        dir.seedFile(
+            METADATA_FILENAME,
+            JSON.stringify({
+                version: 1,
+                sort: 'updated',
+                pinned: [],
+                created: {},
+                active: 'A.md',
+            }),
+        );
+        const store = new FileSystemNoteStore(asDirectoryHandle(dir));
+        const hook = renderHook(() => useNotes(store, onError, 'B.md'));
+        await waitFor(() => expect(hook.result.current.activeId).toBe('B.md'));
+        // A deliberate metadata mutation from the note window (pin) writes the sidecar…
+        await act(async () => {
+            hook.result.current.togglePin('C.md');
+        });
+        await waitFor(async () => {
+            expect((await store.readMetadata()).pinned).toContain('C.md');
+        });
+        // …but the shared last-active pointer must stay the MAIN window's, not this window's note.
+        expect((await store.readMetadata()).active).toBe('A.md');
+        // Navigating within the note window (open → withActive write) must not leak it either.
+        await act(async () => {
+            await hook.result.current.open('C.md');
+        });
+        await act(async () => {
+            await hook.result.current.flushPending();
+        });
+        await waitFor(async () => {
+            expect((await store.readMetadata()).active).toBe('A.md');
+        });
+    });
+
     it('a missing initialNoteId opens nothing and leaves the sidecar pointer intact', async () => {
         const onError = vi.fn();
         const dir = new FakeDirectoryHandle();
diff --git a/src/hooks/useNotes.ts b/src/hooks/useNotes.ts
index 9725b1a..8add46d 100644
--- a/src/hooks/useNotes.ts
+++ b/src/hooks/useNotes.ts
@@ -86,6 +86,19 @@ const RETRY_MAX_DELAY = 30_000;
  */
 const FOCUS_REFRESH_MIN_GAP_MS = 2_000;
 
+/**
+ * Tell the desktop shell a note's id (rel-path) changed, so any single-note WINDOW pinned to the
+ * old id keeps answering per-note focus-if-open under the new one (without this, "open in new
+ * window" for the renamed note would spawn a duplicate). Fire-and-forget: the shell map is an
+ * optimization, and the web build has no shell at all.
+ */
+function notifyShellNoteRenamed(oldId: string, newId: string): void {
+    if (!isTauri) return;
+    void import('@tauri-apps/api/core')
+        .then(({invoke}) => invoke('window_note_renamed', {oldId, newId}))
+        .catch(() => {});
+}
+
 /** A detected external change to the open note. */
 export interface NoteConflict {
     id: string;
@@ -225,6 +238,9 @@ export function useNotes(
     const [conflict, setConflict] = useState<NoteConflict | null>(null);
     const [metadata, setMetadata] = useState<NotesMetadata>(DEFAULT_METADATA);
     const metadataRef = useRef<NotesMetadata>(DEFAULT_METADATA);
+    // The sidecar's on-disk `active` as of the initial load — the fallback for the note-window
+    // write-boundary substitution in writeMetadataNow when a fresh disk read fails.
+    const diskActiveRef = useRef<string | null>(null);
     const [ready, setReady] = useState(false);
     const [sessionId, setSessionId] = useState(0);
     const sessionRef = useRef(0);
@@ -255,14 +271,27 @@ export function useNotes(
             metaWriteTimerRef.current = null;
         }
         try {
-            await store.writeMetadata(metadataRef.current);
+            let payload = metadataRef.current;
+            if (typeof initialNoteId === 'string') {
+                // A single-note window's in-memory `active` deliberately tracks ITS open note
+                // (the conflict checks key on it), but the on-disk pointer belongs to the main
+                // window's next-launch restore — substitute the live disk value at this write
+                // boundary so no note-window persist (pin, appearance, navigation, close…) can
+                // hijack it. The load-time snapshot backstops a failed disk read.
+                const active = await store
+                    .readMetadata()
+                    .then((disk) => disk.active)
+                    .catch(() => diskActiveRef.current);
+                payload = {...payload, active};
+            }
+            await store.writeMetadata(payload);
             return true;
         } catch (err) {
             metaWriteDirtyRef.current = true;
             onError(err instanceof Error ? err.message : 'Failed to save notes metadata');
             return false;
         }
-    }, [store, onError]);
+    }, [store, initialNoteId, onError]);
 
     const persistMetadata = useCallback(
         async (next: NotesMetadata, options?: {defer?: boolean}): Promise<boolean> => {
@@ -740,6 +769,7 @@ export function useNotes(
                     timerRef.current = setTimeout(() => void flush(), AUTOSAVE_DELAY);
                 }
                 rekeyNote(id, meta); // re-key the list row in place (body/preview unchanged)
+                notifyShellNoteRenamed(id, meta.id); // keep note-window focus-if-open matching
                 return meta.id;
             } catch (err) {
                 if (err instanceof NameCollisionError) {
@@ -801,6 +831,7 @@ export function useNotes(
                     timerRef.current = setTimeout(() => void flush(), AUTOSAVE_DELAY);
                 }
                 rekeyNote(id, meta); // re-key the list row in place; folder synthesizes from the path
+                notifyShellNoteRenamed(id, meta.id); // keep note-window focus-if-open matching
                 await relistFolders(); // dest folder may be new; emptied source folder may be pruned
                 return meta.id;
             } catch (err) {
@@ -1087,6 +1118,7 @@ export function useNotes(
                 });
                 // A note window restores its ASSIGNED note, not the (shared) last-active pointer.
                 const restoreId = initialNoteId ?? meta.active;
+                diskActiveRef.current = meta.active;
                 let loaded: Note | null = null;
                 if (restoreId) {
                     try {
@@ -1187,12 +1219,15 @@ export function useNotes(
             void getCurrentWindow()
                 .onCloseRequested(async (event) => {
                     await flushMetadata();
-                    await flush();
+                    const unresolved = await flush();
                     // The MAIN window is never destroyed — the Rust shell hides it on close (macOS
                     // convention), so stop the JS wrapper from destroying it after this handler.
-                    // Workspace (ws-N) windows fall through: the wrapper destroys them once the
-                    // flush above has landed — exactly the flush-then-close ordering we want.
-                    if (isMainWindow()) event.preventDefault();
+                    // Workspace (ws-N) and note (note-N) windows fall through: the wrapper
+                    // destroys them once the flush above has landed — UNLESS the flush could NOT
+                    // land the edit (an unresolved conflict re-queued it, `unresolved`);
+                    // destroying then would silently drop the edit, so keep the window (and its
+                    // conflict banner) alive for the user to resolve first.
+                    if (isMainWindow() || unresolved) event.preventDefault();
                 })
                 .then((fn) => {
                     if (disposed) fn();
diff --git a/src/hooks/useNotesStorage.ts b/src/hooks/useNotesStorage.ts
index 5189afb..dee0f3d 100644
--- a/src/hooks/useNotesStorage.ts
+++ b/src/hooks/useNotesStorage.ts
@@ -1,6 +1,6 @@
 import {useCallback, useEffect, useRef, useState} from 'react';
 
-import {isNoteWindow, isTauri} from '../isTauri';
+import {isMainWindow, isNoteWindow, isTauri} from '../isTauri';
 import {FileSystemNoteStore} from '../storage/fileSystemStore';
 import {IndexedDbNoteStore} from '../storage/indexedDbStore';
 import {TauriNoteStore} from '../storage/tauriStore';
@@ -411,9 +411,13 @@ export function useNotesStorage(): NotesStorage {
                 const opened = await openEntry(entry, {
                     seq,
                     isBootstrap: true,
-                    // A shell-assigned workspace was verified seconds ago by the window that
-                    // spawned this one — skip the probe so the new window paints sooner.
-                    skipProbe: assignment !== null,
+                    // A shell-assigned ws-/note- window's workspace was verified seconds ago by
+                    // the window that spawned it — skip the probe so the new window paints
+                    // sooner. NOT for the main window: its assignment is registered on every
+                    // in-place open and lives until the window is destroyed, so after a webview
+                    // reload (crash recovery, dev ⌘R) it can be hours stale — that path keeps
+                    // the timed liveness probe.
+                    skipProbe: assignment !== null && !isMainWindow(),
                 });
                 if (bail()) return;
                 // A restored entry that couldn't be opened but set no state itself (e.g. a
@@ -502,6 +506,19 @@ export function useNotesStorage(): NotesStorage {
             title: 'Choose your notes folder',
         });
         if (typeof selected !== 'string') return; // dismissed
+        // Probe the picked folder like every other tauri-fs open path: the new window's bootstrap
+        // SKIPS its own probe for shell-assigned workspaces on the premise the opener verified
+        // it — this is where that premise is made true. Probe BEFORE touching the registry, so a
+        // dead or endless (home-dir) pick never becomes the last-active launch pointer.
+        try {
+            await withTimeout(
+                new TauriNoteStore(selected).list(),
+                PROBE_TIMEOUT_MS,
+                'Folder probe',
+            );
+        } catch (err) {
+            throw new Error(probeFailureMessage(err, err instanceof TimeoutError));
+        }
         const entry: WorkspaceEntry = {
             id: workspaceIdForPath(selected),
             backend: 'tauri-fs',
@@ -611,21 +628,43 @@ export function useNotesStorage(): NotesStorage {
             // registry — first open creates it.
             if (!entry && id === 'indexeddb') entry = browserEntry();
             if (!entry) return false;
-            return openEntry(entry, {seq});
+            const opened = await openEntry(entry, {seq});
+            // The shell's note assignment is a one-shot for the workspace this window was
+            // created for: once the user explicitly switches the window somewhere else, drop it —
+            // otherwise a later switch BACK would re-apply the stale assignment and force the
+            // originally-assigned note open over the workspace's own last-active restore.
+            if (opened) setWindowNote(null);
+            return opened;
         },
         [beginOp, isStale, openEntry, refreshWorkspaces],
     );
 
-    const openInNewWindow = useCallback(async (id: string) => {
-        if (!isTauri) return;
-        const entry = entriesRef.current.find((candidate) => candidate.id === id);
-        if (!entry) return;
-        const {invoke} = await import('@tauri-apps/api/core');
-        await invoke('open_workspace_window', {
-            wsId: id,
-            title: `${displayName(entry)} — Gravity Notes`,
-        });
-    }, []);
+    const openInNewWindow = useCallback(
+        async (id: string) => {
+            if (!isTauri) return;
+            let entry = entriesRef.current.find((candidate) => candidate.id === id);
+            if (!entry) {
+                // This window's snapshot may be stale (another window may have just written the
+                // entry) — re-read before deciding.
+                await refreshWorkspaces();
+                entry = entriesRef.current.find((candidate) => candidate.id === id);
+            }
+            if (!entry) {
+                // Fail loudly instead of a silent no-op: this is also the ⌘0 (Main Window) path,
+                // and a forced open_workspace_window would only spawn a window whose bootstrap
+                // can't resolve the workspace from the registry (it would land on the gate).
+                throw new Error(
+                    'This workspace is no longer in the recents list — reopen its folder to restore it.',
+                );
+            }
+            const {invoke} = await import('@tauri-apps/api/core');
+            await invoke('open_workspace_window', {
+                wsId: id,
+                title: `${displayName(entry)} — Gravity Notes`,
+            });
+        },
+        [refreshWorkspaces],
+    );
 
     const openNoteInNewWindow = useCallback(async (noteId: string, title: string) => {
         if (!isTauri) return;

From 06ebdb29978510a197a089e70ccd98ca817f82c0 Mon Sep 17 00:00:00 2001
From: Gadzhi Gadzhiev <168296+resure@users.noreply.github.com>
Date: Sun, 5 Jul 2026 22:14:50 +0300
Subject: [PATCH 5/5] fix: address code-review follow-ups (M1/M3 + comment
 hardening)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

From an external review of the note-windows branch:

- M3 (blocking): unify the "open in new window" chord. Hoist isOpenInNewWindowChord
  to shortcuts.ts and use it in TopBar (recents + Open Folder…) and the ⌃R switcher,
  which previously gated on metaKey alone — so Ctrl-click/Ctrl↵ now works off macOS
  (Windows/Linux), matching the note-list rows.
- M1: notify the shell when a note is trashed or deleted (window_note_removed), the
  delete-path mirror of window_note_renamed — so a note window left showing an orphan
  stops answering per-note focus-if-open for a dead id. Pure core unit-tested.
- M2: cite the SDK header + verified macOS version for the hand-coded SF_DATALESS.
- N1/N3: document the notifyShellNoteRenamed ordering and that writeMetadataNow's
  diskActiveRef fallback is a load-time snapshot (best-effort, not authoritative).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CLAUDE.md                                  | 10 ++--
 src-tauri/src/lib.rs                       | 62 +++++++++++++++++++++-
 src/components/NoteList.tsx                | 15 +-----
 src/components/TopBar.tsx                  | 21 +++++---
 src/components/WorkspaceSwitcherDialog.tsx |  5 +-
 src/hooks/useNotes.ts                      | 24 ++++++++-
 src/shortcuts.ts                           | 17 ++++++
 7 files changed, 124 insertions(+), 30 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 11a2a6c..075b3ba 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -43,10 +43,12 @@ because reading one blocks on download; they list by name/mtime with empty previ
 single-note open still materializes), the folder ops, `reveal_path`, and the **window commands** — a
 label→workspace map plus a label→note map powering
 `window_workspace`/`set_window_workspace`/`focus_workspace_window`/`open_workspace_window` and
-`window_note`/`set_window_note`/`window_note_renamed`/`open_note_window`, plus `focus_main_window`
-(the ⌘0 fallback App invokes when no Workspace is mounted to listen). `window_note_renamed` re-keys
-note-window assignments when a rename/move changes a note's rel-path (`useNotes.rename`/`move` fire
-it, fire-and-forget), so per-note focus-if-open doesn't go stale and spawn duplicate windows. All
+`window_note`/`set_window_note`/`window_note_renamed`/`window_note_removed`/`open_note_window`, plus
+`focus_main_window` (the ⌘0 fallback App invokes when no Workspace is mounted to listen).
+`window_note_renamed` re-keys note-window assignments when a rename/move changes a note's rel-path,
+and `window_note_removed` drops them when a note is trashed/deleted (`useNotes.rename`/`move`/`trash`/
+`remove` fire them, fire-and-forget, scoped to the caller's workspace), so per-note focus-if-open
+doesn't go stale and spawn duplicate windows. All
 three focus-if-open paths `unminimize()` before `show()`+`set_focus()` — set_focus alone leaves a
 minimized window in the Dock. (`ws-N` and `note-N` windows are cloned from the main
 window's config; note windows are 760×640, cascade centered on the opener's monitor, get their
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 6aa4662..81d67f5 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -169,7 +169,10 @@ fn modified_ms(meta: &fs::Metadata) -> f64 {
 #[cfg(target_os = "macos")]
 fn is_dataless(meta: &fs::Metadata) -> bool {
     use std::os::macos::fs::MetadataExt;
-    // SF_DATALESS from <sys/stat.h> ("file is dataless object"); not exposed by libc consts.
+    // SF_DATALESS ("file is dataless object") from `<sys/stat.h>` — a super-user/system flag in the
+    // high half of `st_flags`, defined there as `0x40000000`. Hand-coded because libc doesn't expose
+    // it. Verified against the macOS 26.5 SDK header; if a future SDK ever moves it, the worst case
+    // is one blocking read of an evicted file (treated as local), not data loss. `st_flags()` is u32.
     const SF_DATALESS: u32 = 0x4000_0000;
     meta.st_flags() & SF_DATALESS != 0
 }
@@ -725,7 +728,9 @@ fn open_external(url: String) -> Result<(), String> {
 ///   the `Destroyed` window event.
 /// - `notes`: a note window's label → the note id (store rel-path) it shows. Assigned by
 ///   `open_note_window` before the page loads, kept current by the frontend's `set_window_note`
-///   (in-window navigation / rename / close), drained with `labels`. Powers per-note focus-if-open.
+///   (in-window navigation / close) plus `window_note_renamed` / `window_note_removed` (a rename,
+///   move, trash, or delete from ANOTHER window in the same workspace re-keys or drops the entry),
+///   drained with `labels`. Powers per-note focus-if-open.
 /// - `pending`: workspace ids (or `ws\u{1f}note` composite keys, see `note_pending_key`) whose
 ///   window is currently being built. During the build gap the window isn't yet resolvable via
 ///   `get_webview_window`, so without this marker a second open for the same target would treat
@@ -1089,6 +1094,39 @@ fn remap_note_windows(
     }
 }
 
+/// Drop note-window assignments for a note that was trashed or permanently deleted (rel-path
+/// `note_id`) in the CALLER's workspace — the delete-path mirror of `window_note_renamed`, keeping
+/// the `notes` map free of ids no longer openable. Without it, a note window left showing an
+/// orphaned note (trashed from another window) would keep answering per-note focus-if-open for a
+/// dead id — e.g. a later note of the same name would focus the orphan instead of opening fresh.
+/// Workspace-scoped (the delete ran in the caller's window), so the same rel-path in another
+/// workspace is untouched.
+#[tauri::command]
+fn window_note_removed(
+    window: tauri::WebviewWindow,
+    state: tauri::State<'_, WindowWorkspaces>,
+    note_id: String,
+) {
+    let mut st = state.0.lock().unwrap();
+    let Some(ws_id) = st.labels.get(window.label()).cloned() else {
+        return;
+    };
+    let WindowState { labels, notes, .. } = &mut *st;
+    unassign_note_windows(labels, notes, &ws_id, &note_id);
+}
+
+/// Pure core of `window_note_removed`, split out for the unit test.
+fn unassign_note_windows(
+    labels: &HashMap<String, String>,
+    notes: &mut HashMap<String, String>,
+    ws_id: &str,
+    note_id: &str,
+) {
+    notes.retain(|label, note| {
+        !(note.as_str() == note_id && labels.get(label).map(String::as_str) == Some(ws_id))
+    });
+}
+
 /// macOS window chrome shared by the main window (at setup) and each workspace window: make the
 /// title bar tall with SYSTEM-positioned traffic lights, and paint the webview backdrop in the
 /// resolved theme so a fresh window doesn't flash white before the page background loads (the
@@ -1340,6 +1378,7 @@ pub fn run() {
             window_note,
             set_window_note,
             window_note_renamed,
+            window_note_removed,
             open_note_window,
             focus_main_window,
         ])
@@ -1821,4 +1860,23 @@ mod tests {
         remap_note_windows(&labels, &mut notes, "tauri:/a", "Missing.md", "Elsewhere.md");
         assert_eq!(notes.get("note-1").map(String::as_str), Some("New.md"));
     }
+
+    #[test]
+    fn note_delete_unassigns_matching_windows_in_the_same_workspace_only() {
+        let mut labels = HashMap::new();
+        labels.insert("note-1".to_string(), "tauri:/a".to_string());
+        labels.insert("note-2".to_string(), "tauri:/b".to_string());
+        let mut notes = HashMap::new();
+        notes.insert("note-1".to_string(), "Gone.md".to_string());
+        // Same rel-path in ANOTHER workspace — a delete in /a must not evict it.
+        notes.insert("note-2".to_string(), "Gone.md".to_string());
+
+        unassign_note_windows(&labels, &mut notes, "tauri:/a", "Gone.md");
+        assert!(!notes.contains_key("note-1")); // dropped
+        assert_eq!(notes.get("note-2").map(String::as_str), Some("Gone.md")); // other ws kept
+
+        // Deleting a note no window shows is a no-op.
+        unassign_note_windows(&labels, &mut notes, "tauri:/b", "Other.md");
+        assert_eq!(notes.get("note-2").map(String::as_str), Some("Gone.md"));
+    }
 }
diff --git a/src/components/NoteList.tsx b/src/components/NoteList.tsx
index e239e62..631449c 100644
--- a/src/components/NoteList.tsx
+++ b/src/components/NoteList.tsx
@@ -43,6 +43,7 @@ import {defaultRangeExtractor, useVirtualizer} from '@tanstack/react-virtual';
 
 import {useHeldValue} from '../hooks/useHeldValue';
 import {escapeRegExp, tokenizeQuery} from '../search';
+import {isOpenInNewWindowChord} from '../shortcuts';
 import {dirname, formatCrumb} from '../storage/noteText';
 import type {NoteMeta, SortMode} from '../storage/types';
 
@@ -153,20 +154,6 @@ function highlightTerms(text: string, terms: string[]): ReactNode {
     );
 }
 
-/**
- * ⌘/Ctrl with no other modifier — the open-in-new-window chord, on ↵ and on click alike
- * (see onOpenInNewWindow). On macOS a Ctrl+click never reaches the click handler (WebKit turns it
- * into the contextmenu event), so in practice the mouse path means ⌘-click.
- */
-function isOpenInNewWindowChord(event: {
-    metaKey: boolean;
-    ctrlKey: boolean;
-    shiftKey: boolean;
-    altKey: boolean;
-}): boolean {
-    return (event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey;
-}
-
 /** Compact list date: 24-hour time for today, otherwise `DD.MM.YY`. Exported for unit tests. */
 export function formatNoteDate(ts: number | undefined): string {
     if (!ts) return '';
diff --git a/src/components/TopBar.tsx b/src/components/TopBar.tsx
index 3dca5ba..8eee2a4 100644
--- a/src/components/TopBar.tsx
+++ b/src/components/TopBar.tsx
@@ -26,6 +26,7 @@ import {Button, DropdownMenu, Icon, TextInput} from '@gravity-ui/uikit';
 import type {SaveState} from '../hooks/useNotes';
 import type {WorkspaceInfo} from '../hooks/useNotesStorage';
 import type {NoteAppearance} from '../hooks/useSettings';
+import {isOpenInNewWindowChord} from '../shortcuts';
 import type {NoteMeta} from '../storage/types';
 
 import {NoteAppearancePopover} from './NoteAppearancePopover';
@@ -369,11 +370,15 @@ export function TopBar({
                         iconStart: <Icon data={ws.backend === 'indexeddb' ? Database : Folder} />,
                         selected: ws.id === activeWorkspaceId,
                         // The uikit action gets a React mouse event on click but a NATIVE
-                        // KeyboardEvent on Enter — both carry metaKey, which is all we need.
+                        // KeyboardEvent on Enter — both carry the modifier flags the shared chord
+                        // reads (⌘ on macOS, Ctrl elsewhere).
                         action: (event: ReactMouseEvent<HTMLElement> | KeyboardEvent) => {
                             if (ws.id === activeWorkspaceId) return;
-                            if (isDesktop && event.metaKey) onOpenWorkspaceInNewWindow(ws.id);
-                            else onOpenWorkspace(ws.id);
+                            if (isDesktop && isOpenInNewWindowChord(event)) {
+                                onOpenWorkspaceInNewWindow(ws.id);
+                            } else {
+                                onOpenWorkspace(ws.id);
+                            }
                         },
                     })),
                     [
@@ -390,10 +395,14 @@ export function TopBar({
                       {
                           text: 'Open Folder…',
                           iconStart: <Icon data={FolderOpen} />,
-                          // ⌘-click / ⌘↵ (desktop) opens the picked folder in its OWN window —
-                          // the same modifier convention as the recents above.
+                          // ⌘-click / ⌘↵ (desktop; Ctrl elsewhere) opens the picked folder in its
+                          // OWN window — the same shared chord as the recents above.
                           action: (event: ReactMouseEvent<HTMLElement> | KeyboardEvent) => {
-                              if (isDesktop && event.metaKey && onOpenFolderInNewWindow) {
+                              if (
+                                  isDesktop &&
+                                  isOpenInNewWindowChord(event) &&
+                                  onOpenFolderInNewWindow
+                              ) {
                                   onOpenFolderInNewWindow();
                               } else {
                                   onOpenFolder();
diff --git a/src/components/WorkspaceSwitcherDialog.tsx b/src/components/WorkspaceSwitcherDialog.tsx
index 26c04a4..1e7353b 100644
--- a/src/components/WorkspaceSwitcherDialog.tsx
+++ b/src/components/WorkspaceSwitcherDialog.tsx
@@ -5,6 +5,7 @@ import {Dialog, Icon, Text, TextInput} from '@gravity-ui/uikit';
 
 import {useListboxNav} from '../hooks/useListboxNav';
 import type {WorkspaceInfo} from '../hooks/useNotesStorage';
+import {isOpenInNewWindowChord} from '../shortcuts';
 
 import {highlightMatch} from './highlightMatch';
 
@@ -143,7 +144,7 @@ export function WorkspaceSwitcherDialog({
         items: entries,
         getKey: (row) => row.id,
         isDisabled: (row) => row.disabled,
-        onEnter: (index, event) => commit(entries[index], event.metaKey),
+        onEnter: (index, event) => commit(entries[index], isOpenInNewWindowChord(event)),
         onRemove: (index) => {
             const row = entries[index];
             if (row && !row.disabled && !row.synthesized && !row.openFolder) onRemove(row.id);
@@ -195,7 +196,7 @@ export function WorkspaceSwitcherDialog({
                 role="option"
                 aria-selected={active}
                 aria-disabled={row.disabled || undefined}
-                onClick={(event) => commit(row, event.metaKey)}
+                onClick={(event) => commit(row, isOpenInNewWindowChord(event))}
                 onMouseMove={() => {
                     if (!row.disabled && !active) setActiveIndex(index);
                 }}
diff --git a/src/hooks/useNotes.ts b/src/hooks/useNotes.ts
index 8add46d..07baedf 100644
--- a/src/hooks/useNotes.ts
+++ b/src/hooks/useNotes.ts
@@ -90,7 +90,9 @@ const FOCUS_REFRESH_MIN_GAP_MS = 2_000;
  * Tell the desktop shell a note's id (rel-path) changed, so any single-note WINDOW pinned to the
  * old id keeps answering per-note focus-if-open under the new one (without this, "open in new
  * window" for the renamed note would spawn a duplicate). Fire-and-forget: the shell map is an
- * optimization, and the web build has no shell at all.
+ * optimization, and the web build has no shell at all. Fired right after the in-memory rekey —
+ * the shell map is what focus-if-open reads, and the on-disk rename it reflects has already
+ * happened (the `store.rename`/`move` await completed before we get here).
  */
 function notifyShellNoteRenamed(oldId: string, newId: string): void {
     if (!isTauri) return;
@@ -99,6 +101,18 @@ function notifyShellNoteRenamed(oldId: string, newId: string): void {
         .catch(() => {});
 }
 
+/**
+ * The delete-path twin of {@link notifyShellNoteRenamed}: tell the shell a note id is gone
+ * (trashed or permanently deleted) so its note-window map entry is dropped — else a note window
+ * left showing the orphan would keep answering focus-if-open for a dead id. Fire-and-forget.
+ */
+function notifyShellNoteRemoved(id: string): void {
+    if (!isTauri) return;
+    void import('@tauri-apps/api/core')
+        .then(({invoke}) => invoke('window_note_removed', {noteId: id}))
+        .catch(() => {});
+}
+
 /** A detected external change to the open note. */
 export interface NoteConflict {
     id: string;
@@ -277,7 +291,11 @@ export function useNotes(
                 // (the conflict checks key on it), but the on-disk pointer belongs to the main
                 // window's next-launch restore — substitute the live disk value at this write
                 // boundary so no note-window persist (pin, appearance, navigation, close…) can
-                // hijack it. The load-time snapshot backstops a failed disk read.
+                // hijack it. The `diskActiveRef` fallback is the LOAD-TIME snapshot (never
+                // refreshed), so it can be stale for a long-lived window — but it's only reached
+                // when a fresh read fails, and "keep roughly what was last on disk" beats
+                // clobbering the pointer with this window's note; it's a best-effort guard, not
+                // an authoritative value.
                 const active = await store
                     .readMetadata()
                     .then((disk) => disk.active)
@@ -855,6 +873,7 @@ export function useNotes(
             await flush();
             try {
                 await store.remove(id);
+                notifyShellNoteRemoved(id); // drop any note-window focus-if-open entry for it
                 if (pendingRef.current?.id === id) pendingRef.current = null;
                 const wasActive = metadataRef.current.active === id;
                 await persistMetadata(withRemoved(metadataRef.current, id));
@@ -908,6 +927,7 @@ export function useNotes(
                 const icon = metadataRef.current.icons[id];
                 const appearance = metadataRef.current.appearances[id];
                 const trashId = await store.trash(id);
+                notifyShellNoteRemoved(id); // the live id is gone — drop its note-window entry
                 if (pendingRef.current?.id === id) pendingRef.current = null;
                 const wasActive = metadataRef.current.active === id;
                 await persistMetadata(
diff --git a/src/shortcuts.ts b/src/shortcuts.ts
index f22fe99..37cb78a 100644
--- a/src/shortcuts.ts
+++ b/src/shortcuts.ts
@@ -20,6 +20,23 @@ export type ShortcutAction =
     | 'deleteSelected'
     | 'openWorkspaces';
 
+/**
+ * The "open in a new window" chord — ⌘ (macOS) or Ctrl (Windows/Linux), no other modifier — on ↵
+ * and on click alike. Shared by the note-list rows (⌘↵ / ⌘-click), the orb menu's recents +
+ * "Open Folder…" items, and the ⌃R switcher, so the convention stays identical across every
+ * surface (and Ctrl works off macOS). Shift is excluded so ⌘⇧↵ (the global new-note chord) still
+ * bubbles. Structurally typed on the four modifier flags so it takes a React OR native mouse/
+ * keyboard event without importing React's types.
+ */
+export function isOpenInNewWindowChord(event: {
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+}): boolean {
+    return (event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey;
+}
+
 /** How a globally-handled shortcut maps to a key event. */
 export interface GlobalBinding {
     /**