feat: add filter pills (Open/Archived/Trashed) to All Notes view

Reuses the existing FilterPills component and sub-filter mechanism from
sectionGroup views. Adds countAllByFilter helper for counting across all
entry types and extends filterByKind to support subFilter for the 'all'
filter. Bulk actions automatically adapt based on active pill. Switching
pills resets multi-selection.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

docs/ABSTRACTIONS.md

@@ -342,6 +342,10 @@ interface PulseCommit {
 - Configurable interval (from app settings: `auto_pull_interval_minutes`)
 - Pulls on interval, pushes after commits
 - Detects merge conflicts → opens `ConflictResolverModal`
+- Tracks remote status (branch, ahead/behind via `git_remote_status`)
+- Handles push rejection (divergence) → sets `pull_required` status
+- `pullAndPush()`: pulls then auto-pushes for divergence recovery
+- `ConflictNoteBanner`: inline banner in editor for conflicted notes (Keep mine / Keep theirs)
 
 ### Frontend Integration
 
@@ -350,6 +354,9 @@ interface PulseCommit {
 - **Git history**: Shown in Inspector panel for active note
 - **Commit dialog**: Triggered from sidebar or Cmd+K
 - **Pulse view**: Activity feed when Pulse filter is selected
+- **Pull command**: Cmd+K → "Pull from Remote", also in Vault menu
+- **Git status popup**: Click sync badge → shows branch, ahead/behind, Pull button
+- **Conflict banner**: Inline banner in editor with Keep mine / Keep theirs for conflicted notes
 
 ## BlockNote Customization
 
@@ -532,7 +539,7 @@ Managed by `useIndexing` hook:
 
 ### Vault Config
 
-Per-vault settings stored in `config/ui.config.md`:
+Per-vault settings stored in `ui.config.md` at vault root:
 - Editable as a normal note (YAML frontmatter)
 - Managed by `useVaultConfig` hook and `vaultConfigStore`
 - Settings: zoom, view mode, tag colors, status colors, property display modes

docs/ARCHITECTURE.md

@@ -164,6 +164,24 @@ flowchart TD
 
 Panels are separated by `ResizeHandle` components that support drag-to-resize.
 
+## Multi-Window (Note Windows)
+
+Notes can be opened in separate Tauri windows for focused editing. Secondary windows show only the editor panel (no sidebar, no note list).
+
+**Triggers:**
+- `Cmd+Shift+Click` on any note in the note list or sidebar
+- `Cmd+K` → "Open in New Window" (command palette, requires active note)
+- `Cmd+Shift+O` keyboard shortcut
+- Note → "Open in New Window" menu bar item
+
+**Architecture:**
+- `openNoteInNewWindow()` (`src/utils/openNoteWindow.ts`) creates a new `WebviewWindow` via the Tauri v2 JS API with URL query params (`?window=note&path=...&vault=...&title=...`)
+- `main.tsx` checks `isNoteWindow()` at boot to route between `App` (main window) and `NoteWindow` (secondary window)
+- `NoteWindow` (`src/NoteWindow.tsx`) is a minimal shell that loads vault entries, fetches note content, applies the theme, and renders a single `Editor` instance
+- Each window has its own auto-save via `useEditorSaveWithLinks` (same 500ms debounce, same Rust `save_note_content` command)
+- Secondary windows are sized 800×700 with overlay title bar
+- Capabilities config (`src-tauri/capabilities/default.json`) grants permissions to both `main` and `note-*` window labels
+
 ## AI System
 
 Laputa has two AI interfaces with distinct architectures:
@@ -448,7 +466,7 @@ Managed by `useVaultSwitcher` hook. Switching vaults closes all tabs and resets
 
 ### Vault Config
 
-Per-vault UI settings stored in `config/ui.config.md` (YAML frontmatter in a markdown note):
+Per-vault UI settings stored in `ui.config.md` at vault root (YAML frontmatter in a markdown note):
 - `zoom`: Float zoom level (0.8–1.5)
 - `view_mode`: "all" | "editor-list" | "editor-only"
 - `editor_mode`: "raw" | "preview" (persists across tab switches and sessions)
@@ -547,17 +565,34 @@ flowchart LR
 flowchart TD
     AS["useAutoSync\n(configurable interval)"] --> PULL["invoke('git_pull')"]
     PULL --> PC{Result?}
-    PC -->|Conflicts| CM["ConflictResolverModal"]
+    PC -->|Conflicts| CM["ConflictResolverModal\nor ConflictNoteBanner"]
     PC -->|Fast-forward| RV["reload vault"]
     PC -->|Up to date| DONE["idle"]
 
-    AS --> PUSH["invoke('git_push')"]
-
     MAN["Manual commit\n(CommitDialog)"] --> GC["invoke('git_commit', message)"]
     GC --> GP["invoke('git_push')"]
-    GP --> RM["Reload modified files"]
+    GP --> PR{Push result?}
+    PR -->|ok| RM["Reload modified files"]
+    PR -->|rejected| DIV["syncStatus = pull_required"]
+    DIV -->|User clicks badge| PAP["pullAndPush()"]
+    PAP --> PULL2["invoke('git_pull')"]
+    PULL2 --> GP2["invoke('git_push')"]
+    GP2 --> RM
+
+    CMD["Cmd+K → Pull\nor Menu → Pull"] --> PULL
+    STATUS["Click sync badge"] --> POPUP["GitStatusPopup\n(branch, ahead/behind)"]
 ```
 
+#### Sync States
+
+| State | Indicator | Color | Trigger |
+|-------|-----------|-------|---------|
+| `idle` | Synced / Synced Xm ago | green | Successful sync |
+| `syncing` | Syncing... | blue | Pull/push in progress |
+| `pull_required` | Pull required | orange | Push rejected (divergence) |
+| `conflict` | Conflict | orange | Merge conflicts detected |
+| `error` | Sync failed | grey | Network/auth error |
+
 ## Vault Module Structure
 
 The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
@@ -631,6 +666,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `git_commit` | Stage all + commit |
 | `git_pull` | Pull from remote |
 | `git_push` | Push to remote |
+| `git_remote_status` | Get branch name + ahead/behind counts |
 | `git_resolve_conflict` | Resolve a merge conflict |
 | `git_commit_conflict_resolution` | Commit conflict resolution |
 | `get_file_history` | Last N commits for a file |

src-tauri/capabilities/default.json

@@ -3,11 +3,16 @@
   "identifier": "default",
   "description": "enables the default permissions",
   "windows": [
-    "main"
+    "main",
+    "note-*"
   ],
   "permissions": [
     "core:default",
+    "core:window:allow-create",
     "core:window:allow-start-dragging",
+    "core:window:allow-close",
+    "core:window:allow-set-title",
+    "core:webview:allow-create-webview-window",
     "dialog:default",
     "updater:default",
     "process:default",

src-tauri/src/commands.rs

@@ -6,7 +6,8 @@ use crate::claude_cli::{
 };
 use crate::frontmatter::FrontmatterValue;
 use crate::git::{
-    GitCommit, GitPullResult, GitPushResult, LastCommitInfo, ModifiedFile, PulseCommit,
+    GitCommit, GitPullResult, GitPushResult, GitRemoteStatus, LastCommitInfo, ModifiedFile,
+    PulseCommit,
 };
 use crate::github::{DeviceFlowPollResult, DeviceFlowStart, GitHubUser, GithubRepo};
 use crate::indexing::{IndexStatus, IndexingProgress};
@@ -154,10 +155,14 @@ pub fn get_default_vault_path() -> Result<String, String> {
 }
 
 #[tauri::command]
-pub fn reload_vault(path: String) -> Result<Vec<VaultEntry>, String> {
-    let path = expand_tilde(&path);
-    vault::invalidate_cache(std::path::Path::new(path.as_ref()));
-    vault::scan_vault_cached(std::path::Path::new(path.as_ref()))
+pub async fn reload_vault(path: String) -> Result<Vec<VaultEntry>, String> {
+    let path = expand_tilde(&path).into_owned();
+    tokio::task::spawn_blocking(move || {
+        vault::invalidate_cache(std::path::Path::new(&path));
+        vault::scan_vault_cached(std::path::Path::new(&path))
+    })
+    .await
+    .map_err(|e| format!("Task panicked: {e}"))?
 }
 
 #[tauri::command]
@@ -292,9 +297,11 @@ pub fn get_last_commit_info(vault_path: String) -> Result<Option<LastCommitInfo>
 }
 
 #[tauri::command]
-pub fn git_pull(vault_path: String) -> Result<GitPullResult, String> {
-    let vault_path = expand_tilde(&vault_path);
-    git::git_pull(&vault_path)
+pub async fn git_pull(vault_path: String) -> Result<GitPullResult, String> {
+    let vault_path = expand_tilde(&vault_path).into_owned();
+    tokio::task::spawn_blocking(move || git::git_pull(&vault_path))
+        .await
+        .map_err(|e| format!("Task panicked: {e}"))?
 }
 
 #[tauri::command]
@@ -326,9 +333,19 @@ pub fn git_commit_conflict_resolution(vault_path: String) -> Result<String, Stri
 }
 
 #[tauri::command]
-pub fn git_push(vault_path: String) -> Result<GitPushResult, String> {
-    let vault_path = expand_tilde(&vault_path);
-    git::git_push(&vault_path)
+pub async fn git_push(vault_path: String) -> Result<GitPushResult, String> {
+    let vault_path = expand_tilde(&vault_path).into_owned();
+    tokio::task::spawn_blocking(move || git::git_push(&vault_path))
+        .await
+        .map_err(|e| format!("Task panicked: {e}"))?
+}
+
+#[tauri::command]
+pub async fn git_remote_status(vault_path: String) -> Result<GitRemoteStatus, String> {
+    let vault_path = expand_tilde(&vault_path).into_owned();
+    tokio::task::spawn_blocking(move || git::git_remote_status(&vault_path))
+        .await
+        .map_err(|e| format!("Task panicked: {e}"))?
 }
 
 // ── GitHub commands ─────────────────────────────────────────────────────────
@@ -571,6 +588,8 @@ pub fn repair_vault(vault_path: String) -> Result<String, String> {
     // Migrate legacy theme/ directory to root, then repair themes
     theme::migrate_theme_dir_to_root(&vault_path);
     theme::restore_default_themes(&vault_path)?;
+    // Migrate legacy config/ui.config.md → root ui.config.md
+    vault_config::migrate_ui_config_to_root(&vault_path);
     // Repair config files (AGENTS.md at root, config.md type def)
     vault::repair_config_files(&vault_path)?;
     // Ensure .gitignore with sensible defaults exists
@@ -787,7 +806,9 @@ mod tests {
         std::fs::write(vault.join("note.md"), "---\nTrashed: true\n---\n# Note\n").unwrap();
 
         // reload_vault must return the updated trashed state
-        let fresh = reload_vault(vault.to_str().unwrap().to_string()).unwrap();
+        let vault_str = vault.to_str().unwrap();
+        vault::invalidate_cache(std::path::Path::new(vault_str));
+        let fresh = vault::scan_vault_cached(std::path::Path::new(vault_str)).unwrap();
         assert!(
             fresh[0].trashed,
             "reload_vault must reflect disk state after trashing"

src-tauri/src/git/mod.rs

@@ -15,7 +15,10 @@ pub use conflict::{
 };
 pub use history::{get_file_diff, get_file_diff_at_commit, get_file_history};
 pub use pulse::{get_last_commit_info, get_vault_pulse, LastCommitInfo, PulseCommit, PulseFile};
-pub use remote::{git_pull, git_push, has_remote, GitPullResult, GitPushResult};
+pub use remote::{
+    git_pull, git_push, git_remote_status, has_remote, GitPullResult, GitPushResult,
+    GitRemoteStatus,
+};
 pub use status::{get_modified_files, ModifiedFile};
 
 use serde::Serialize;

src-tauri/src/git/remote.rs

@@ -110,6 +110,75 @@ fn parse_updated_files(stdout: &str) -> Vec<String> {
         .collect()
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct GitRemoteStatus {
+    pub branch: String,
+    pub ahead: u32,
+    pub behind: u32,
+    #[serde(rename = "hasRemote")]
+    pub has_remote: bool,
+}
+
+/// Get the current branch name, and how many commits ahead/behind the upstream.
+pub fn git_remote_status(vault_path: &str) -> Result<GitRemoteStatus, String> {
+    let vault = Path::new(vault_path);
+
+    if !has_remote(vault_path)? {
+        let branch = current_branch(vault)?;
+        return Ok(GitRemoteStatus {
+            branch,
+            ahead: 0,
+            behind: 0,
+            has_remote: false,
+        });
+    }
+
+    // Fetch latest remote refs (silent, best-effort)
+    let _ = Command::new("git")
+        .args(["fetch", "--quiet"])
+        .current_dir(vault)
+        .output();
+
+    let branch = current_branch(vault)?;
+
+    let output = Command::new("git")
+        .args(["rev-list", "--left-right", "--count", "HEAD...@{upstream}"])
+        .current_dir(vault)
+        .output()
+        .map_err(|e| format!("Failed to run git rev-list: {}", e))?;
+
+    if !output.status.success() {
+        // No upstream set — report 0/0
+        return Ok(GitRemoteStatus {
+            branch,
+            ahead: 0,
+            behind: 0,
+            has_remote: true,
+        });
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let parts: Vec<&str> = stdout.trim().split('\t').collect();
+    let ahead = parts.first().and_then(|s| s.parse().ok()).unwrap_or(0);
+    let behind = parts.get(1).and_then(|s| s.parse().ok()).unwrap_or(0);
+
+    Ok(GitRemoteStatus {
+        branch,
+        ahead,
+        behind,
+        has_remote: true,
+    })
+}
+
+fn current_branch(vault: &Path) -> Result<String, String> {
+    let output = Command::new("git")
+        .args(["branch", "--show-current"])
+        .current_dir(vault)
+        .output()
+        .map_err(|e| format!("Failed to get branch: {}", e))?;
+    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct GitPushResult {
     pub status: String, // "ok" | "rejected" | "auth_error" | "network_error" | "error"
@@ -391,6 +460,90 @@ hint: have locally."#;
         assert!(result.message.contains("Pull first"));
     }
 
+    #[test]
+    fn test_git_remote_status_no_remote() {
+        let dir = setup_git_repo();
+        let vault = dir.path();
+        let vp = vault.to_str().unwrap();
+
+        fs::write(vault.join("note.md"), "# Note\n").unwrap();
+        git_commit(vp, "initial").unwrap();
+
+        let status = git_remote_status(vp).unwrap();
+        assert!(!status.has_remote);
+        assert_eq!(status.ahead, 0);
+        assert_eq!(status.behind, 0);
+    }
+
+    #[test]
+    fn test_git_remote_status_up_to_date() {
+        let (_bare, clone_a, _clone_b) = setup_remote_pair();
+        let vp_a = clone_a.path().to_str().unwrap();
+
+        fs::write(clone_a.path().join("note.md"), "# Note\n").unwrap();
+        git_commit(vp_a, "initial").unwrap();
+        git_push(vp_a).unwrap();
+
+        let status = git_remote_status(vp_a).unwrap();
+        assert!(status.has_remote);
+        assert_eq!(status.ahead, 0);
+        assert_eq!(status.behind, 0);
+    }
+
+    #[test]
+    fn test_git_remote_status_ahead() {
+        let (_bare, clone_a, _clone_b) = setup_remote_pair();
+        let vp_a = clone_a.path().to_str().unwrap();
+
+        fs::write(clone_a.path().join("note.md"), "# Note\n").unwrap();
+        git_commit(vp_a, "initial").unwrap();
+        git_push(vp_a).unwrap();
+
+        // Make a new commit without pushing
+        fs::write(clone_a.path().join("note.md"), "# Updated\n").unwrap();
+        git_commit(vp_a, "update").unwrap();
+
+        let status = git_remote_status(vp_a).unwrap();
+        assert_eq!(status.ahead, 1);
+        assert_eq!(status.behind, 0);
+    }
+
+    #[test]
+    fn test_git_remote_status_behind() {
+        let (_bare, clone_a, clone_b) = setup_remote_pair();
+        let vp_a = clone_a.path().to_str().unwrap();
+        let vp_b = clone_b.path().to_str().unwrap();
+
+        fs::write(clone_a.path().join("note.md"), "# Note\n").unwrap();
+        git_commit(vp_a, "initial").unwrap();
+        git_push(vp_a).unwrap();
+
+        git_pull(vp_b).unwrap();
+        fs::write(clone_b.path().join("note.md"), "# B update\n").unwrap();
+        git_commit(vp_b, "from B").unwrap();
+        git_push(vp_b).unwrap();
+
+        // A is now behind by 1
+        let status = git_remote_status(vp_a).unwrap();
+        assert_eq!(status.behind, 1);
+        assert_eq!(status.ahead, 0);
+    }
+
+    #[test]
+    fn test_git_remote_status_serialization() {
+        let status = GitRemoteStatus {
+            branch: "main".to_string(),
+            ahead: 2,
+            behind: 1,
+            has_remote: true,
+        };
+        let json = serde_json::to_string(&status).unwrap();
+        assert!(json.contains("\"hasRemote\""));
+        let parsed: GitRemoteStatus = serde_json::from_str(&json).unwrap();
+        assert_eq!(parsed.branch, "main");
+        assert_eq!(parsed.ahead, 2);
+    }
+
     #[test]
     fn test_git_pull_result_serialization() {
         let result = GitPullResult {

src-tauri/src/lib.rs

@@ -44,6 +44,8 @@ fn run_startup_tasks() {
         "Migrated is_a to type on startup",
         vault::migrate_is_a_to_type(vp_str),
     );
+    // Migrate legacy config/ui.config.md → root ui.config.md
+    vault_config::migrate_ui_config_to_root(vp_str);
     log_startup_result(
         "Migrated hidden_sections to visible property",
         vault_config::migrate_hidden_sections_to_visible(vp_str),
@@ -130,6 +132,7 @@ pub fn run() {
             commands::get_last_commit_info,
             commands::git_pull,
             commands::git_push,
+            commands::git_remote_status,
             commands::get_conflict_files,
             commands::get_conflict_mode,
             commands::git_resolve_conflict,

src-tauri/src/menu.rs

@@ -36,10 +36,12 @@ const GO_ALL_NOTES: &str = "go-all-notes";
 const GO_ARCHIVED: &str = "go-archived";
 const GO_TRASH: &str = "go-trash";
 const GO_CHANGES: &str = "go-changes";
+const GO_INBOX: &str = "go-inbox";
 
 const NOTE_ARCHIVE: &str = "note-archive";
 const NOTE_TRASH: &str = "note-trash";
 const NOTE_EMPTY_TRASH: &str = "note-empty-trash";
+const NOTE_OPEN_IN_NEW_WINDOW: &str = "note-open-in-new-window";
 
 const VAULT_OPEN: &str = "vault-open";
 const VAULT_REMOVE: &str = "vault-remove";
@@ -47,6 +49,7 @@ const VAULT_RESTORE_GETTING_STARTED: &str = "vault-restore-getting-started";
 const VAULT_NEW_THEME: &str = "vault-new-theme";
 const VAULT_RESTORE_DEFAULT_THEMES: &str = "vault-restore-default-themes";
 const VAULT_COMMIT_PUSH: &str = "vault-commit-push";
+const VAULT_PULL: &str = "vault-pull";
 const VAULT_RESOLVE_CONFLICTS: &str = "vault-resolve-conflicts";
 const VAULT_VIEW_CHANGES: &str = "vault-view-changes";
 const VAULT_INSTALL_MCP: &str = "vault-install-mcp";
@@ -86,12 +89,14 @@ const CUSTOM_IDS: &[&str] = &[
     NOTE_ARCHIVE,
     NOTE_TRASH,
     NOTE_EMPTY_TRASH,
+    NOTE_OPEN_IN_NEW_WINDOW,
     VAULT_OPEN,
     VAULT_REMOVE,
     VAULT_RESTORE_GETTING_STARTED,
     VAULT_NEW_THEME,
     VAULT_RESTORE_DEFAULT_THEMES,
     VAULT_COMMIT_PUSH,
+    VAULT_PULL,
     VAULT_RESOLVE_CONFLICTS,
     VAULT_VIEW_CHANGES,
     VAULT_INSTALL_MCP,
@@ -109,6 +114,7 @@ const NOTE_DEPENDENT_IDS: &[&str] = &[
     EDIT_TOGGLE_RAW_EDITOR,
     EDIT_TOGGLE_DIFF,
     VIEW_TOGGLE_BACKLINKS,
+    NOTE_OPEN_IN_NEW_WINDOW,
 ];
 
 /// IDs of menu items that depend on having uncommitted changes.
@@ -267,6 +273,7 @@ fn build_go_menu(app: &App) -> MenuResult {
         .build(app)?;
     let trash = MenuItemBuilder::new("Trash").id(GO_TRASH).build(app)?;
     let changes = MenuItemBuilder::new("Changes").id(GO_CHANGES).build(app)?;
+    let inbox = MenuItemBuilder::new("Inbox").id(GO_INBOX).build(app)?;
     let go_back = MenuItemBuilder::new("Go Back")
         .id(VIEW_GO_BACK)
         .accelerator("CmdOrCtrl+[")
@@ -281,6 +288,7 @@ fn build_go_menu(app: &App) -> MenuResult {
         .item(&archived)
         .item(&trash)
         .item(&changes)
+        .item(&inbox)
         .separator()
         .item(&go_back)
         .item(&go_forward)
@@ -299,6 +307,10 @@ fn build_note_menu(app: &App) -> MenuResult {
     let empty_trash = MenuItemBuilder::new("Empty Trash…")
         .id(NOTE_EMPTY_TRASH)
         .build(app)?;
+    let open_new_window = MenuItemBuilder::new("Open in New Window")
+        .id(NOTE_OPEN_IN_NEW_WINDOW)
+        .accelerator("CmdOrCtrl+Shift+O")
+        .build(app)?;
     let toggle_raw_editor = MenuItemBuilder::new("Toggle Raw Editor")
         .id(EDIT_TOGGLE_RAW_EDITOR)
         .accelerator("CmdOrCtrl+\\")
@@ -316,6 +328,8 @@ fn build_note_menu(app: &App) -> MenuResult {
         .item(&trash_note)
         .item(&empty_trash)
         .separator()
+        .item(&open_new_window)
+        .separator()
         .item(&toggle_raw_editor)
         .item(&toggle_ai_chat)
         .item(&toggle_backlinks)
@@ -341,6 +355,9 @@ fn build_vault_menu(app: &App) -> MenuResult {
     let commit_push = MenuItemBuilder::new("Commit & Push")
         .id(VAULT_COMMIT_PUSH)
         .build(app)?;
+    let pull = MenuItemBuilder::new("Pull from Remote")
+        .id(VAULT_PULL)
+        .build(app)?;
     let resolve_conflicts = MenuItemBuilder::new("Resolve Conflicts")
         .id(VAULT_RESOLVE_CONFLICTS)
         .enabled(false)
@@ -370,6 +387,7 @@ fn build_vault_menu(app: &App) -> MenuResult {
         .item(&restore_default_themes)
         .separator()
         .item(&commit_push)
+        .item(&pull)
         .item(&resolve_conflicts)
         .item(&view_changes)
         .separator()
@@ -485,12 +503,14 @@ mod tests {
             NOTE_ARCHIVE,
             NOTE_TRASH,
             NOTE_EMPTY_TRASH,
+            NOTE_OPEN_IN_NEW_WINDOW,
             VAULT_OPEN,
             VAULT_REMOVE,
             VAULT_RESTORE_GETTING_STARTED,
             VAULT_NEW_THEME,
             VAULT_RESTORE_DEFAULT_THEMES,
             VAULT_COMMIT_PUSH,
+            VAULT_PULL,
             VAULT_RESOLVE_CONFLICTS,
             VAULT_VIEW_CHANGES,
             VAULT_INSTALL_MCP,

src-tauri/src/vault/mod_tests.rs

@@ -486,6 +486,79 @@ References:
     );
 }
 
+// --- large relationship array (regression: No Code note with 32 Notes) ---
+
+#[test]
+fn test_parse_large_notes_relationship_array() {
+    let dir = TempDir::new().unwrap();
+    let content = r#"---
+type: Topic
+Referred by Data:
+  - "[[michele-sampieri|Michele Sampieri]]"
+  - "[[varun-anand|Varun Anand]]"
+Belongs to:
+  - "[[engineering|Engineering]]"
+aliases:
+  - No Code
+Notes:
+  - "[[8020-we-help-companies-move-faster-without-code|8020 | We help companies move faster without code.]]"
+  - "[[airdev-build-hub|Airdev Build Hub]]"
+  - "[[airdev-leader-in-bubble-and-no-code-development|AirDev | Leader in Bubble and No-Code Development]]"
+  - "[[budibase-internal-tools-made-easy|Budibase - Internal tools made easy]]"
+  - "[[bullet-launch-bubble-boilerplate|Bullet Launch Bubble Boilerplate]]"
+  - "[[canvas-base-template-for-bubble|Canvas • Base Template for Bubble]]"
+  - "[[chameleon-microsurveys|Chameleon | Microsurveys]]"
+  - "[[felt-the-best-way-to-make-maps-on-the-internet|Felt – The best way to make maps on the internet]]"
+  - "[[flutterflow-build-native-apps-visually|FlutterFlow | Build Native Apps Visually]]"
+  - "[[framer-ai-generate-and-publish-your-site-with-ai-in-seconds|Framer AI — Generate and publish your site with AI in seconds.]]"
+  - "[[jumpstart-pro-the-best-ruby-on-rails-saas-template|Jumpstart Pro | The best Ruby on Rails SaaS Template]]"
+  - "[[mailparser-email-parser-software-workflow-automation|MailParser • Email Parser Software & Workflow Automation]]"
+  - "[[make-work-the-way-you-imagine|Make | Work the way you imagine]]"
+  - "[[michele-sampieri|Michele Sampieri]]"
+  - "[[n8nio-a-powerful-workflow-automation-tool|n8n.io - a powerful workflow automation tool]]"
+  - "[[n8nio-ai-workflow-automation-tool|n8n.io - AI workflow automation tool]]"
+  - "[[nocodey-find-best-nocoder|Nocodey • Find Best Nocoder]]"
+  - "[[outseta-software-for-subscription-start-ups|Outseta | Software for subscription start-ups]]"
+  - "[[payments-tax-subscriptions-for-software-companies-lemon-squeezy|Payments, tax & subscriptions for software companies • Lemon Squeezy]]"
+  - "[[retool-portals-custom-client-portal-software|Retool Portals • Custom Client Portal Software]]"
+  - "[[rise-of-the-no-code-economy-report-formstack|Rise of the No-Code Economy Report | Formstack]]"
+  - "[[scene-the-smart-way-to-build-websites|Scene • The smart way to build websites]]"
+  - "[[scrapingbee-the-best-web-scraping-api|ScrapingBee • the best web scraping API]]"
+  - "[[softr-build-a-website-web-app-or-portal-on-airtable-without-code|Softr | Build a website, web app or portal on Airtable without code]]"
+  - "[[superblocks-build-modern-internal-apps-in-days-not-months|Superblocks • Build modern internal apps in days, not months]]"
+  - "[[superwall-quickly-deploy-paywalls|Superwall • Quickly deploy paywalls]]"
+  - "[[tails-tailwind-css-page-creator|Tails | Tailwind CSS Page Creator]]"
+  - "[[the-open-source-firebase-alternative-supabase|The Open Source Firebase Alternative | Supabase]]"
+  - "[[varun-anand|Varun Anand]]"
+  - "[[xano-the-fastest-no-code-backend-development-platform|Xano - The Fastest No Code Backend Development Platform]]"
+  - "[[directus-open-data-platform-for-headless-content-management|{'Directus': 'Open Data Platform for Headless Content Management'}]]"
+  - "[[framer-design-beautiful-websites-in-minutes|{'Framer': 'Design beautiful websites in minutes'}]]"
+title: No Code
+---
+# No Code
+"#;
+    create_test_file(dir.path(), "no-code.md", content);
+    let entry = parse_md_file(&dir.path().join("no-code.md")).unwrap();
+
+    let notes = entry
+        .relationships
+        .get("Notes")
+        .expect("Notes relationship should exist");
+    assert_eq!(notes.len(), 32, "All 32 Notes entries should be parsed");
+
+    let referred = entry
+        .relationships
+        .get("Referred by Data")
+        .expect("Referred by Data should exist");
+    assert_eq!(referred.len(), 2);
+
+    let belongs = entry
+        .relationships
+        .get("Belongs to")
+        .expect("Belongs to should exist");
+    assert_eq!(belongs.len(), 1);
+}
+
 // --- type from frontmatter only (no folder inference) ---
 
 #[test]

src-tauri/src/vault/rename.rs

@@ -28,32 +28,6 @@ pub(super) fn title_to_slug(title: &str) -> String {
         .join("-")
 }
 
-/// Update the first H1 heading in markdown content to a new title.
-fn update_h1_title(content: &str, new_title: &str) -> String {
-    let has_h1 = content.lines().any(|l| l.trim().starts_with("# "));
-    if !has_h1 {
-        return content.to_string();
-    }
-
-    let result: Vec<String> = content
-        .lines()
-        .map(|l| {
-            if l.trim().starts_with("# ") {
-                format!("# {}", new_title)
-            } else {
-                l.to_string()
-            }
-        })
-        .collect();
-
-    let joined = result.join("\n");
-    if content.ends_with('\n') && !joined.ends_with('\n') {
-        format!("{}\n", joined)
-    } else {
-        joined
-    }
-}
-
 /// Build a regex that matches wiki links referencing old title or path stem.
 fn build_wikilink_pattern(old_title: &str, old_path_stem: &str) -> Option<Regex> {
     let pattern_str = format!(
@@ -148,15 +122,16 @@ fn extract_fm_title_value(content: &str) -> Option<String> {
     None
 }
 
-/// Update H1 and the `title:` frontmatter field in content.
+/// Update the `title:` frontmatter field in content.
 /// Always writes `title` to frontmatter (creates it if absent).
+/// H1 headings are body content and are NOT modified — the title source
+/// of truth is frontmatter `title:` → filename, never H1.
 fn update_note_title_in_content(content: &str, new_title: &str) -> String {
-    let mut updated = update_h1_title(content, new_title);
     let value = FrontmatterValue::String(new_title.to_string());
-    if let Ok(c) = update_frontmatter_content(&updated, "title", Some(value)) {
-        updated = c;
+    match update_frontmatter_content(content, "title", Some(value)) {
+        Ok(c) => c,
+        Err(_) => content.to_string(),
     }
-    updated
 }
 
 /// Strip vault prefix and .md suffix to get the relative path stem (e.g., "project/weekly-review").
@@ -192,12 +167,11 @@ fn unique_dest_path(dest_dir: &Path, filename: &str) -> std::path::PathBuf {
     }
 }
 
-/// Rename a note: update its title, rename the file, and update wiki links across the vault.
+/// Rename a note: update its frontmatter title, rename the file, and update wiki links across the vault.
 ///
 /// When `old_title_hint` is provided it is used instead of extracting the title from
-/// the file's H1 heading.  This is needed when the caller has already saved updated
-/// content to disk (e.g. the editor saved a new H1 before triggering the rename)
-/// so the on-disk H1 already matches `new_title`.
+/// the file's frontmatter/filename.  This is needed when the caller has already saved
+/// updated content to disk before triggering the rename.
 pub fn rename_note(
     vault_path: &str,
     old_path: &str,
@@ -298,15 +272,6 @@ mod tests {
         assert_eq!(title_to_slug("Hello World"), "hello-world");
     }
 
-    #[test]
-    fn test_update_h1_title() {
-        let content = "---\nIs A: Note\n---\n# Old Title\n\nContent here.\n";
-        let updated = update_h1_title(content, "New Title");
-        assert!(updated.contains("# New Title"));
-        assert!(!updated.contains("# Old Title"));
-        assert!(updated.contains("Content here."));
-    }
-
     #[test]
     fn test_rename_note_basic() {
         let dir = TempDir::new().unwrap();
@@ -331,7 +296,9 @@ mod tests {
         assert!(Path::new(&result.new_path).exists());
 
         let new_content = fs::read_to_string(&result.new_path).unwrap();
-        assert!(new_content.contains("# Sprint Retrospective"));
+        // H1 is body content — rename must NOT modify it
+        assert!(new_content.contains("# Weekly Review"));
+        assert!(new_content.contains("title: Sprint Retrospective"));
     }
 
     #[test]
@@ -454,7 +421,8 @@ mod tests {
 
         let content = fs::read_to_string(&result.new_path).unwrap();
         assert!(content.contains("title: New Name"));
-        assert!(content.contains("# New Name"));
+        // H1 is body content — rename must NOT modify it
+        assert!(content.contains("# Old Name"));
     }
 
     // --- Regression: rename empty / minimal notes (nota vuota) ---
@@ -513,7 +481,9 @@ mod tests {
     #[test]
     fn test_rename_note_h1_only_no_body() {
         let content = rename_test_note("note/heading-only.md", "# Old Heading\n", "New Heading");
-        assert!(content.contains("# New Heading"));
+        // H1 is body content — rename must NOT modify it
+        assert!(content.contains("# Old Heading"));
+        assert!(content.contains("title: New Heading"));
     }
 
     #[test]
@@ -524,7 +494,8 @@ mod tests {
             "Renamed Note",
         );
         assert!(content.contains("title: Renamed Note"));
-        assert!(content.contains("# Renamed Note"));
+        // H1 is body content — rename must NOT modify it
+        assert!(content.contains("# My Note"));
     }
 
     // --- rename-on-save: filename doesn't match title slug ---
@@ -678,6 +649,41 @@ mod tests {
         assert!(other_content.contains("[[Sprint Retrospective]]"));
     }
 
+    #[test]
+    fn test_rename_note_does_not_modify_h1() {
+        // H1 is body content — rename should only update frontmatter title, not H1
+        let dir = TempDir::new().unwrap();
+        let vault = dir.path();
+        create_test_file(
+            vault,
+            "note/old.md",
+            "---\ntitle: Old Title\ntype: Note\n---\n\n# Old Title\n\nSome body text.\n",
+        );
+
+        let old_path = vault.join("note/old.md");
+        let result = rename_note(
+            vault.to_str().unwrap(),
+            old_path.to_str().unwrap(),
+            "Brand New Title",
+            None,
+        )
+        .unwrap();
+
+        let content = fs::read_to_string(&result.new_path).unwrap();
+        assert!(
+            content.contains("title: Brand New Title"),
+            "frontmatter title should be updated"
+        );
+        assert!(
+            content.contains("# Old Title"),
+            "H1 must NOT be modified by rename"
+        );
+        assert!(
+            !content.contains("# Brand New Title"),
+            "H1 must NOT match new title"
+        );
+    }
+
     #[test]
     fn test_rename_note_hint_same_as_new_title_noop() {
         // If old_title_hint == new_title, should be a noop

src-tauri/src/vault_config.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::Path;
 
-/// Vault-wide UI configuration stored in `config/ui.config.md`.
+/// Vault-wide UI configuration stored in `ui.config.md` at vault root.
 ///
 /// This file is a regular vault note with YAML frontmatter, visible in the
 /// sidebar under the "Config" section and editable like any note.
@@ -21,14 +21,13 @@ pub struct VaultConfig {
     pub property_display_modes: Option<HashMap<String, String>>,
 }
 
-const CONFIG_DIR: &str = "config";
 const CONFIG_FILENAME: &str = "ui.config.md";
 
 fn config_path(vault_path: &str) -> std::path::PathBuf {
-    Path::new(vault_path).join(CONFIG_DIR).join(CONFIG_FILENAME)
+    Path::new(vault_path).join(CONFIG_FILENAME)
 }
 
-/// Read the vault-wide UI config from `config/ui.config.md`.
+/// Read the vault-wide UI config from `ui.config.md` at vault root.
 /// Returns default values if the file doesn't exist.
 pub fn get_vault_config(vault_path: &str) -> Result<VaultConfig, String> {
     let path = config_path(vault_path);
@@ -69,19 +68,42 @@ fn parse_vault_config(content: &str) -> Result<VaultConfig, String> {
         .map_err(|e| format!("Failed to parse config: {e}"))
 }
 
-/// Save the vault-wide UI config to `config/ui.config.md`.
-/// Creates the directory and file if they don't exist.
+/// Save the vault-wide UI config to `ui.config.md` at vault root.
+/// Creates the file if it doesn't exist.
 pub fn save_vault_config(vault_path: &str, config: VaultConfig) -> Result<(), String> {
     let path = config_path(vault_path);
-    let dir = Path::new(vault_path).join(CONFIG_DIR);
-    if !dir.exists() {
-        std::fs::create_dir_all(&dir).map_err(|e| format!("Failed to create config dir: {e}"))?;
-    }
-
     let content = serialize_config(&config);
     std::fs::write(&path, content).map_err(|e| format!("Failed to write config: {e}"))
 }
 
+/// Migrate legacy `config/ui.config.md` → root `ui.config.md`.
+/// If the root file already exists, the legacy file is simply removed.
+/// Cleans up empty `config/` directory after migration.
+pub fn migrate_ui_config_to_root(vault_path: &str) {
+    let vault = Path::new(vault_path);
+    let legacy = vault.join("config").join(CONFIG_FILENAME);
+    let root = vault.join(CONFIG_FILENAME);
+
+    if legacy.exists() {
+        if !root.exists() {
+            // Move legacy content to root
+            if let Ok(content) = std::fs::read_to_string(&legacy) {
+                let _ = std::fs::write(&root, content);
+            }
+        }
+        let _ = std::fs::remove_file(&legacy);
+    }
+
+    // Clean up empty config/ directory
+    let config_dir = vault.join("config");
+    if config_dir.is_dir() {
+        let is_empty = std::fs::read_dir(&config_dir).map_or(true, |mut d| d.next().is_none());
+        if is_empty {
+            let _ = std::fs::remove_dir(&config_dir);
+        }
+    }
+}
+
 /// Serialize VaultConfig to a markdown file with YAML frontmatter.
 fn serialize_config(config: &VaultConfig) -> String {
     let mut lines = vec!["---".to_string(), "type: config".to_string()];
@@ -142,7 +164,7 @@ fn yaml_safe_value(value: &str) -> String {
     }
 }
 
-/// Migrate `hidden_sections` from `config/ui.config.md` to `visible: false`
+/// Migrate `hidden_sections` from `ui.config.md` to `visible: false`
 /// on Type notes. Returns the number of Type notes updated.
 ///
 /// For each type name in `hidden_sections`:
@@ -354,11 +376,9 @@ property_display_modes:
         let dir = tempfile::TempDir::new().unwrap();
         let vault_path = dir.path().to_str().unwrap();
 
-        // Create config with hidden_sections
-        let config_dir = dir.path().join("config");
-        std::fs::create_dir_all(&config_dir).unwrap();
+        // Create config with hidden_sections at vault root
         std::fs::write(
-            config_dir.join("ui.config.md"),
+            dir.path().join("ui.config.md"),
             "---\ntype: config\nhidden_sections:\n  - Bookmark\n  - Recipe\n---\n",
         )
         .unwrap();
@@ -375,7 +395,7 @@ property_display_modes:
         assert!(recipe.contains("visible: false"));
 
         // Config should no longer have hidden_sections
-        let config_content = std::fs::read_to_string(config_dir.join("ui.config.md")).unwrap();
+        let config_content = std::fs::read_to_string(dir.path().join("ui.config.md")).unwrap();
         assert!(!config_content.contains("hidden_sections"));
     }
 
@@ -384,11 +404,9 @@ property_display_modes:
         let dir = tempfile::TempDir::new().unwrap();
         let vault_path = dir.path().to_str().unwrap();
 
-        // Create config with hidden_sections
-        let config_dir = dir.path().join("config");
-        std::fs::create_dir_all(&config_dir).unwrap();
+        // Create config with hidden_sections at vault root
         std::fs::write(
-            config_dir.join("ui.config.md"),
+            dir.path().join("ui.config.md"),
             "---\ntype: config\nhidden_sections:\n  - Project\n---\n",
         )
         .unwrap();
@@ -416,10 +434,8 @@ property_display_modes:
         let dir = tempfile::TempDir::new().unwrap();
         let vault_path = dir.path().to_str().unwrap();
 
-        let config_dir = dir.path().join("config");
-        std::fs::create_dir_all(&config_dir).unwrap();
         std::fs::write(
-            config_dir.join("ui.config.md"),
+            dir.path().join("ui.config.md"),
             "---\ntype: config\nzoom: 1.0\n---\n",
         )
         .unwrap();
@@ -440,19 +456,15 @@ property_display_modes:
         let dir = tempfile::TempDir::new().unwrap();
         let vault_path = dir.path().to_str().unwrap();
 
-        let config_dir = dir.path().join("config");
-        std::fs::create_dir_all(&config_dir).unwrap();
         std::fs::write(
-            config_dir.join("ui.config.md"),
+            dir.path().join("ui.config.md"),
             "---\ntype: config\nhidden_sections:\n  - Note\n---\n",
         )
         .unwrap();
 
-        // Type note already has visible: false
-        let type_dir = dir.path().join("type");
-        std::fs::create_dir_all(&type_dir).unwrap();
+        // Type note already has visible: false at vault root
         std::fs::write(
-            type_dir.join("note.md"),
+            dir.path().join("note.md"),
             "---\ntype: Type\ntitle: Note\nvisible: false\n---\n",
         )
         .unwrap();
@@ -460,7 +472,7 @@ property_display_modes:
         let count = migrate_hidden_sections_to_visible(vault_path).unwrap();
         assert_eq!(count, 1);
 
-        let content = std::fs::read_to_string(type_dir.join("note.md")).unwrap();
+        let content = std::fs::read_to_string(dir.path().join("note.md")).unwrap();
         // Should have exactly one visible: false, not two
         assert_eq!(content.matches("visible:").count(), 1);
     }
@@ -478,4 +490,90 @@ property_display_modes:
         assert_eq!(yaml_safe_key("has space"), "\"has space\"");
         assert_eq!(yaml_safe_key("has:colon"), "\"has:colon\"");
     }
+
+    #[test]
+    fn migrate_ui_config_moves_legacy_to_root() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let vault_path = dir.path().to_str().unwrap();
+
+        let config_dir = dir.path().join("config");
+        std::fs::create_dir_all(&config_dir).unwrap();
+        std::fs::write(
+            config_dir.join("ui.config.md"),
+            "---\ntype: config\nzoom: 1.5\n---\n",
+        )
+        .unwrap();
+
+        migrate_ui_config_to_root(vault_path);
+
+        // Root file should exist with migrated content
+        let content = std::fs::read_to_string(dir.path().join("ui.config.md")).unwrap();
+        assert!(content.contains("zoom: 1.5"));
+        // Legacy file and empty config dir should be gone
+        assert!(!config_dir.join("ui.config.md").exists());
+        assert!(!config_dir.exists());
+    }
+
+    #[test]
+    fn migrate_ui_config_preserves_existing_root() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let vault_path = dir.path().to_str().unwrap();
+
+        // Root already has content
+        std::fs::write(
+            dir.path().join("ui.config.md"),
+            "---\ntype: config\nzoom: 2.0\n---\n",
+        )
+        .unwrap();
+
+        // Legacy also exists
+        let config_dir = dir.path().join("config");
+        std::fs::create_dir_all(&config_dir).unwrap();
+        std::fs::write(
+            config_dir.join("ui.config.md"),
+            "---\ntype: config\nzoom: 1.0\n---\n",
+        )
+        .unwrap();
+
+        migrate_ui_config_to_root(vault_path);
+
+        // Root should keep its original content
+        let content = std::fs::read_to_string(dir.path().join("ui.config.md")).unwrap();
+        assert!(content.contains("zoom: 2.0"));
+        // Legacy file should be removed
+        assert!(!config_dir.join("ui.config.md").exists());
+    }
+
+    #[test]
+    fn migrate_ui_config_keeps_nonempty_config_dir() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let vault_path = dir.path().to_str().unwrap();
+
+        let config_dir = dir.path().join("config");
+        std::fs::create_dir_all(&config_dir).unwrap();
+        std::fs::write(config_dir.join("ui.config.md"), "---\ntype: config\n---\n").unwrap();
+        std::fs::write(config_dir.join("other.md"), "Other file").unwrap();
+
+        migrate_ui_config_to_root(vault_path);
+
+        // config/ should still exist because it has other files
+        assert!(config_dir.exists());
+        assert!(config_dir.join("other.md").exists());
+        assert!(!config_dir.join("ui.config.md").exists());
+    }
+
+    #[test]
+    fn save_config_writes_to_vault_root() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let vault_path = dir.path().to_str().unwrap();
+        let config = VaultConfig {
+            zoom: Some(1.0),
+            ..Default::default()
+        };
+        save_vault_config(vault_path, config).unwrap();
+
+        // File should be at vault root, not in config/
+        assert!(dir.path().join("ui.config.md").exists());
+        assert!(!dir.path().join("config").exists());
+    }
 }

src/App.tsx

@@ -49,10 +49,11 @@ import { FlatVaultMigrationBanner } from './components/FlatVaultMigrationBanner'
 import { useFlatVaultMigration } from './hooks/useFlatVaultMigration'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from './mock-tauri'
-import type { SidebarSelection, VaultEntry } from './types'
+import type { SidebarSelection, VaultEntry, InboxPeriod } from './types'
 import type { NoteListItem } from './utils/ai-context'
-import { filterEntries, type NoteListFilter } from './utils/noteListHelpers'
+import { filterEntries, filterInboxEntries, type NoteListFilter } from './utils/noteListHelpers'
 import { openLocalFile } from './utils/url'
+import { openNoteInNewWindow } from './utils/openNoteWindow'
 import { flushEditorContent } from './utils/autoSave'
 import './App.css'
 
@@ -71,6 +72,7 @@ const DEFAULT_SELECTION: SidebarSelection = { kind: 'filter', filter: 'all' }
 function App() {
   const [selection, setSelection] = useState<SidebarSelection>(DEFAULT_SELECTION)
   const [noteListFilter, setNoteListFilter] = useState<NoteListFilter>('open')
+  const [inboxPeriod, setInboxPeriod] = useState<InboxPeriod>('month')
   const handleSetSelection = useCallback((sel: SidebarSelection) => {
     setSelection(sel)
     setNoteListFilter('open')
@@ -155,11 +157,40 @@ function App() {
     dialogs.closeConflictResolver()
   }, [autoSync, dialogs])
 
+  /** Resolve a single file conflict from the in-editor banner. */
+  const handleResolveConflictInline = useCallback(async (filePath: string, strategy: 'ours' | 'theirs') => {
+    try {
+      const relativePath = filePath.replace(resolvedPath + '/', '')
+      const call = isTauri() ? invoke : mockInvoke
+      await call('git_resolve_conflict', { vaultPath: resolvedPath, file: relativePath, strategy })
+      // Reload the note content to show the resolved version
+      const content = await (isTauri() ? invoke<string> : mockInvoke<string>)('get_note_content', { path: filePath })
+      // Check remaining conflicts
+      const remaining = await (isTauri() ? invoke<string[]> : mockInvoke<string[]>)('get_conflict_files', { vaultPath: resolvedPath })
+      if (remaining.length === 0) {
+        // All resolved — auto-commit the merge and push
+        await (isTauri() ? invoke : mockInvoke)('git_commit_conflict_resolution', { vaultPath: resolvedPath })
+        vault.reloadVault()
+        autoSync.triggerSync()
+        setToastMessage('All conflicts resolved — merge committed')
+      } else {
+        void content // content reload happens via vault reload
+        vault.reloadVault()
+        setToastMessage(`Resolved — ${remaining.length} conflict${remaining.length > 1 ? 's' : ''} remaining`)
+      }
+    } catch (err) {
+      setToastMessage(`Failed to resolve conflict: ${err}`)
+    }
+  }, [resolvedPath, vault, autoSync, setToastMessage])
+
+  const handleKeepMine = useCallback((path: string) => handleResolveConflictInline(path, 'ours'), [handleResolveConflictInline])
+  const handleKeepTheirs = useCallback((path: string) => handleResolveConflictInline(path, 'theirs'), [handleResolveConflictInline])
+
   // Ref bridges handleContentChange (created after notes) into useNoteActions.
   // Read at callback time, so it's always current when user presses Cmd+N.
   const contentChangeRef = useRef<(path: string, content: string) => void>(() => {})
 
-  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry })
+  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry, onFrontmatterContentChanged: themeManager.notifyThemeSaved })
 
   // Keep tab entries in sync with vault entries so banners (trash/archive)
   // and read-only state react immediately without reopening the note.
@@ -255,6 +286,17 @@ function App() {
     if (notes.activeTabPath) handleRemoveNoteIcon(notes.activeTabPath)
   }, [notes.activeTabPath, handleRemoveNoteIcon])
 
+  /** Open the active note in a new window (command palette / keyboard shortcut). */
+  const handleOpenInNewWindow = useCallback(() => {
+    const activeTab = notes.tabs.find(t => t.entry.path === notes.activeTabPath)
+    if (activeTab) openNoteInNewWindow(activeTab.entry.path, resolvedPath, activeTab.entry.title)
+  }, [notes.tabs, notes.activeTabPath, resolvedPath])
+
+  /** Open a specific note entry in a new window (Cmd+Shift+Click). */
+  const handleOpenEntryInNewWindow = useCallback((entry: VaultEntry) => {
+    openNoteInNewWindow(entry.path, resolvedPath, entry.title)
+  }, [resolvedPath])
+
   const { triggerIncrementalIndex } = indexing
   const onAfterSave = useCallback(() => {
     vault.loadModifiedFiles()
@@ -313,6 +355,22 @@ function App() {
     }
   }, [resolvedPath, vault.entries, notes, dialogs])
 
+  /** Flush pending auto-save before closing a tab to prevent data loss. */
+  const handleCloseTabWithFlush = useCallback((path: string) => {
+    savePendingForPath(path).catch(() => {})
+    notes.handleCloseTab(path)
+  }, [savePendingForPath, notes])
+
+  // Wrap the close-tab ref so Cmd+W and menu bar also flush auto-save
+  const closeTabWithFlushRef = useRef<(path: string) => void>(handleCloseTabWithFlush)
+  useEffect(() => {
+    const original = notes.handleCloseTabRef.current
+    closeTabWithFlushRef.current = (path: string) => {
+      savePendingForPath(path).catch(() => {})
+      original(path)
+    }
+  })
+
   const handleRenameTab = useCallback(async (path: string, newTitle: string) => {
     await savePendingForPath(path)
     await notes.handleRenameNote(path, newTitle, resolvedPath, vault.replaceEntry).then(vault.loadModifiedFiles)
@@ -333,7 +391,7 @@ function App() {
     }
   }, [handleSaveRaw, handleRenameTab, notes.tabs, notes.activeTabPath, vault.unsavedPaths])
 
-  const commitFlow = useCommitFlow({ savePending, loadModifiedFiles: vault.loadModifiedFiles, commitAndPush: vault.commitAndPush, setToastMessage })
+  const commitFlow = useCommitFlow({ savePending, loadModifiedFiles: vault.loadModifiedFiles, commitAndPush: vault.commitAndPush, setToastMessage, onPushRejected: autoSync.handlePushRejected })
 
   const entryActions = useEntryActions({
     entries: vault.entries, updateEntry: vault.updateEntry,
@@ -359,10 +417,12 @@ function App() {
     setToastMessage(`Type "${name}" created`)
   }, [notes])
 
-  /** H1→title sync: save pending content then rename file + update wikilinks. */
-  const handleTitleSync = useCallback(async (path: string, newTitle: string) => {
-    await savePendingForPath(path)
-    await notes.handleRenameNote(path, newTitle, resolvedPath, vault.replaceEntry).then(vault.loadModifiedFiles)
+  /** Title field change: save pending content then rename file + update wikilinks (non-blocking). */
+  const handleTitleSync = useCallback((path: string, newTitle: string) => {
+    savePendingForPath(path)
+      .then(() => notes.handleRenameNote(path, newTitle, resolvedPath, vault.replaceEntry))
+      .then(vault.loadModifiedFiles)
+      .catch((err) => console.error('Title rename failed:', err))
   }, [notes, resolvedPath, vault, savePendingForPath])
 
   const bulkActions = useBulkActions(entryActions, setToastMessage)
@@ -424,7 +484,7 @@ function App() {
 
   const commands = useAppCommands({
     activeTabPath: notes.activeTabPath, activeTabPathRef: notes.activeTabPathRef,
-    handleCloseTabRef: notes.handleCloseTabRef, tabs: notes.tabs,
+    handleCloseTabRef: closeTabWithFlushRef, tabs: notes.tabs,
     entries: vault.entries,
     modifiedCount: vault.modifiedFiles.length,
     activeNoteModified: vault.modifiedFiles.some(f => f.path === notes.activeTabPath),
@@ -439,6 +499,7 @@ function App() {
     onTrashNote: entryActions.handleTrashNote, onRestoreNote: entryActions.handleRestoreNote,
     onArchiveNote: entryActions.handleArchiveNote, onUnarchiveNote: entryActions.handleUnarchiveNote,
     onCommitPush: commitFlow.openCommitDialog,
+    onPull: autoSync.triggerSync,
     onResolveConflicts: handleOpenConflictResolver,
     onSetViewMode: setViewMode,
     onToggleInspector: () => layout.setInspectorCollapsed(c => !c),
@@ -491,19 +552,23 @@ function App() {
     })(),
     noteListFilter,
     onSetNoteListFilter: setNoteListFilter,
+    onOpenInNewWindow: handleOpenInNewWindow,
   })
 
   const activeTab = notes.tabs.find((t) => t.entry.path === notes.activeTabPath) ?? null
 
+  const inboxCount = useMemo(() => filterInboxEntries(vault.entries, inboxPeriod).length, [vault.entries, inboxPeriod])
+
   const aiNoteList = useMemo<NoteListItem[]>(() => {
-    return filterEntries(vault.entries, selection).map(e => ({
+    const isInbox = selection.kind === 'filter' && selection.filter === 'inbox'
+    const filtered = isInbox ? filterInboxEntries(vault.entries, inboxPeriod) : filterEntries(vault.entries, selection)
+    return filtered.map(e => ({
       path: e.path, title: e.title, type: e.isA ?? 'Note',
     }))
-  }, [vault.entries, selection])
+  }, [vault.entries, selection, inboxPeriod])
 
   const aiNoteListFilter = useMemo(() => {
     if (selection.kind === 'sectionGroup') return { type: selection.type, query: '' }
-    if (selection.kind === 'topic') return { type: null, query: selection.entry.title }
     if (selection.kind === 'entity') return { type: null, query: selection.entry.title }
     return { type: null, query: '' }
   }, [selection])
@@ -524,7 +589,7 @@ function App() {
         {sidebarVisible && (
           <>
             <div className="app__sidebar" style={{ width: layout.sidebarWidth }}>
-              <Sidebar entries={vault.entries} selection={selection} onSelect={handleSetSelection} onSelectNote={notes.handleSelectNote} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} onRenameSection={entryActions.handleRenameSection} onToggleTypeVisibility={entryActions.handleToggleTypeVisibility} modifiedCount={vault.modifiedFiles.length} onCommitPush={commitFlow.openCommitDialog} isGitVault={!vault.modifiedFilesError} />
+              <Sidebar entries={vault.entries} selection={selection} onSelect={handleSetSelection} onSelectNote={notes.handleSelectNote} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} onRenameSection={entryActions.handleRenameSection} onToggleTypeVisibility={entryActions.handleToggleTypeVisibility} modifiedCount={vault.modifiedFiles.length} inboxCount={inboxCount} onCommitPush={commitFlow.openCommitDialog} isGitVault={!vault.modifiedFilesError} />
             </div>
             <ResizeHandle onResize={layout.handleSidebarResize} />
           </>
@@ -535,7 +600,7 @@ function App() {
               {selection.kind === 'filter' && selection.filter === 'pulse' ? (
                 <PulseView vaultPath={resolvedPath} onOpenNote={handlePulseOpenNote} sidebarCollapsed={!sidebarVisible} onExpandSidebar={() => setViewMode('all')} />
               ) : (
-                <NoteList entries={vault.entries} selection={selection} selectedNote={activeTab?.entry ?? null} noteListFilter={noteListFilter} onNoteListFilterChange={setNoteListFilter} modifiedFiles={vault.modifiedFiles} modifiedFilesError={vault.modifiedFilesError} getNoteStatus={vault.getNoteStatus} sidebarCollapsed={!sidebarVisible} onSelectNote={notes.handleSelectNote} onReplaceActiveTab={notes.handleReplaceActiveTab} onCreateNote={notes.handleCreateNoteImmediate} onBulkArchive={bulkActions.handleBulkArchive} onBulkTrash={bulkActions.handleBulkTrash} onBulkRestore={bulkActions.handleBulkRestore} onBulkDeletePermanently={deleteActions.handleBulkDeletePermanently} onEmptyTrash={deleteActions.handleEmptyTrash} onUpdateTypeSort={notes.handleUpdateFrontmatter} updateEntry={vault.updateEntry} />
+                <NoteList entries={vault.entries} selection={selection} selectedNote={activeTab?.entry ?? null} noteListFilter={noteListFilter} onNoteListFilterChange={setNoteListFilter} inboxPeriod={inboxPeriod} onInboxPeriodChange={setInboxPeriod} modifiedFiles={vault.modifiedFiles} modifiedFilesError={vault.modifiedFilesError} getNoteStatus={vault.getNoteStatus} sidebarCollapsed={!sidebarVisible} onSelectNote={notes.handleSelectNote} onReplaceActiveTab={notes.handleReplaceActiveTab} onCreateNote={notes.handleCreateNoteImmediate} onBulkArchive={bulkActions.handleBulkArchive} onBulkTrash={bulkActions.handleBulkTrash} onBulkRestore={bulkActions.handleBulkRestore} onBulkDeletePermanently={deleteActions.handleBulkDeletePermanently} onEmptyTrash={deleteActions.handleEmptyTrash} onUpdateTypeSort={notes.handleUpdateFrontmatter} updateEntry={vault.updateEntry} onOpenInNewWindow={handleOpenEntryInNewWindow} />
               )}
             </div>
             <ResizeHandle onResize={layout.handleNoteListResize} />
@@ -547,7 +612,7 @@ function App() {
             activeTabPath={notes.activeTabPath}
             entries={vault.entries}
             onSwitchTab={notes.handleSwitchTab}
-            onCloseTab={notes.handleCloseTab}
+            onCloseTab={handleCloseTabWithFlush}
             onReorderTabs={notes.handleReorderTabs}
             onNavigateWikilink={notes.handleNavigateWikilink}
             onLoadDiff={vault.loadDiff}
@@ -592,6 +657,9 @@ function App() {
             onVaultChanged={handleAgentVaultChanged}
             onSetNoteIcon={handleSetNoteIcon}
             onRemoveNoteIcon={handleRemoveNoteIcon}
+            isConflicted={!!notes.activeTabPath && autoSync.conflictFiles.some(f => notes.activeTabPath?.endsWith(f))}
+            onKeepMine={handleKeepMine}
+            onKeepTheirs={handleKeepTheirs}
           />
         </div>
       </div>
@@ -607,7 +675,7 @@ function App() {
         />
       )}
       <UpdateBanner status={updateStatus} actions={updateActions} />
-      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} onTriggerSync={autoSync.triggerSync} onOpenConflictResolver={handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} indexingProgress={indexing.progress} lastIndexedTime={indexing.lastIndexedTime} onRetryIndexing={indexing.retryIndexing} onReindexVault={indexing.triggerFullReindex} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} />
+      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} remoteStatus={autoSync.remoteStatus} onTriggerSync={autoSync.triggerSync} onPullAndPush={autoSync.pullAndPush} onOpenConflictResolver={handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} indexingProgress={indexing.progress} lastIndexedTime={indexing.lastIndexedTime} onRetryIndexing={indexing.retryIndexing} onReindexVault={indexing.triggerFullReindex} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} />
       <Toast message={toastMessage} onDismiss={() => setToastMessage(null)} />
       <QuickOpenPalette open={dialogs.showQuickOpen} entries={vault.entries} onSelect={notes.handleSelectNote} onClose={dialogs.closeQuickOpen} />
       <CommandPalette open={dialogs.showCommandPalette} commands={commands} onClose={dialogs.closeCommandPalette} />

src/NoteWindow.tsx

@@ -0,0 +1,169 @@
+import { useCallback, useEffect, useMemo, useState } from 'react'
+import { invoke } from '@tauri-apps/api/core'
+import { Editor } from './components/Editor'
+import { Toast } from './components/Toast'
+import { isTauri, mockInvoke } from './mock-tauri'
+import { getNoteWindowParams } from './utils/windowMode'
+import { useThemeManager } from './hooks/useThemeManager'
+import { useEditorSaveWithLinks } from './hooks/useEditorSaveWithLinks'
+import { useLayoutPanels } from './hooks/useLayoutPanels'
+import type { VaultEntry } from './types'
+import './App.css'
+
+function tauriCall<T>(command: string, args: Record<string, unknown>): Promise<T> {
+  return isTauri() ? invoke<T>(command, args) : mockInvoke<T>(command, args)
+}
+
+interface Tab {
+  entry: VaultEntry
+  content: string
+}
+
+/**
+ * Minimal app shell for secondary "note windows" opened via "Open in New Window".
+ * Shows only the editor — no sidebar, no note list.
+ */
+export default function NoteWindow() {
+  const params = getNoteWindowParams()
+  const [entries, setEntries] = useState<VaultEntry[]>([])
+  const [tabs, setTabs] = useState<Tab[]>([])
+  const [toastMessage, setToastMessage] = useState<string | null>(null)
+  const activeTabPath = tabs[0]?.entry.path ?? null
+
+  const layout = useLayoutPanels()
+
+  // Load vault entries + note content on mount
+  useEffect(() => {
+    if (!params) return
+    const { vaultPath, notePath } = params
+    let cancelled = false
+
+    async function load() {
+      const vaultEntries = await tauriCall<VaultEntry[]>('list_vault', { path: vaultPath })
+      if (cancelled) return
+      setEntries(vaultEntries)
+      const entry = vaultEntries.find(e => e.path === notePath)
+      if (!entry) return
+      const content = await tauriCall<string>('get_note_content', { path: notePath })
+      if (cancelled) return
+      setTabs([{ entry, content }])
+    }
+
+    load().catch(err => console.error('NoteWindow load failed:', err))
+    return () => { cancelled = true }
+  }, []) // eslint-disable-line react-hooks/exhaustive-deps -- run once on mount with captured params
+
+  // Apply theme
+  const vaultPath = params?.vaultPath ?? ''
+  useThemeManager(vaultPath, entries)
+
+  // Update window title when note title changes
+  useEffect(() => {
+    const title = tabs[0]?.entry.title
+    if (!title) return
+    if (!isTauri()) { document.title = title; return }
+    import('@tauri-apps/api/window').then(({ getCurrentWindow }) => {
+      getCurrentWindow().setTitle(title)
+    }).catch(() => {})
+  }, [tabs])
+
+  // Auto-save
+  const updateEntry = useCallback((path: string, patch: Partial<VaultEntry>) => {
+    setEntries(prev => prev.map(e => e.path === path ? { ...e, ...patch } : e))
+    setTabs(prev => prev.map(t => t.entry.path === path ? { ...t, entry: { ...t.entry, ...patch } } : t))
+  }, [])
+
+  const onAfterSave = useCallback(() => {}, [])
+  const onNotePersisted = useCallback(() => {}, [])
+
+  const { handleSave, handleContentChange } = useEditorSaveWithLinks({
+    updateEntry,
+    setTabs,
+    setToastMessage,
+    onAfterSave,
+    onNotePersisted,
+  })
+
+  // Wikilink navigation — in a note window, open wikilinks in the same window
+  const handleNavigateWikilink = useCallback((target: string) => {
+    const targetLower = target.toLowerCase()
+    const entry = entries.find(e =>
+      e.title.toLowerCase() === targetLower ||
+      e.aliases.some(a => a.toLowerCase() === targetLower)
+    )
+    if (!entry) return
+    tauriCall<string>('get_note_content', { path: entry.path }).then(content => {
+      setTabs([{ entry, content }])
+    }).catch(() => {})
+  }, [entries])
+
+  // Stub for close tab — in a note window, close the window
+  const handleCloseTab = useCallback(() => {
+    if (!isTauri()) return
+    import('@tauri-apps/api/window').then(({ getCurrentWindow }) => {
+      getCurrentWindow().close()
+    }).catch(() => {})
+  }, [])
+
+  // Keyboard: Cmd+S to save, Cmd+W to close
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === 's') {
+        e.preventDefault()
+        handleSave()
+      }
+      if ((e.metaKey || e.ctrlKey) && e.key === 'w') {
+        e.preventDefault()
+        handleCloseTab()
+      }
+    }
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [handleSave, handleCloseTab])
+
+  const activeTab = tabs[0] ?? null
+  const gitHistory = useMemo(() => [], [])
+
+  if (!params) {
+    return <div className="app-shell"><p>Invalid note window parameters</p></div>
+  }
+
+  if (!activeTab) {
+    return (
+      <div className="app-shell">
+        <div style={{ width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--sidebar)' }}>
+          <span style={{ color: 'var(--muted-foreground)', fontSize: 14 }}>Loading…</span>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="app-shell">
+      <div className="app">
+        <div className="app__editor">
+          <Editor
+            tabs={tabs}
+            activeTabPath={activeTabPath}
+            entries={entries}
+            onSwitchTab={() => {}}
+            onCloseTab={handleCloseTab}
+            onNavigateWikilink={handleNavigateWikilink}
+            inspectorCollapsed={layout.inspectorCollapsed}
+            onToggleInspector={() => layout.setInspectorCollapsed(c => !c)}
+            inspectorWidth={layout.inspectorWidth}
+            onInspectorResize={layout.handleInspectorResize}
+            inspectorEntry={activeTab.entry}
+            inspectorContent={activeTab.content}
+            gitHistory={gitHistory}
+            onContentChange={handleContentChange}
+            onSave={handleSave}
+            leftPanelsCollapsed={true}
+            vaultPath={vaultPath}
+          />
+        </div>
+      </div>
+      <Toast message={toastMessage} onDismiss={() => setToastMessage(null)} />
+    </div>
+  )
+}

src/components/BreadcrumbBar.tsx

@@ -1,6 +1,7 @@
 import { memo } from 'react'
 import type { VaultEntry, NoteStatus } from '../types'
 import { cn } from '@/lib/utils'
+import { isEmoji } from '../utils/emoji'
 import {
   MagnifyingGlass,
   GitBranch,
@@ -179,7 +180,10 @@ export const BreadcrumbBar = memo(function BreadcrumbBar({
       <div className="flex items-center gap-1 min-w-0 whitespace-nowrap" style={{ fontSize: 12 }}>
         <span className="shrink-0 text-muted-foreground">{entry.isA || 'Note'}</span>
         <span className="shrink-0 text-muted-foreground" style={{ margin: '0 2px' }}>&rsaquo;</span>
-        <span className="truncate font-medium text-foreground" style={{ maxWidth: '40vw' }}>{entry.title}</span>
+        <span className="truncate font-medium text-foreground" style={{ maxWidth: '40vw' }}>
+          {entry.icon && isEmoji(entry.icon) && <span className="mr-1">{entry.icon}</span>}
+          {entry.title}
+        </span>
         <span className="shrink-0 text-muted-foreground" style={{ margin: '0 4px' }}>&middot;</span>
         <span className="shrink-0 text-muted-foreground">{wordCount.toLocaleString()} words</span>
         {noteStatus === 'pendingSave' && (

src/components/ConflictNoteBanner.test.tsx

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi } from 'vitest'
+import { render, screen, fireEvent } from '@testing-library/react'
+import { ConflictNoteBanner } from './ConflictNoteBanner'
+
+describe('ConflictNoteBanner', () => {
+  it('renders conflict message', () => {
+    render(<ConflictNoteBanner onKeepMine={vi.fn()} onKeepTheirs={vi.fn()} />)
+    expect(screen.getByText('This note has a merge conflict')).toBeInTheDocument()
+  })
+
+  it('calls onKeepMine when clicking Keep mine button', () => {
+    const onKeepMine = vi.fn()
+    render(<ConflictNoteBanner onKeepMine={onKeepMine} onKeepTheirs={vi.fn()} />)
+    fireEvent.click(screen.getByTestId('conflict-keep-mine-btn'))
+    expect(onKeepMine).toHaveBeenCalledOnce()
+  })
+
+  it('calls onKeepTheirs when clicking Keep theirs button', () => {
+    const onKeepTheirs = vi.fn()
+    render(<ConflictNoteBanner onKeepMine={vi.fn()} onKeepTheirs={onKeepTheirs} />)
+    fireEvent.click(screen.getByTestId('conflict-keep-theirs-btn'))
+    expect(onKeepTheirs).toHaveBeenCalledOnce()
+  })
+
+  it('has the correct test id', () => {
+    render(<ConflictNoteBanner onKeepMine={vi.fn()} onKeepTheirs={vi.fn()} />)
+    expect(screen.getByTestId('conflict-note-banner')).toBeInTheDocument()
+  })
+})

src/components/ConflictNoteBanner.tsx

@@ -0,0 +1,68 @@
+import { AlertTriangle } from 'lucide-react'
+
+interface ConflictNoteBannerProps {
+  onKeepMine: () => void
+  onKeepTheirs: () => void
+}
+
+export function ConflictNoteBanner({ onKeepMine, onKeepTheirs }: ConflictNoteBannerProps) {
+  return (
+    <div
+      data-testid="conflict-note-banner"
+      style={{
+        display: 'flex',
+        alignItems: 'center',
+        gap: 6,
+        padding: '4px 16px',
+        background: 'var(--muted)',
+        borderBottom: '1px solid var(--border)',
+        fontSize: 12,
+        color: 'var(--accent-orange)',
+        flexShrink: 0,
+      }}
+    >
+      <AlertTriangle size={13} />
+      <span>This note has a merge conflict</span>
+      <div style={{ marginLeft: 'auto', display: 'flex', gap: 4 }}>
+        <button
+          data-testid="conflict-keep-mine-btn"
+          onClick={onKeepMine}
+          style={{
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: 4,
+            padding: '2px 8px',
+            background: 'transparent',
+            border: '1px solid var(--border)',
+            borderRadius: 4,
+            fontSize: 11,
+            color: 'var(--foreground)',
+            cursor: 'pointer',
+          }}
+          title="Keep my local version"
+        >
+          Keep mine
+        </button>
+        <button
+          data-testid="conflict-keep-theirs-btn"
+          onClick={onKeepTheirs}
+          style={{
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: 4,
+            padding: '2px 8px',
+            background: 'transparent',
+            border: '1px solid var(--border)',
+            borderRadius: 4,
+            fontSize: 11,
+            color: 'var(--foreground)',
+            cursor: 'pointer',
+          }}
+          title="Keep the remote version"
+        >
+          Keep theirs
+        </button>
+      </div>
+    </div>
+  )
+}

src/components/DynamicPropertiesPanel.test.tsx

@@ -227,14 +227,14 @@ describe('DynamicPropertiesPanel', () => {
       <DynamicPropertiesPanel
         entry={makeEntry()}
         content=""
-        frontmatter={{ archived: false }}
+        frontmatter={{ published: false }}
         onUpdateProperty={onUpdateProperty}
       />
     )
     // Boolean should show as Yes/No toggle
     const toggleBtn = screen.getByText('\u2717 No')
     fireEvent.click(toggleBtn)
-    expect(onUpdateProperty).toHaveBeenCalledWith('archived', true)
+    expect(onUpdateProperty).toHaveBeenCalledWith('published', true)
   })
 
   it('renders array property as tag pills', () => {
@@ -441,7 +441,7 @@ describe('DynamicPropertiesPanel', () => {
       <DynamicPropertiesPanel
         entry={makeEntry()}
         content=""
-        frontmatter={{ archived: 'false' }}
+        frontmatter={{ draft: 'false' }}
         onUpdateProperty={onUpdateProperty}
       />
     )
@@ -450,7 +450,7 @@ describe('DynamicPropertiesPanel', () => {
     const input = screen.getByDisplayValue('false')
     fireEvent.change(input, { target: { value: 'true' } })
     fireEvent.keyDown(input, { key: 'Enter' })
-    expect(onUpdateProperty).toHaveBeenCalledWith('archived', true)
+    expect(onUpdateProperty).toHaveBeenCalledWith('draft', true)
   })
 
   it('coerces numeric strings to numbers on save', () => {
@@ -664,6 +664,39 @@ describe('DynamicPropertiesPanel', () => {
     })
   })
 
+  describe('property row 50/50 layout', () => {
+    it('uses CSS grid with two equal columns on editable rows', () => {
+      render(
+        <DynamicPropertiesPanel
+          entry={makeEntry()}
+          content=""
+          frontmatter={{ url: 'https://example.com/very/long/path/that/should/be/truncated' }}
+          onUpdateProperty={onUpdateProperty}
+        />
+      )
+      const editableRows = screen.getAllByTestId('editable-property')
+      editableRows.forEach(row => {
+        expect(row.className).toContain('grid')
+        expect(row.className).toContain('grid-cols-2')
+      })
+    })
+
+    it('uses CSS grid with two equal columns on read-only rows', () => {
+      render(
+        <DynamicPropertiesPanel
+          entry={makeEntry()}
+          content=""
+          frontmatter={{}}
+        />
+      )
+      const readOnlyRows = screen.getAllByTestId('readonly-property')
+      readOnlyRows.forEach(row => {
+        expect(row.className).toContain('grid')
+        expect(row.className).toContain('grid-cols-2')
+      })
+    })
+  })
+
   describe('URL property rendering', () => {
     it('renders URL values with link styling instead of plain EditableValue', () => {
       render(
@@ -885,7 +918,7 @@ describe('DynamicPropertiesPanel', () => {
         <DynamicPropertiesPanel
           entry={makeEntry()}
           content=""
-          frontmatter={{ archived: false }}
+          frontmatter={{ published: false }}
           onUpdateProperty={onUpdateProperty}
         />
       )
@@ -894,6 +927,54 @@ describe('DynamicPropertiesPanel', () => {
     })
   })
 
+  describe('system property filtering', () => {
+    it('hides trashed, trashed_at, archived, archived_at, icon from properties panel', () => {
+      render(
+        <DynamicPropertiesPanel
+          entry={makeEntry()}
+          content=""
+          frontmatter={{ trashed: true, trashed_at: '2026-01-01', archived: false, archived_at: '', icon: '📝', cadence: 'Weekly' }}
+          onUpdateProperty={onUpdateProperty}
+        />
+      )
+      expect(screen.queryByText('trashed')).not.toBeInTheDocument()
+      expect(screen.queryByText('trashed_at')).not.toBeInTheDocument()
+      expect(screen.queryByText('archived')).not.toBeInTheDocument()
+      expect(screen.queryByText('archived_at')).not.toBeInTheDocument()
+      expect(screen.queryByText('icon')).not.toBeInTheDocument()
+      // Custom property still visible
+      expect(screen.getByText('cadence')).toBeInTheDocument()
+    })
+
+    it('filters system properties case-insensitively', () => {
+      render(
+        <DynamicPropertiesPanel
+          entry={makeEntry()}
+          content=""
+          frontmatter={{ Trashed: true, Archived: false, Icon: '🎯', cadence: 'Daily' }}
+          onUpdateProperty={onUpdateProperty}
+        />
+      )
+      expect(screen.queryByText('Trashed')).not.toBeInTheDocument()
+      expect(screen.queryByText('Archived')).not.toBeInTheDocument()
+      expect(screen.queryByText('Icon')).not.toBeInTheDocument()
+      expect(screen.getByText('cadence')).toBeInTheDocument()
+    })
+
+    it('does not filter similar but non-matching property names', () => {
+      render(
+        <DynamicPropertiesPanel
+          entry={makeEntry()}
+          content=""
+          frontmatter={{ 'Is Trashed': true, 'archive_date': '2026-01-01' }}
+          onUpdateProperty={onUpdateProperty}
+        />
+      )
+      expect(screen.getByText('Is Trashed')).toBeInTheDocument()
+      expect(screen.getByText('archive_date')).toBeInTheDocument()
+    })
+  })
+
   describe('display mode override', () => {
     beforeEach(() => {
       resetVaultConfigStore()

src/components/DynamicPropertiesPanel.tsx

@@ -47,7 +47,7 @@ function PropertyRow({ propKey, value, editingKey, displayMode, autoMode, vaultS
   }
 
   return (
-    <div className="group/prop flex min-w-0 items-center justify-between gap-2 rounded px-1.5 py-0.5 outline-none transition-colors hover:bg-muted focus:bg-muted focus:ring-1 focus:ring-primary" tabIndex={0} onKeyDown={handleKeyDown} data-testid="editable-property">
+    <div className="group/prop grid min-w-0 grid-cols-2 items-center gap-2 rounded px-1.5 outline-none transition-colors hover:bg-muted focus:bg-muted focus:ring-1 focus:ring-primary" tabIndex={0} onKeyDown={handleKeyDown} data-testid="editable-property">
       <span className="font-mono-overline flex min-w-0 items-center gap-1 text-muted-foreground">
         <span className="truncate">{propKey}</span>
         {onDelete && (
@@ -55,15 +55,17 @@ function PropertyRow({ propKey, value, editingKey, displayMode, autoMode, vaultS
         )}
         <DisplayModeSelector propKey={propKey} currentMode={displayMode} autoMode={autoMode} onSelect={onDisplayModeChange} />
       </span>
-      <SmartPropertyValueCell propKey={propKey} value={value} displayMode={displayMode} isEditing={editingKey === propKey} vaultStatuses={vaultStatuses} vaultTags={vaultTags} onStartEdit={onStartEdit} onSave={onSave} onSaveList={onSaveList} onUpdate={onUpdate} />
+      <div className="min-w-0">
+        <SmartPropertyValueCell propKey={propKey} value={value} displayMode={displayMode} isEditing={editingKey === propKey} vaultStatuses={vaultStatuses} vaultTags={vaultTags} onStartEdit={onStartEdit} onSave={onSave} onSaveList={onSaveList} onUpdate={onUpdate} />
+      </div>
     </div>
   )
 }
 
 function InfoRow({ label, value }: { label: string; value: string }) {
   return (
-    <div className="flex min-w-0 items-center justify-between gap-2 px-1.5" data-testid="readonly-property">
-      <span className="font-mono-overline shrink-0" style={{ color: 'var(--text-muted)' }}>{label}</span>
+    <div className="grid min-w-0 grid-cols-2 items-center gap-2 px-1.5" data-testid="readonly-property">
+      <span className="font-mono-overline min-w-0 truncate" style={{ color: 'var(--text-muted)' }}>{label}</span>
       <span className="min-w-0 truncate text-right text-[12px]" style={{ color: 'var(--text-muted)' }}>{value}</span>
     </div>
   )
@@ -116,7 +118,7 @@ export function DynamicPropertiesPanel({
 
   return (
     <div className="flex flex-col gap-3">
-      <div className="flex flex-col gap-2">
+      <div className="flex flex-col gap-1.5">
         <TypeSelector isA={entry.isA} customColorKey={customColorKey} availableTypes={availableTypes} typeColorKeys={typeColorKeys} typeIconKeys={typeIconKeys} onUpdateProperty={onUpdateProperty} onNavigate={onNavigate} />
         {propertyEntries.map(([key, value]) => (
           <PropertyRow

src/components/Editor.css

@@ -23,11 +23,19 @@
   opacity: 0.55;
 }
 
+/* Scroll area wrapping title + editor — single scroll context for alignment */
+.editor-scroll-area {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+}
+
 /* BlockNote container */
 .editor__blocknote-container {
   flex: 1;
   min-height: 0;
-  overflow-y: auto;
   display: flex;
   justify-content: center;
   position: relative;
@@ -88,7 +96,7 @@
 .editor__blocknote-container .bn-editor {
   width: 100%;
   padding: 20px 40px;
-  max-width: 760px;
+  max-width: var(--editor-max-width, 760px);
   margin: 0 auto;
 }
 
@@ -162,9 +170,23 @@
   opacity: 1 !important;
 }
 
+/* --- Title Section: wraps icon + title + separator, aligned to editor --- */
+.title-section {
+  width: 100%;
+  max-width: var(--editor-max-width, 760px);
+  margin: 0 auto;
+  padding: 0 var(--editor-padding-horizontal, 40px);
+  flex-shrink: 0;
+}
+
+.title-section__separator {
+  border-bottom: 1px solid var(--border-primary, rgba(0, 0, 0, 0.08));
+  margin-top: 12px;
+}
+
 /* --- Note Icon Area --- */
 .note-icon-area {
-  padding: 16px 54px 0;
+  padding: 16px 0 0;
   flex-shrink: 0;
 }
 
@@ -250,7 +272,7 @@
 
 /* --- Title Field --- */
 .title-field {
-  padding: 4px 54px 0;
+  padding: 4px 0 0;
   flex-shrink: 0;
 }
 
@@ -260,11 +282,13 @@
   border: none;
   outline: none;
   background: transparent;
-  font-size: var(--editor-title-size, 28px);
-  font-weight: 700;
-  line-height: 1.2;
+  font-size: var(--headings-h1-font-size);
+  font-weight: var(--headings-h1-font-weight);
+  line-height: var(--headings-h1-line-height);
+  letter-spacing: var(--headings-h1-letter-spacing);
   color: var(--foreground);
   padding: 0;
+  margin-left: 8px;
 }
 
 .title-field__input::placeholder {

src/components/Editor.test.tsx

@@ -300,7 +300,7 @@ describe('Editor', () => {
     const trashedTab = { entry: trashedEntry, content: mockContent }
 
     function renderTrashed(overrides: Partial<Parameters<typeof Editor>[0]> = {}) {
-      return render(<Editor {...defaultProps} tabs={[trashedTab]} activeTabPath={trashedEntry.path} {...overrides} />)
+      return render(<Editor {...defaultProps} entries={[trashedEntry]} tabs={[trashedTab]} activeTabPath={trashedEntry.path} {...overrides} />)
     }
 
     it('shows banner and read-only editor when note is trashed', () => {
@@ -336,9 +336,10 @@ describe('Editor', () => {
       )
       expect(screen.queryByTestId('trashed-note-banner')).not.toBeInTheDocument()
 
-      const updatedTab = { entry: { ...mockEntry, trashed: true, trashedAt: Date.now() / 1000 }, content: mockContent }
+      const trashedEntryUpdated = { ...mockEntry, trashed: true, trashedAt: Date.now() / 1000 }
+      const updatedTab = { entry: trashedEntryUpdated, content: mockContent }
       rerender(
-        <Editor {...defaultProps} tabs={[updatedTab]} activeTabPath={mockEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
+        <Editor {...defaultProps} entries={[trashedEntryUpdated]} tabs={[updatedTab]} activeTabPath={mockEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
       )
       expect(screen.getByTestId('trashed-note-banner')).toBeInTheDocument()
       expect(screen.getByTestId('blocknote-view')).toHaveAttribute('data-editable', 'false')
@@ -346,13 +347,14 @@ describe('Editor', () => {
 
     it('removes trash banner immediately when entry is restored (reactive)', () => {
       const { rerender } = render(
-        <Editor {...defaultProps} tabs={[trashedTab]} activeTabPath={trashedEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
+        <Editor {...defaultProps} entries={[trashedEntry]} tabs={[trashedTab]} activeTabPath={trashedEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
       )
       expect(screen.getByTestId('trashed-note-banner')).toBeInTheDocument()
 
-      const restoredTab = { entry: { ...trashedEntry, trashed: false, trashedAt: null }, content: mockContent }
+      const restoredEntry = { ...trashedEntry, trashed: false, trashedAt: null }
+      const restoredTab = { entry: restoredEntry, content: mockContent }
       rerender(
-        <Editor {...defaultProps} tabs={[restoredTab]} activeTabPath={trashedEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
+        <Editor {...defaultProps} entries={[restoredEntry]} tabs={[restoredTab]} activeTabPath={trashedEntry.path} onRestoreNote={vi.fn()} onDeleteNote={vi.fn()} />
       )
       expect(screen.queryByTestId('trashed-note-banner')).not.toBeInTheDocument()
       expect(screen.getByTestId('blocknote-view')).toHaveAttribute('data-editable', 'true')
@@ -408,6 +410,7 @@ describe('click empty editor space', () => {
     render(
       <Editor
         {...defaultProps}
+        entries={[trashedEntry]}
         tabs={[{ entry: trashedEntry, content: mockContent }]}
         activeTabPath={trashedEntry.path}
       />
@@ -429,9 +432,10 @@ describe('archived note behavior', () => {
     )
     expect(screen.queryByTestId('archived-note-banner')).not.toBeInTheDocument()
 
-    const archivedTab = { entry: { ...mockEntry, archived: true }, content: mockContent }
+    const archivedEntry = { ...mockEntry, archived: true }
+    const archivedTab = { entry: archivedEntry, content: mockContent }
     rerender(
-      <Editor {...defaultProps} tabs={[archivedTab]} activeTabPath={mockEntry.path} onUnarchiveNote={vi.fn()} />
+      <Editor {...defaultProps} entries={[archivedEntry]} tabs={[archivedTab]} activeTabPath={mockEntry.path} onUnarchiveNote={vi.fn()} />
     )
     expect(screen.getByTestId('archived-note-banner')).toBeInTheDocument()
   })
@@ -440,13 +444,14 @@ describe('archived note behavior', () => {
     const archivedEntry: VaultEntry = { ...mockEntry, archived: true }
     const archivedTab = { entry: archivedEntry, content: mockContent }
     const { rerender } = render(
-      <Editor {...defaultProps} tabs={[archivedTab]} activeTabPath={archivedEntry.path} onUnarchiveNote={vi.fn()} />
+      <Editor {...defaultProps} entries={[archivedEntry]} tabs={[archivedTab]} activeTabPath={archivedEntry.path} onUnarchiveNote={vi.fn()} />
     )
     expect(screen.getByTestId('archived-note-banner')).toBeInTheDocument()
 
-    const unarchivedTab = { entry: { ...archivedEntry, archived: false }, content: mockContent }
+    const unarchivedEntry = { ...archivedEntry, archived: false }
+    const unarchivedTab = { entry: unarchivedEntry, content: mockContent }
     rerender(
-      <Editor {...defaultProps} tabs={[unarchivedTab]} activeTabPath={archivedEntry.path} onUnarchiveNote={vi.fn()} />
+      <Editor {...defaultProps} entries={[unarchivedEntry]} tabs={[unarchivedTab]} activeTabPath={archivedEntry.path} onUnarchiveNote={vi.fn()} />
     )
     expect(screen.queryByTestId('archived-note-banner')).not.toBeInTheDocument()
   })

src/components/Editor.tsx

@@ -1,6 +1,5 @@
 import { useRef, useEffect, useCallback, memo } from 'react'
-import { useEditorTabSwap, getH1TextFromBlocks } from '../hooks/useEditorTabSwap'
-import { useHeadingTitleSync } from '../hooks/useHeadingTitleSync'
+import { useEditorTabSwap } from '../hooks/useEditorTabSwap'
 import { useCreateBlockNote } from '@blocknote/react'
 import '@blocknote/mantine/style.css'
 import { uploadImageFile } from '../hooks/useImageDrop'
@@ -59,7 +58,7 @@ interface EditorProps {
   onRenameTab?: (path: string, newTitle: string) => void
   onContentChange?: (path: string, content: string) => void
   onSave?: () => void
-  /** Called when H1→title sync updates the title (debounced). */
+  /** Called when the user edits the title in TitleField. */
   onTitleSync?: (path: string, newTitle: string) => void
   canGoBack?: boolean
   canGoForward?: boolean
@@ -78,6 +77,12 @@ interface EditorProps {
   onSetNoteIcon?: (path: string, emoji: string) => void
   /** Called when user removes an emoji icon from a note. */
   onRemoveNoteIcon?: (path: string) => void
+  /** Whether the active note has a merge conflict. */
+  isConflicted?: boolean
+  /** Resolve conflict by keeping the local version. */
+  onKeepMine?: (path: string) => void
+  /** Resolve conflict by keeping the remote version. */
+  onKeepTheirs?: (path: string) => void
 }
 
 function useEditorModeExclusion({
@@ -125,8 +130,6 @@ interface EditorSetupParams {
   activeTabPath: string | null
   vaultPath?: string
   onContentChange?: (path: string, content: string) => void
-  onTitleSync?: (path: string, newTitle: string) => void
-  onRenameTab?: (path: string, newTitle: string) => void
   onLoadDiff?: (path: string) => Promise<string>
   onLoadDiffAtCommit?: (path: string, commitHash: string) => Promise<string>
   getNoteStatus?: (path: string) => NoteStatus
@@ -169,8 +172,8 @@ function useRawModeWithFlush(
 }
 
 function useEditorSetup({
-  tabs, activeTabPath, vaultPath, onContentChange, onTitleSync,
-  onRenameTab, onLoadDiff, onLoadDiffAtCommit, getNoteStatus,
+  tabs, activeTabPath, vaultPath, onContentChange,
+  onLoadDiff, onLoadDiffAtCommit, getNoteStatus,
   rawToggleRef, diffToggleRef,
 }: EditorSetupParams) {
   const vaultPathRef = useRef(vaultPath)
@@ -183,28 +186,15 @@ function useEditorSetup({
 
   const activeTab = tabs.find((t) => t.entry.path === activeTabPath) ?? null
 
-  const { syncActiveRef, onH1Changed, onManualRename } = useHeadingTitleSync({
-    activeTabPath,
-    currentTitle: activeTab?.entry.title ?? null,
-    onTitleSync: onTitleSync ?? (() => {}),
-  })
-
   const { rawMode, handleToggleRaw, rawLatestContentRef } = useRawModeWithFlush(
     activeTabPath, onContentChange,
   )
 
   const { handleEditorChange, editorMountedRef } = useEditorTabSwap({
-    tabs, activeTabPath, editor, onContentChange,
-    onH1Change: onH1Changed, syncActiveRef, rawMode,
+    tabs, activeTabPath, editor, onContentChange, rawMode,
   })
   useEditorFocus(editor, editorMountedRef)
 
-  const handleRenameTabWithSync = useCallback((path: string, newTitle: string) => {
-    const h1Text = getH1TextFromBlocks(editor.document)
-    onManualRename(newTitle, h1Text)
-    onRenameTab?.(path, newTitle)
-  }, [editor, onManualRename, onRenameTab])
-
   const { diffMode, diffContent, diffLoading, handleToggleDiff, handleViewCommitDiff } = useDiffMode({
     activeTabPath, onLoadDiff, onLoadDiffAtCommit,
   })
@@ -221,7 +211,7 @@ function useEditorSetup({
     editor, activeTab, rawLatestContentRef,
     rawMode, diffMode, diffContent, diffLoading,
     handleToggleDiffExclusive, handleToggleRawExclusive,
-    handleEditorChange, handleRenameTabWithSync, handleViewCommitDiff,
+    handleEditorChange, handleViewCommitDiff,
     isLoadingNewTab, activeStatus, showDiffToggle,
   }
 }
@@ -240,17 +230,18 @@ export const Editor = memo(function Editor(props: EditorProps) {
     canGoBack, canGoForward, onGoBack, onGoForward, leftPanelsCollapsed,
     isDarkTheme, onFileCreated, onFileModified, onVaultChanged,
     onSetNoteIcon, onRemoveNoteIcon,
+    isConflicted, onKeepMine, onKeepTheirs,
   } = props
 
   const {
     editor, activeTab, rawLatestContentRef,
     rawMode, diffMode, diffContent, diffLoading,
     handleToggleDiffExclusive, handleToggleRawExclusive,
-    handleEditorChange, handleRenameTabWithSync, handleViewCommitDiff,
+    handleEditorChange, handleViewCommitDiff,
     isLoadingNewTab, activeStatus, showDiffToggle,
   } = useEditorSetup({
-    tabs, activeTabPath, vaultPath, onContentChange, onTitleSync,
-    onRenameTab: props.onRenameTab, onLoadDiff: props.onLoadDiff,
+    tabs, activeTabPath, vaultPath, onContentChange,
+    onLoadDiff: props.onLoadDiff,
     onLoadDiffAtCommit: props.onLoadDiffAtCommit, getNoteStatus,
     rawToggleRef: props.rawToggleRef, diffToggleRef: props.diffToggleRef,
   })
@@ -265,7 +256,7 @@ export const Editor = memo(function Editor(props: EditorProps) {
         onCloseTab={onCloseTab}
         onCreateNote={onCreateNote}
         onReorderTabs={onReorderTabs}
-        onRenameTab={handleRenameTabWithSync}
+        onRenameTab={props.onRenameTab}
         canGoBack={canGoBack}
         canGoForward={canGoForward}
         onGoBack={onGoBack}
@@ -307,6 +298,9 @@ export const Editor = memo(function Editor(props: EditorProps) {
               onTitleChange={onTitleSync}
               onSetNoteIcon={onSetNoteIcon}
               onRemoveNoteIcon={onRemoveNoteIcon}
+              isConflicted={isConflicted}
+              onKeepMine={onKeepMine}
+              onKeepTheirs={onKeepTheirs}
             />
         }
         {(showAIChat || !inspectorCollapsed) && <ResizeHandle onResize={onInspectorResize} />}

src/components/EditorContent.tsx

@@ -8,6 +8,7 @@ import { TitleField } from './TitleField'
 import { NoteIcon } from './NoteIcon'
 import { TrashedNoteBanner } from './TrashedNoteBanner'
 import { ArchivedNoteBanner } from './ArchivedNoteBanner'
+import { ConflictNoteBanner } from './ConflictNoteBanner'
 import { RawEditorView } from './RawEditorView'
 import { countWords } from '../utils/wikilinks'
 import { SingleEditorView } from './SingleEditorView'
@@ -54,6 +55,12 @@ interface EditorContentProps {
   onSetNoteIcon?: (path: string, emoji: string) => void
   /** Called when user removes an emoji icon. */
   onRemoveNoteIcon?: (path: string) => void
+  /** Whether the active note has a merge conflict. */
+  isConflicted?: boolean
+  /** Resolve conflict by keeping the local version. */
+  onKeepMine?: (path: string) => void
+  /** Resolve conflict by keeping the remote version. */
+  onKeepTheirs?: (path: string) => void
 }
 
 function EditorLoadingSkeleton() {
@@ -144,30 +151,6 @@ function ActiveTabBreadcrumb({ activeTab, props }: {
   )
 }
 
-function EditorBody({ activeTab, isLoadingNewTab, entries, editor, diffMode, diffContent, onToggleDiff, rawMode, onRawContentChange, onSave, onNavigateWikilink, onEditorChange, vaultPath, isDarkTheme, isTrashed, rawLatestContentRef }: {
-  activeTab: Tab | null; isLoadingNewTab: boolean; entries: VaultEntry[]
-  editor: ReturnType<typeof useCreateBlockNote>
-  diffMode: boolean; diffContent: string | null; onToggleDiff: () => void
-  rawMode: boolean; onRawContentChange?: (path: string, content: string) => void; onSave?: () => void
-  onNavigateWikilink: (target: string) => void; onEditorChange?: () => void
-  vaultPath?: string; isDarkTheme?: boolean; isTrashed: boolean
-  rawLatestContentRef?: React.MutableRefObject<string | null>
-}) {
-  const showEditor = !diffMode && !rawMode
-  return (
-    <>
-      {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
-      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} isDark={isDarkTheme} latestContentRef={rawLatestContentRef} />
-      {showEditor && activeTab && (
-        <div style={{ display: 'flex', flex: 1, flexDirection: 'column', minHeight: 0 }}>
-          <SingleEditorView editor={editor} entries={entries} onNavigateWikilink={onNavigateWikilink} onChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} editable={!isTrashed} />
-        </div>
-      )}
-      {isLoadingNewTab && showEditor && <EditorLoadingSkeleton />}
-    </>
-  )
-}
-
 export function EditorContent({
   activeTab, isLoadingNewTab, entries, editor,
   diffMode, diffContent, onToggleDiff,
@@ -175,10 +158,15 @@ export function EditorContent({
   onNavigateWikilink, onEditorChange, vaultPath, isDarkTheme,
   onDeleteNote, rawLatestContentRef, onTitleChange,
   onSetNoteIcon, onRemoveNoteIcon,
+  isConflicted, onKeepMine, onKeepTheirs,
   ...breadcrumbProps
 }: EditorContentProps) {
-  const isTrashed = activeTab?.entry.trashed ?? false
-  const showTitleField = activeTab && !diffMode && !rawMode
+  // Look up trashed/archived from the latest vault entries, not the tab snapshot,
+  // so the banner appears regardless of navigation context.
+  const freshEntry = activeTab ? entries.find(e => e.path === activeTab.entry.path) : undefined
+  const isTrashed = freshEntry?.trashed ?? activeTab?.entry.trashed ?? false
+  const isArchived = freshEntry?.archived ?? activeTab?.entry.archived ?? false
+  const showEditor = !diffMode && !rawMode
   const entryIcon = activeTab?.entry.icon ?? null
   const emojiIcon = entryIcon && isEmoji(entryIcon) ? entryIcon : null
 
@@ -204,26 +192,38 @@ export function EditorContent({
           onDeletePermanently={() => onDeleteNote?.(activeTab.entry.path)}
         />
       )}
-      {activeTab?.entry.archived && breadcrumbProps.onUnarchiveNote && (
+      {activeTab && isArchived && breadcrumbProps.onUnarchiveNote && (
         <ArchivedNoteBanner onUnarchive={() => breadcrumbProps.onUnarchiveNote!(activeTab.entry.path)} />
       )}
-      {showTitleField && (
-        <NoteIcon
-          icon={emojiIcon}
-          editable={!isTrashed}
-          onSetIcon={handleSetIcon}
-          onRemoveIcon={handleRemoveIcon}
+      {activeTab && isConflicted && (
+        <ConflictNoteBanner
+          onKeepMine={() => onKeepMine?.(activeTab.entry.path)}
+          onKeepTheirs={() => onKeepTheirs?.(activeTab.entry.path)}
         />
       )}
-      {showTitleField && (
-        <TitleField
-          title={activeTab.entry.title}
-          filename={activeTab.entry.filename}
-          editable={!isTrashed}
-          onTitleChange={(newTitle) => onTitleChange?.(activeTab.entry.path, newTitle)}
-        />
+      {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
+      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} isDark={isDarkTheme} latestContentRef={rawLatestContentRef} />
+      {showEditor && activeTab && (
+        <div className="editor-scroll-area">
+          <div className="title-section">
+            <NoteIcon
+              icon={emojiIcon}
+              editable={!isTrashed}
+              onSetIcon={handleSetIcon}
+              onRemoveIcon={handleRemoveIcon}
+            />
+            <TitleField
+              title={activeTab.entry.title}
+              filename={activeTab.entry.filename}
+              editable={!isTrashed}
+              onTitleChange={(newTitle) => onTitleChange?.(activeTab.entry.path, newTitle)}
+            />
+            <div className="title-section__separator" />
+          </div>
+          <SingleEditorView editor={editor} entries={entries} onNavigateWikilink={onNavigateWikilink} onChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} editable={!isTrashed} />
+        </div>
       )}
-      <EditorBody activeTab={activeTab} isLoadingNewTab={isLoadingNewTab} entries={entries} editor={editor} diffMode={diffMode} diffContent={diffContent} onToggleDiff={onToggleDiff} rawMode={rawMode} onRawContentChange={onRawContentChange} onSave={onSave} onNavigateWikilink={onNavigateWikilink} onEditorChange={onEditorChange} vaultPath={vaultPath} isDarkTheme={isDarkTheme} isTrashed={isTrashed} rawLatestContentRef={rawLatestContentRef} />
+      {isLoadingNewTab && showEditor && <EditorLoadingSkeleton />}
     </div>
   )
 }

src/components/InspectorPanels.test.tsx

@@ -242,6 +242,36 @@ describe('DynamicRelationshipsPanel', () => {
     expect(screen.getByText('My Cool Project')).toBeInTheDocument()
   })
 
+  it('shows emoji icon before label when entry has an emoji', () => {
+    const emojiEntry = makeEntry({
+      path: '/vault/note/rocket.md', filename: 'rocket.md', title: 'Rocket Note', isA: 'Note', icon: '🚀',
+    })
+    render(
+      <DynamicRelationshipsPanel
+        typeEntryMap={{}}
+        frontmatter={{ 'Belongs to': ['[[Rocket Note]]'] }}
+        entries={[emojiEntry]}
+        onNavigate={onNavigate}
+      />
+    )
+    expect(screen.getByText('🚀')).toBeInTheDocument()
+    expect(screen.getByText('Rocket Note')).toBeInTheDocument()
+  })
+
+  it('does not show emoji when entry has no icon', () => {
+    render(
+      <DynamicRelationshipsPanel
+        typeEntryMap={{}}
+        frontmatter={{ 'Belongs to': ['[[project/my-project]]'] }}
+        entries={entries}
+        onNavigate={onNavigate}
+      />
+    )
+    const link = screen.getByText('My Project')
+    const container = link.closest('.group\\/link')
+    expect(container?.textContent).not.toMatch(/^[\p{Emoji_Presentation}]/u)
+  })
+
   describe('relation editing', () => {
     const onUpdateProperty = vi.fn()
     const onDeleteProperty = vi.fn()
@@ -649,6 +679,29 @@ describe('BacklinksPanel', () => {
     fireEvent.click(screen.getByTestId('backlinks-toggle'))
     expect(screen.queryByText('Note A')).not.toBeInTheDocument()
   })
+
+  it('shows emoji icon before backlink title when entry has an emoji', () => {
+    const backlinks = [{
+      entry: makeEntry({ title: 'Starred Note', icon: '⭐' }),
+      context: null,
+    }]
+    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
+    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    expect(screen.getByText('⭐')).toBeInTheDocument()
+    expect(screen.getByText('Starred Note')).toBeInTheDocument()
+  })
+
+  it('does not show emoji when backlink entry has no icon', () => {
+    const backlinks = [{ entry: makeEntry({ title: 'Plain Note' }), context: null }]
+    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
+    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    expect(screen.getByText('Plain Note')).toBeInTheDocument()
+    const btn = screen.getByText('Plain Note').closest('button')
+    const spans = btn?.querySelectorAll('span.shrink-0')
+    // No emoji span should exist (only possible shrink-0 spans are trash icon, not emoji)
+    const emojiSpans = Array.from(spans ?? []).filter(s => /[\p{Emoji_Presentation}]/u.test(s.textContent ?? ''))
+    expect(emojiSpans).toHaveLength(0)
+  })
 })
 
 describe('ReferencedByPanel', () => {

src/components/NoteItem.tsx

@@ -131,7 +131,7 @@ export function NoteItem({ entry, isSelected, isMultiSelected = false, isHighlig
         </div>
       </div>
       {entry.snippet && (
-        <div className="mt-0.5 text-[12px] leading-[1.5] text-muted-foreground" style={{ display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical', overflow: 'hidden' }}>
+        <div className="mt-0.5 text-[12px] leading-[1.5] text-muted-foreground" data-testid="note-snippet" style={{ display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical', overflow: 'hidden' }}>
           {entry.snippet}
         </div>
       )}

src/components/NoteList.test.tsx

@@ -1,7 +1,7 @@
 import { render, screen, fireEvent } from '@testing-library/react'
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { NoteList } from './NoteList'
-import { getSortComparator, filterEntries, countByFilter } from '../utils/noteListHelpers'
+import { getSortComparator, filterEntries, countByFilter, countAllByFilter } from '../utils/noteListHelpers'
 import type { NoteListFilter } from '../utils/noteListHelpers'
 import type { VaultEntry, SidebarSelection } from '../types'
 
@@ -154,6 +154,29 @@ const mockEntries: VaultEntry[] = [
   },
 ]
 
+const makeEntry = (overrides: Partial<VaultEntry> = {}): VaultEntry => ({
+  path: '/test.md', filename: 'test.md', title: 'Test', isA: null,
+  aliases: [], belongsTo: [], relatedTo: [], status: null,
+  archived: false, trashed: false, trashedAt: null,
+  modifiedAt: null, createdAt: null, fileSize: 100, snippet: '', wordCount: 0,
+  relationships: {}, icon: null, color: null, order: null, sidebarLabel: null,
+  template: null, sort: null, view: null, visible: null,
+  outgoingLinks: [], properties: {},
+  ...overrides,
+})
+
+const makeIndexedEntry = (i: number, overrides?: Partial<VaultEntry>): VaultEntry =>
+  makeEntry({
+    path: `/vault/note/note-${i}.md`,
+    filename: `note-${i}.md`,
+    title: `Note ${i}`,
+    isA: 'Note',
+    modifiedAt: 1700000000 - i * 60,
+    fileSize: 500,
+    snippet: `Content of note ${i}`,
+    ...overrides,
+  })
+
 describe('NoteList', () => {
   it('shows empty state when no entries', () => {
     render(<NoteList {...defaultFilterProps} entries={[]} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />)
@@ -200,13 +223,14 @@ describe('NoteList', () => {
     expect(screen.getByText('Related to')).toBeInTheDocument()
   })
 
-  it('filters by topic (relatedTo references)', () => {
+  it('shows entity view with relationship groups for topics', () => {
     render(
-      <NoteList {...defaultFilterProps} entries={mockEntries} selection={{ kind: 'topic', entry: mockEntries[4] }} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
+      <NoteList {...defaultFilterProps} entries={mockEntries} selection={{ kind: 'entity', entry: mockEntries[4] }} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
-    // Build Laputa App has relatedTo: [[topic/software-development]]
+    // Build Laputa App references this topic via relatedTo — should appear in Referenced By
     expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-    expect(screen.queryByText('Facebook Ads Strategy')).not.toBeInTheDocument()
+    // Entity view shows group headers
+    expect(screen.getByText('Referenced By')).toBeInTheDocument()
   })
 
   it('shows search input when search icon is clicked', () => {
@@ -347,35 +371,6 @@ describe('NoteList click behavior', () => {
 })
 
 describe('getSortComparator', () => {
-  const makeEntry = (overrides: Partial<VaultEntry>): VaultEntry => ({
-    path: '/test.md',
-    filename: 'test.md',
-    title: 'Test',
-    isA: null,
-    aliases: [],
-    belongsTo: [],
-    relatedTo: [],
-    status: null,
-    owner: null,
-    cadence: null,
-    archived: false,
-    trashed: false,
-    trashedAt: null,
-    modifiedAt: null,
-    createdAt: null,
-    fileSize: 100,
-    snippet: '',
-    wordCount: 0,
-    relationships: {},
-    icon: null,
-    color: null,
-    order: null,
-    template: null, sort: null,
-    outgoingLinks: [],
-    properties: {},
-    ...overrides,
-  })
-
   it('sorts by modified date descending', () => {
     const a = makeEntry({ title: 'A', modifiedAt: 1000 })
     const b = makeEntry({ title: 'B', modifiedAt: 3000 })
@@ -461,35 +456,6 @@ describe('NoteList sort controls', () => {
     try { localStorage.removeItem('laputa-sort-preferences') } catch { /* noop */ }
   })
 
-  const makeEntry = (overrides: Partial<VaultEntry>): VaultEntry => ({
-    path: '/test.md',
-    filename: 'test.md',
-    title: 'Test',
-    isA: null,
-    aliases: [],
-    belongsTo: [],
-    relatedTo: [],
-    status: null,
-    owner: null,
-    cadence: null,
-    archived: false,
-    trashed: false,
-    trashedAt: null,
-    modifiedAt: null,
-    createdAt: null,
-    fileSize: 100,
-    snippet: '',
-    wordCount: 0,
-    relationships: {},
-    icon: null,
-    color: null,
-    order: null,
-    template: null, sort: null,
-    outgoingLinks: [],
-    properties: {},
-    ...overrides,
-  })
-
   it('shows sort button in note list header for flat view', () => {
     render(
       <NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -504,11 +470,21 @@ describe('NoteList sort controls', () => {
     expect(screen.getByTestId('sort-button-Children')).toBeInTheDocument()
   })
 
-  it('opens sort menu on click and shows all options', () => {
+  const renderListAndOpenSort = (entries: VaultEntry[] = mockEntries) => {
     render(
-      <NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
+      <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
     fireEvent.click(screen.getByTestId('sort-button-__list__'))
+  }
+
+  const zamEntries = [
+    makeEntry({ path: '/a.md', title: 'Zebra', modifiedAt: 3000 }),
+    makeEntry({ path: '/b.md', title: 'Alpha', modifiedAt: 1000 }),
+    makeEntry({ path: '/c.md', title: 'Middle', modifiedAt: 2000 }),
+  ]
+
+  it('opens sort menu on click and shows all options', () => {
+    renderListAndOpenSort()
     expect(screen.getByTestId('sort-menu-__list__')).toBeInTheDocument()
     expect(screen.getByTestId('sort-option-modified')).toBeInTheDocument()
     expect(screen.getByTestId('sort-option-created')).toBeInTheDocument()
@@ -517,20 +493,12 @@ describe('NoteList sort controls', () => {
   })
 
   it('changes sort order when an option is selected', () => {
-    const entries = [
-      makeEntry({ path: '/a.md', title: 'Zebra', modifiedAt: 3000 }),
-      makeEntry({ path: '/b.md', title: 'Alpha', modifiedAt: 1000 }),
-      makeEntry({ path: '/c.md', title: 'Middle', modifiedAt: 2000 }),
-    ]
-    render(
-      <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
-    )
-    // Default sort: by modified (Zebra first)
+    renderListAndOpenSort(zamEntries)
+    // Default sort: by modified (Zebra first) — menu is already open
     let titles = screen.getAllByText(/Zebra|Alpha|Middle/).map((el) => el.textContent)
     expect(titles).toEqual(['Zebra', 'Middle', 'Alpha'])
 
     // Switch to title sort
-    fireEvent.click(screen.getByTestId('sort-button-__list__'))
     fireEvent.click(screen.getByTestId('sort-option-title'))
 
     // Now should be alphabetical
@@ -539,21 +507,14 @@ describe('NoteList sort controls', () => {
   })
 
   it('closes sort menu after selecting an option', () => {
-    render(
-      <NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
-    )
-    fireEvent.click(screen.getByTestId('sort-button-__list__'))
+    renderListAndOpenSort()
     expect(screen.getByTestId('sort-menu-__list__')).toBeInTheDocument()
     fireEvent.click(screen.getByTestId('sort-option-title'))
     expect(screen.queryByTestId('sort-menu-__list__')).not.toBeInTheDocument()
   })
 
   it('shows direction arrows in sort dropdown menu', () => {
-    render(
-      <NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
-    )
-    fireEvent.click(screen.getByTestId('sort-button-__list__'))
-    // Each option should have asc and desc direction buttons
+    renderListAndOpenSort()
     expect(screen.getByTestId('sort-dir-asc-modified')).toBeInTheDocument()
     expect(screen.getByTestId('sort-dir-desc-modified')).toBeInTheDocument()
     expect(screen.getByTestId('sort-dir-asc-title')).toBeInTheDocument()
@@ -561,20 +522,12 @@ describe('NoteList sort controls', () => {
   })
 
   it('reverses sort order when clicking direction arrow', () => {
-    const entries = [
-      makeEntry({ path: '/a.md', title: 'Zebra', modifiedAt: 3000 }),
-      makeEntry({ path: '/b.md', title: 'Alpha', modifiedAt: 1000 }),
-      makeEntry({ path: '/c.md', title: 'Middle', modifiedAt: 2000 }),
-    ]
-    render(
-      <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
-    )
+    renderListAndOpenSort(zamEntries)
     // Default sort: modified descending (Zebra first at 3000)
     let titles = screen.getAllByText(/Zebra|Alpha|Middle/).map((el) => el.textContent)
     expect(titles).toEqual(['Zebra', 'Middle', 'Alpha'])
 
     // Click the asc arrow for modified to reverse
-    fireEvent.click(screen.getByTestId('sort-button-__list__'))
     fireEvent.click(screen.getByTestId('sort-dir-asc-modified'))
 
     // Now ascending: Alpha (1000) first
@@ -806,17 +759,9 @@ describe('filterEntries — trash', () => {
     expect(result.find((e) => e.title === 'Old Draft Notes')).toBeUndefined()
   })
 
-  it('topic filter excludes trashed entries', () => {
-    const topicEntry: VaultEntry = { ...mockEntries[4] } // Software Development topic
-    const trashedWithTopic: VaultEntry = {
-      ...trashedEntry,
-      relatedTo: ['[[topic/software-development]]'],
-    }
-    const all = [...mockEntries, trashedWithTopic]
-    const result = filterEntries(all, { kind: 'topic', entry: topicEntry })
-    expect(result.find((e) => e.title === 'Old Draft Notes')).toBeUndefined()
-    // Normal entry with that topic should still appear
-    expect(result.find((e) => e.title === 'Build Laputa App')).toBeDefined()
+  it('entity filter returns empty (entity view uses relationship groups instead)', () => {
+    const result = filterEntries(mockEntries, { kind: 'entity', entry: mockEntries[4] })
+    expect(result).toHaveLength(0)
   })
 })
 
@@ -904,37 +849,8 @@ describe('NoteList — trash view', () => {
 // --- Virtual list performance tests ---
 
 describe('NoteList — virtual list with large datasets', () => {
-  const makeEntry = (i: number, overrides?: Partial<VaultEntry>): VaultEntry => ({
-    path: `/vault/note/note-${i}.md`,
-    filename: `note-${i}.md`,
-    title: `Note ${i}`,
-    isA: 'Note',
-    aliases: [],
-    belongsTo: [],
-    relatedTo: [],
-    status: null,
-    owner: null,
-    cadence: null,
-    archived: false,
-    trashed: false,
-    trashedAt: null,
-    modifiedAt: 1700000000 - i * 60,
-    createdAt: null,
-    fileSize: 500,
-    snippet: `Content of note ${i}`,
-    wordCount: 0,
-    relationships: {},
-    icon: null,
-    color: null,
-    order: null,
-    template: null, sort: null,
-    outgoingLinks: [],
-    properties: {},
-    ...overrides,
-  })
-
   it('renders 9000 entries without crashing', { timeout: 30000 }, () => {
-    const largeDataset = Array.from({ length: 9000 }, (_, i) => makeEntry(i))
+    const largeDataset = Array.from({ length: 9000 }, (_, i) => makeIndexedEntry(i))
     const { container } = render(
       <NoteList {...defaultFilterProps} entries={largeDataset} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
@@ -943,7 +859,7 @@ describe('NoteList — virtual list with large datasets', () => {
   })
 
   it('renders items from a large dataset via Virtuoso', () => {
-    const largeDataset = Array.from({ length: 500 }, (_, i) => makeEntry(i))
+    const largeDataset = Array.from({ length: 500 }, (_, i) => makeIndexedEntry(i))
     render(
       <NoteList {...defaultFilterProps} entries={largeDataset} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
@@ -953,9 +869,9 @@ describe('NoteList — virtual list with large datasets', () => {
 
   it('search filters large dataset correctly', () => {
     const entries = [
-      makeEntry(0, { title: 'Alpha Strategy' }),
-      ...Array.from({ length: 998 }, (_, i) => makeEntry(i + 1, { title: `Filler Note ${i + 1}` })),
-      makeEntry(999, { title: 'Beta Strategy' }),
+      makeIndexedEntry(0, { title: 'Alpha Strategy' }),
+      ...Array.from({ length: 998 }, (_, i) => makeIndexedEntry(i + 1, { title: `Filler Note ${i + 1}` })),
+      makeIndexedEntry(999, { title: 'Beta Strategy' }),
     ]
     render(
       <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -969,9 +885,9 @@ describe('NoteList — virtual list with large datasets', () => {
 
   it('sorting works with large dataset', () => {
     const entries = [
-      makeEntry(0, { title: 'Zebra', modifiedAt: 1000 }),
-      makeEntry(1, { title: 'Alpha', modifiedAt: 3000 }),
-      ...Array.from({ length: 100 }, (_, i) => makeEntry(i + 2, { title: `Mid ${i}`, modifiedAt: 2000 - i })),
+      makeIndexedEntry(0, { title: 'Zebra', modifiedAt: 1000 }),
+      makeIndexedEntry(1, { title: 'Alpha', modifiedAt: 3000 }),
+      ...Array.from({ length: 100 }, (_, i) => makeIndexedEntry(i + 2, { title: `Mid ${i}`, modifiedAt: 2000 - i })),
     ]
     render(
       <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -983,8 +899,8 @@ describe('NoteList — virtual list with large datasets', () => {
 
   it('section group filter works with large mixed-type dataset', () => {
     const entries = [
-      ...Array.from({ length: 100 }, (_, i) => makeEntry(i, { isA: 'Project', title: `Project ${i}` })),
-      ...Array.from({ length: 200 }, (_, i) => makeEntry(100 + i, { isA: 'Note', title: `Note ${i}` })),
+      ...Array.from({ length: 100 }, (_, i) => makeIndexedEntry(i, { isA: 'Project', title: `Project ${i}` })),
+      ...Array.from({ length: 200 }, (_, i) => makeIndexedEntry(100 + i, { isA: 'Note', title: `Note ${i}` })),
     ]
     render(
       <NoteList {...defaultFilterProps} entries={entries} selection={{ kind: 'sectionGroup', type: 'Project' }} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -994,7 +910,7 @@ describe('NoteList — virtual list with large datasets', () => {
   })
 
   it('selection highlighting works in virtualized list', () => {
-    const entries = Array.from({ length: 100 }, (_, i) => makeEntry(i))
+    const entries = Array.from({ length: 100 }, (_, i) => makeIndexedEntry(i))
     const selected = entries[5]
     render(
       <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={selected} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -1004,7 +920,7 @@ describe('NoteList — virtual list with large datasets', () => {
 
   it('click handler works on virtualized items', () => {
     noopReplace.mockClear()
-    const entries = Array.from({ length: 100 }, (_, i) => makeEntry(i))
+    const entries = Array.from({ length: 100 }, (_, i) => makeIndexedEntry(i))
     render(
       <NoteList {...defaultFilterProps} entries={entries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
@@ -1204,68 +1120,34 @@ describe('NoteList — multi-select', () => {
     expect(screen.getByText('2 selected')).toBeInTheDocument()
   })
 
-  it('bulk archive calls onBulkArchive and clears selection', () => {
-    const onBulkArchive = vi.fn()
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} onBulkArchive={onBulkArchive} />)
+  const selectTwoNotes = (extraProps: Record<string, unknown> = {}) => {
+    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} {...extraProps} />)
     fireEvent.click(screen.getByText('Build Laputa App'))
     fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
-    fireEvent.click(screen.getByTestId('bulk-archive-btn'))
-    expect(onBulkArchive).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
-    expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
-  })
+  }
 
-  it('bulk trash calls onBulkTrash and clears selection', () => {
-    const onBulkTrash = vi.fn()
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} onBulkTrash={onBulkTrash} />)
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
-    fireEvent.click(screen.getByTestId('bulk-trash-btn'))
-    expect(onBulkTrash).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
+  it.each([
+    { label: 'bulk archive via button', prop: 'onBulkArchive', trigger: () => fireEvent.click(screen.getByTestId('bulk-archive-btn')) },
+    { label: 'bulk trash via button', prop: 'onBulkTrash', trigger: () => fireEvent.click(screen.getByTestId('bulk-trash-btn')) },
+    { label: 'Cmd+E archives', prop: 'onBulkArchive', trigger: () => fireEvent.keyDown(window, { key: 'e', metaKey: true }) },
+    { label: 'Cmd+Backspace trashes', prop: 'onBulkTrash', trigger: () => fireEvent.keyDown(window, { key: 'Backspace', metaKey: true }) },
+    { label: 'Cmd+Delete trashes', prop: 'onBulkTrash', trigger: () => fireEvent.keyDown(window, { key: 'Delete', metaKey: true }) },
+  ])('$label selected notes and clears selection', ({ prop, trigger }) => {
+    const handler = vi.fn()
+    selectTwoNotes({ [prop]: handler })
+    trigger()
+    expect(handler).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
     expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
   })
 
   it('clear button on bulk action bar clears selection', () => {
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />)
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
+    selectTwoNotes()
     expect(screen.getByTestId('bulk-action-bar')).toBeInTheDocument()
     fireEvent.click(screen.getByTestId('bulk-clear-btn'))
     expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
     expect(screen.queryByTestId('multi-selected-item')).not.toBeInTheDocument()
   })
 
-  it('Cmd+E archives selected notes when multiselect is active', () => {
-    const onBulkArchive = vi.fn()
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} onBulkArchive={onBulkArchive} />)
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
-    expect(screen.getByTestId('bulk-action-bar')).toBeInTheDocument()
-    fireEvent.keyDown(window, { key: 'e', metaKey: true })
-    expect(onBulkArchive).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
-    expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
-  })
-
-  it('Cmd+Backspace trashes selected notes when multiselect is active', () => {
-    const onBulkTrash = vi.fn()
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} onBulkTrash={onBulkTrash} />)
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
-    expect(screen.getByTestId('bulk-action-bar')).toBeInTheDocument()
-    fireEvent.keyDown(window, { key: 'Backspace', metaKey: true })
-    expect(onBulkTrash).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
-    expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
-  })
-
-  it('Cmd+Delete trashes selected notes when multiselect is active', () => {
-    const onBulkTrash = vi.fn()
-    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} onBulkTrash={onBulkTrash} />)
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    fireEvent.click(screen.getByText('Facebook Ads Strategy'), { shiftKey: true })
-    fireEvent.keyDown(window, { key: 'Delete', metaKey: true })
-    expect(onBulkTrash).toHaveBeenCalledWith([mockEntries[0].path, mockEntries[1].path])
-    expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
-  })
-
   it('no bulk action bar when nothing is selected', () => {
     render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />)
     expect(screen.queryByTestId('bulk-action-bar')).not.toBeInTheDocument()
@@ -1367,17 +1249,6 @@ describe('NoteList — traffic light padding when sidebar collapsed', () => {
 })
 
 describe('countByFilter', () => {
-  const makeEntry = (overrides: Partial<VaultEntry>): VaultEntry => ({
-    path: '/test.md', filename: 'test.md', title: 'Test', isA: null,
-    aliases: [], belongsTo: [], relatedTo: [], status: null,
-    archived: false, trashed: false, trashedAt: null,
-    modifiedAt: null, createdAt: null, fileSize: 100, snippet: '', wordCount: 0,
-    relationships: {}, icon: null, color: null, order: null, sidebarLabel: null,
-    template: null, sort: null, view: null, visible: null,
-    outgoingLinks: [], properties: {},
-    ...overrides,
-  })
-
   it('counts open, archived, and trashed notes per type', () => {
     const entries = [
       makeEntry({ path: '/1.md', isA: 'Project' }),
@@ -1404,17 +1275,6 @@ describe('countByFilter', () => {
 })
 
 describe('NoteList — filter pills', () => {
-  const makeEntry = (overrides: Partial<VaultEntry>): VaultEntry => ({
-    path: '/test.md', filename: 'test.md', title: 'Test', isA: null,
-    aliases: [], belongsTo: [], relatedTo: [], status: null,
-    archived: false, trashed: false, trashedAt: null,
-    modifiedAt: 1700000000, createdAt: null, fileSize: 100, snippet: '', wordCount: 0,
-    relationships: {}, icon: null, color: null, order: null, sidebarLabel: null,
-    template: null, sort: null, view: null, visible: null,
-    outgoingLinks: [], properties: {},
-    ...overrides,
-  })
-
   const projectEntries = [
     makeEntry({ path: '/p1.md', title: 'Open Project 1', isA: 'Project' }),
     makeEntry({ path: '/p2.md', title: 'Open Project 2', isA: 'Project' }),
@@ -1433,11 +1293,44 @@ describe('NoteList — filter pills', () => {
     expect(screen.getByTestId('filter-pill-trashed')).toBeInTheDocument()
   })
 
-  it('does not show filter pills in All Notes view', () => {
+  it('shows filter pills in All Notes view', () => {
     render(
       <NoteList {...defaultFilterProps} entries={projectEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
     )
-    expect(screen.queryByTestId('filter-pills')).not.toBeInTheDocument()
+    expect(screen.getByTestId('filter-pills')).toBeInTheDocument()
+    expect(screen.getByTestId('filter-pill-open')).toBeInTheDocument()
+    expect(screen.getByTestId('filter-pill-archived')).toBeInTheDocument()
+    expect(screen.getByTestId('filter-pill-trashed')).toBeInTheDocument()
+  })
+
+  it('shows correct All Notes count badges across all types', () => {
+    render(
+      <NoteList {...defaultFilterProps} entries={projectEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
+    )
+    // projectEntries: 2 open Projects + 1 open Note = 3 open, 1 archived, 1 trashed
+    const openPill = screen.getByTestId('filter-pill-open')
+    const archivedPill = screen.getByTestId('filter-pill-archived')
+    const trashedPill = screen.getByTestId('filter-pill-trashed')
+    expect(openPill).toHaveTextContent('3')
+    expect(archivedPill).toHaveTextContent('1')
+    expect(trashedPill).toHaveTextContent('1')
+  })
+
+  it('shows archived notes in All Notes when filter is archived', () => {
+    render(
+      <NoteList noteListFilter="archived" onNoteListFilterChange={noopFilterChange} entries={projectEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
+    )
+    expect(screen.getByText('Archived Project')).toBeInTheDocument()
+    expect(screen.queryByText('Open Project 1')).not.toBeInTheDocument()
+    expect(screen.queryByText('Some Note')).not.toBeInTheDocument()
+  })
+
+  it('shows trashed notes in All Notes when filter is trashed', () => {
+    render(
+      <NoteList noteListFilter="trashed" onNoteListFilterChange={noopFilterChange} entries={projectEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
+    )
+    expect(screen.getByText('Trashed Project')).toBeInTheDocument()
+    expect(screen.queryByText('Open Project 1')).not.toBeInTheDocument()
   })
 
   it('shows correct count badges for each filter', () => {
@@ -1491,17 +1384,6 @@ describe('NoteList — filter pills', () => {
 })
 
 describe('NoteList — filterEntries with subFilter', () => {
-  const makeEntry = (overrides: Partial<VaultEntry>): VaultEntry => ({
-    path: '/test.md', filename: 'test.md', title: 'Test', isA: null,
-    aliases: [], belongsTo: [], relatedTo: [], status: null,
-    archived: false, trashed: false, trashedAt: null,
-    modifiedAt: null, createdAt: null, fileSize: 100, snippet: '', wordCount: 0,
-    relationships: {}, icon: null, color: null, order: null, sidebarLabel: null,
-    template: null, sort: null, view: null, visible: null,
-    outgoingLinks: [], properties: {},
-    ...overrides,
-  })
-
   const entries = [
     makeEntry({ path: '/1.md', title: 'Active', isA: 'Project' }),
     makeEntry({ path: '/2.md', title: 'Archived', isA: 'Project', archived: true }),
@@ -1528,4 +1410,33 @@ describe('NoteList — filterEntries with subFilter', () => {
     const result = filterEntries(entries, { kind: 'sectionGroup', type: 'Project' })
     expect(result.map(e => e.title)).toEqual(['Active'])
   })
+
+  it('filters all notes by open sub-filter', () => {
+    const result = filterEntries(entries, { kind: 'filter', filter: 'all' }, 'open')
+    expect(result.map(e => e.title)).toEqual(['Active', 'Other'])
+  })
+
+  it('filters all notes by archived sub-filter', () => {
+    const result = filterEntries(entries, { kind: 'filter', filter: 'all' }, 'archived')
+    expect(result.map(e => e.title)).toEqual(['Archived'])
+  })
+
+  it('filters all notes by trashed sub-filter', () => {
+    const result = filterEntries(entries, { kind: 'filter', filter: 'all' }, 'trashed')
+    expect(result.map(e => e.title)).toEqual(['Trashed'])
+  })
+})
+
+describe('countAllByFilter', () => {
+  it('counts all entries by filter status', () => {
+    const entries = [
+      makeEntry({ path: '/1.md', isA: 'Project' }),
+      makeEntry({ path: '/2.md', isA: 'Note' }),
+      makeEntry({ path: '/3.md', isA: 'Project', archived: true }),
+      makeEntry({ path: '/4.md', isA: 'Note', trashed: true }),
+      makeEntry({ path: '/5.md', isA: 'Person', archived: true, trashed: true }),
+    ]
+    const counts = countAllByFilter(entries)
+    expect(counts).toEqual({ open: 2, archived: 1, trashed: 2 })
+  })
 })

src/components/NoteList.tsx

@@ -1,7 +1,7 @@
 import { useState, useMemo, useCallback, useEffect, memo } from 'react'
-import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus } from '../types'
+import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus, InboxPeriod } from '../types'
 import type { NoteListFilter } from '../utils/noteListHelpers'
-import { countByFilter } from '../utils/noteListHelpers'
+import { countByFilter, countAllByFilter, countInboxByPeriod } from '../utils/noteListHelpers'
 import { NoteItem } from './NoteItem'
 import { prefetchNoteContent } from '../hooks/useTabManagement'
 import { BulkActionBar } from './BulkActionBar'
@@ -9,6 +9,7 @@ import { useMultiSelect } from '../hooks/useMultiSelect'
 import { useNoteListKeyboard } from '../hooks/useNoteListKeyboard'
 import { NoteListHeader } from './note-list/NoteListHeader'
 import { FilterPills } from './note-list/FilterPills'
+import { InboxFilterPills } from './note-list/InboxFilterPills'
 import { EntityView, ListView } from './note-list/NoteListViews'
 import { DeletedNotesBanner } from './note-list/TrashWarningBanner'
 import { routeNoteClick, toggleSetMember, resolveHeaderTitle } from './note-list/noteListUtils'
@@ -23,6 +24,8 @@ interface NoteListProps {
   selectedNote: VaultEntry | null
   noteListFilter: NoteListFilter
   onNoteListFilterChange: (filter: NoteListFilter) => void
+  inboxPeriod?: InboxPeriod
+  onInboxPeriodChange?: (period: InboxPeriod) => void
   modifiedFiles?: ModifiedFile[]
   modifiedFilesError?: string | null
   getNoteStatus?: (path: string) => NoteStatus
@@ -37,25 +40,34 @@ interface NoteListProps {
   onEmptyTrash?: () => void
   onUpdateTypeSort?: (path: string, key: string, value: string | number | boolean | string[] | null) => void
   updateEntry?: (path: string, patch: Partial<VaultEntry>) => void
+  onOpenInNewWindow?: (entry: VaultEntry) => void
 }
 
-function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNoteListFilterChange, modifiedFiles, modifiedFilesError, getNoteStatus, sidebarCollapsed, onSelectNote, onReplaceActiveTab, onCreateNote, onBulkArchive, onBulkTrash, onBulkRestore, onBulkDeletePermanently, onEmptyTrash, onUpdateTypeSort, updateEntry }: NoteListProps) {
+function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNoteListFilterChange, inboxPeriod = 'month', onInboxPeriodChange, modifiedFiles, modifiedFilesError, getNoteStatus, sidebarCollapsed, onSelectNote, onReplaceActiveTab, onCreateNote, onBulkArchive, onBulkTrash, onBulkRestore, onBulkDeletePermanently, onEmptyTrash, onUpdateTypeSort, updateEntry, onOpenInNewWindow }: NoteListProps) {
   const { modifiedPathSet, modifiedSuffixes, resolvedGetNoteStatus } = useModifiedFilesState(modifiedFiles, getNoteStatus)
 
   const isSectionGroup = selection.kind === 'sectionGroup'
-  const subFilter = isSectionGroup ? noteListFilter : undefined
+  const isInboxView = selection.kind === 'filter' && selection.filter === 'inbox'
+  const isAllNotesView = selection.kind === 'filter' && selection.filter === 'all'
+  const showFilterPills = isSectionGroup || isAllNotesView
+  const subFilter = showFilterPills ? noteListFilter : undefined
 
   const filterCounts = useMemo(
-    () => isSectionGroup ? countByFilter(entries, selection.type) : { open: 0, archived: 0, trashed: 0 },
-    [entries, isSectionGroup, selection],
+    () => isSectionGroup ? countByFilter(entries, selection.type) : isAllNotesView ? countAllByFilter(entries) : { open: 0, archived: 0, trashed: 0 },
+    [entries, isSectionGroup, isAllNotesView, selection],
   )
 
-  const { listSort, listDirection, customProperties, handleSortChange, sortPrefs, typeDocument } = useNoteListSort({ entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, onUpdateTypeSort, updateEntry })
+  const inboxCounts = useMemo(
+    () => isInboxView ? countInboxByPeriod(entries) : { week: 0, month: 0, quarter: 0, all: 0 },
+    [entries, isInboxView],
+  )
+
+  const { listSort, listDirection, customProperties, handleSortChange, sortPrefs, typeDocument } = useNoteListSort({ entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod: isInboxView ? inboxPeriod : undefined, onUpdateTypeSort, updateEntry })
   const { search, setSearch, query, searchVisible, toggleSearch } = useNoteListSearch()
   const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
 
   const typeEntryMap = useTypeEntryMap(entries)
-  const { isEntityView, isTrashView, isArchivedView, searched, searchedGroups, expiredTrashCount } = useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter })
+  const { isEntityView, isTrashView, isArchivedView, searched, searchedGroups, expiredTrashCount } = useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod: isInboxView ? inboxPeriod : undefined })
   const isChangesView = selection.kind === 'filter' && selection.filter === 'changes'
   const deletedCount = useMemo(
     () => isChangesView ? (modifiedFiles ?? []).filter((f) => f.status === 'deleted').length : 0,
@@ -65,11 +77,11 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
 
   const noteListKeyboard = useNoteListKeyboard({ items: searched, selectedNotePath: selectedNote?.path ?? null, onOpen: onReplaceActiveTab, enabled: !isEntityView })
   const multiSelect = useMultiSelect(searched, selectedNote?.path ?? null)
-  useEffect(() => { multiSelect.clear() }, [selection]) // eslint-disable-line react-hooks/exhaustive-deps -- clear on selection change only
+  useEffect(() => { multiSelect.clear() }, [selection, noteListFilter]) // eslint-disable-line react-hooks/exhaustive-deps -- clear on selection/filter change
 
   const handleClickNote = useCallback((entry: VaultEntry, e: React.MouseEvent) => {
-    routeNoteClick(entry, e, { onReplace: onReplaceActiveTab, onSelect: onSelectNote, multiSelect })
-  }, [onReplaceActiveTab, onSelectNote, multiSelect])
+    routeNoteClick(entry, e, { onReplace: onReplaceActiveTab, onSelect: onSelectNote, onOpenInNewWindow, multiSelect })
+  }, [onReplaceActiveTab, onSelectNote, onOpenInNewWindow, multiSelect])
 
   const handleBulkArchive = useCallback(() => { const paths = [...multiSelect.selectedPaths]; multiSelect.clear(); onBulkArchive?.(paths) }, [multiSelect, onBulkArchive])
   const handleBulkTrash = useCallback(() => { const paths = [...multiSelect.selectedPaths]; multiSelect.clear(); onBulkTrash?.(paths) }, [multiSelect, onBulkTrash])
@@ -90,13 +102,14 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
   return (
     <div className="flex flex-col select-none overflow-hidden border-r border-border bg-card text-foreground" style={{ height: '100%' }}>
       <NoteListHeader title={title} typeDocument={typeDocument} isEntityView={isEntityView} isTrashView={isTrashView} trashCount={searched.length} listSort={listSort} listDirection={listDirection} customProperties={customProperties} sidebarCollapsed={sidebarCollapsed} searchVisible={searchVisible} search={search} onSortChange={handleSortChange} onCreateNote={onCreateNote} onOpenType={onReplaceActiveTab} onToggleSearch={toggleSearch} onSearchChange={setSearch} onEmptyTrash={onEmptyTrash} />
-      {isSectionGroup && <FilterPills active={noteListFilter} counts={filterCounts} onChange={onNoteListFilterChange} />}
+      {showFilterPills && <FilterPills active={noteListFilter} counts={filterCounts} onChange={onNoteListFilterChange} />}
+      {isInboxView && onInboxPeriodChange && <InboxFilterPills active={inboxPeriod} counts={inboxCounts} onChange={onInboxPeriodChange} />}
       <div className="flex flex-1 flex-col overflow-hidden outline-none" style={{ minHeight: 0 }} tabIndex={0} onKeyDown={noteListKeyboard.handleKeyDown} onFocus={noteListKeyboard.handleFocus} data-testid="note-list-container">
         <div className="flex-1 overflow-hidden" style={{ minHeight: 0 }}>
           {entitySelection ? (
             <EntityView entity={entitySelection.entry} groups={searchedGroups} query={query} collapsedGroups={collapsedGroups} sortPrefs={sortPrefs} onToggleGroup={toggleGroup} onSortChange={handleSortChange} renderItem={renderItem} typeEntryMap={typeEntryMap} onClickNote={handleClickNote} />
           ) : (
-            <ListView isTrashView={isTrashView} isArchivedView={isArchivedView} isChangesView={isChangesView} changesError={modifiedFilesError} expiredTrashCount={expiredTrashCount} deletedCount={deletedCount} searched={searched} query={query} renderItem={renderItem} virtuosoRef={noteListKeyboard.virtuosoRef} />
+            <ListView isTrashView={isTrashView} isArchivedView={isArchivedView} isChangesView={isChangesView} isInboxView={isInboxView} changesError={modifiedFilesError} expiredTrashCount={expiredTrashCount} deletedCount={deletedCount} searched={searched} query={query} renderItem={renderItem} virtuosoRef={noteListKeyboard.virtuosoRef} />
           )}
         </div>
         {isChangesView && deletedCount > 0 && <DeletedNotesBanner count={deletedCount} />}

src/components/Sidebar.test.tsx

@@ -359,13 +359,13 @@ describe('Sidebar', () => {
     expect(screen.getByText('Trading')).toBeInTheDocument()
   })
 
-  it('calls onSelect with topic kind when clicking a topic', () => {
+  it('calls onSelect with entity kind when clicking a topic', () => {
     const onSelect = vi.fn()
     render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={onSelect} />)
     fireEvent.click(screen.getByLabelText('Expand Topics'))
     fireEvent.click(screen.getByText('Software Development'))
     expect(onSelect).toHaveBeenCalledWith({
-      kind: 'topic',
+      kind: 'entity',
       entry: mockEntries[4],
     })
   })
@@ -418,6 +418,36 @@ describe('Sidebar', () => {
     expect(onSelect).toHaveBeenCalledWith({ kind: 'filter', filter: 'changes' })
   })
 
+  describe('Changes and Pulse in secondary bottom area', () => {
+    it('renders Changes outside the main top nav section', () => {
+      render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} modifiedCount={3} isGitVault />)
+      const changesEl = screen.getByText('Changes')
+      // Changes should be inside the secondary bottom area, not the top nav
+      const secondaryArea = changesEl.closest('[data-testid="sidebar-secondary"]')
+      expect(secondaryArea).not.toBeNull()
+    })
+
+    it('renders Pulse outside the main top nav section', () => {
+      render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} isGitVault />)
+      const pulseEl = screen.getByText('Pulse')
+      const secondaryArea = pulseEl.closest('[data-testid="sidebar-secondary"]')
+      expect(secondaryArea).not.toBeNull()
+    })
+
+    it('does not render Changes or Pulse inside the top nav section', () => {
+      render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} modifiedCount={3} isGitVault />)
+      const topNav = screen.getByTestId('sidebar-top-nav')
+      expect(topNav.textContent).not.toContain('Changes')
+      expect(topNav.textContent).not.toContain('Pulse')
+    })
+
+    it('shows Changes badge count in secondary area', () => {
+      render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} modifiedCount={7} isGitVault />)
+      const secondaryArea = screen.getByTestId('sidebar-secondary')
+      expect(secondaryArea.textContent).toContain('7')
+    })
+  })
+
   describe('dynamic custom type sections', () => {
     const entriesWithCustomTypes: VaultEntry[] = [
       ...mockEntries,
@@ -914,6 +944,63 @@ describe('Sidebar', () => {
     })
   })
 
+  describe('Note type in sidebar', () => {
+    const noteEntries: VaultEntry[] = [
+      ...mockEntries,
+      {
+        path: '/vault/note.md', filename: 'note.md', title: 'Note', isA: 'Type',
+        aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null, cadence: null,
+        archived: false, trashed: false, trashedAt: null, modifiedAt: 1700000000, createdAt: null,
+        fileSize: 200, snippet: '', wordCount: 0, relationships: {},
+        icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/explicit-note.md', filename: 'explicit-note.md', title: 'Explicit Note',
+        isA: 'Note', aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null,
+        cadence: null, archived: false, trashed: false, trashedAt: null, modifiedAt: 1700000000,
+        createdAt: null, fileSize: 300, snippet: '', wordCount: 0, relationships: {},
+        icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/untyped-note.md', filename: 'untyped-note.md', title: 'Untyped Note',
+        isA: null, aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null,
+        cadence: null, archived: false, trashed: false, trashedAt: null, modifiedAt: 1700000000,
+        createdAt: null, fileSize: 150, snippet: '', wordCount: 0, relationships: {},
+        icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
+        outgoingLinks: [], properties: {},
+      },
+    ]
+
+    it('shows Notes section when Note entries exist', () => {
+      render(<Sidebar entries={noteEntries} selection={defaultSelection} onSelect={() => {}} />)
+      expect(screen.getByText('Notes')).toBeInTheDocument()
+    })
+
+    it('includes both explicit and untyped notes under Notes section', () => {
+      render(<Sidebar entries={noteEntries} selection={defaultSelection} onSelect={() => {}} />)
+      fireEvent.click(screen.getByLabelText('Expand Notes'))
+      expect(screen.getByText('Explicit Note')).toBeInTheDocument()
+      expect(screen.getByText('Untyped Note')).toBeInTheDocument()
+    })
+
+    it('shows Notes section for untyped entries even without explicit Note entries', () => {
+      const untypedOnly: VaultEntry[] = [
+        {
+          path: '/vault/plain.md', filename: 'plain.md', title: 'Plain Note',
+          isA: null, aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null,
+          cadence: null, archived: false, trashed: false, trashedAt: null, modifiedAt: 1700000000,
+          createdAt: null, fileSize: 100, snippet: '', wordCount: 0, relationships: {},
+          icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
+          outgoingLinks: [], properties: {},
+        },
+      ]
+      render(<Sidebar entries={untypedOnly} selection={defaultSelection} onSelect={() => {}} />)
+      expect(screen.getByText('Notes')).toBeInTheDocument()
+    })
+  })
+
   it('renders exactly one section for a hyphenated custom type like Monday Ideas', () => {
     const entriesWithMondayIdeas: VaultEntry[] = [
       ...mockEntries,
@@ -951,4 +1038,24 @@ describe('Sidebar', () => {
     const mondaySections = screen.getAllByText(/Monday Ideas/i)
     expect(mondaySections).toHaveLength(1)
   })
+
+  it('renders Inbox as the first item in the top nav', () => {
+    render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} inboxCount={5} />)
+    const topNav = screen.getByTestId('sidebar-top-nav')
+    const items = topNav.children
+    expect(items[0].textContent).toContain('Inbox')
+    expect(items[1].textContent).toContain('All Notes')
+  })
+
+  it('displays inbox count badge', () => {
+    render(<Sidebar entries={[]} selection={defaultSelection} onSelect={() => {}} inboxCount={12} />)
+    expect(screen.getByText('12')).toBeInTheDocument()
+  })
+
+  it('calls onSelect with inbox filter when clicking Inbox', () => {
+    const onSelect = vi.fn()
+    render(<Sidebar entries={[]} selection={defaultSelection} onSelect={onSelect} inboxCount={3} />)
+    fireEvent.click(screen.getByText('Inbox'))
+    expect(onSelect).toHaveBeenCalledWith({ kind: 'filter', filter: 'inbox' })
+  })
 })

src/components/Sidebar.tsx

@@ -12,7 +12,7 @@ import {
 } from '@dnd-kit/sortable'
 import { CSS } from '@dnd-kit/utilities'
 import {
-  FileText, Trash, Archive, CaretLeft, GitDiff, Pulse,
+  FileText, Trash, Archive, CaretLeft, GitDiff, Pulse, Tray,
 } from '@phosphor-icons/react'
 import { GitCommitHorizontal, SlidersHorizontal } from 'lucide-react'
 import {
@@ -34,6 +34,7 @@ interface SidebarProps {
   onRenameSection?: (typeName: string, label: string) => void
   onToggleTypeVisibility?: (typeName: string) => void
   modifiedCount?: number
+  inboxCount?: number
   onCommitPush?: () => void
   onCollapse?: () => void
   isGitVault?: boolean
@@ -115,7 +116,9 @@ function SortableSection({ group, sectionProps }: {
     & { entries: VaultEntry[]; collapsed: Record<string, boolean>; onToggle: (type: string) => void; renamingType: string | null; renameInitialValue: string }
 }) {
   const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: group.type })
-  const items = sectionProps.entries.filter((e) => e.isA === group.type && !e.archived && !e.trashed)
+  const items = sectionProps.entries.filter((e) =>
+    !e.archived && !e.trashed && (group.type === 'Note' ? (e.isA === 'Note' || !e.isA) : e.isA === group.type),
+  )
   const isCollapsed = sectionProps.collapsed[group.type] ?? true
   const isRenaming = sectionProps.renamingType === group.type
 
@@ -220,7 +223,7 @@ export const Sidebar = memo(function Sidebar({
   entries, selection, onSelect, onSelectNote, onCreateType, onCreateNewType,
   onCustomizeType, onUpdateTypeTemplate, onReorderSections, onRenameSection,
   onToggleTypeVisibility,
-  modifiedCount = 0, onCommitPush, onCollapse, isGitVault = false,
+  modifiedCount = 0, inboxCount = 0, onCommitPush, onCollapse, isGitVault = false,
 }: SidebarProps) {
   const [collapsed, setCollapsed] = useState<Record<string, boolean>>({})
   const [customizeTarget, setCustomizeTarget] = useState<string | null>(null)
@@ -302,14 +305,11 @@ export const Sidebar = memo(function Sidebar({
       <SidebarTitleBar onCollapse={onCollapse} />
       <nav className="flex-1 overflow-y-auto">
         {/* Top nav */}
-        <div className="border-b border-border" style={{ padding: '4px 6px' }}>
+        <div className="border-b border-border" data-testid="sidebar-top-nav" style={{ padding: '4px 6px' }}>
+          <NavItem icon={Tray} label="Inbox" count={inboxCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'inbox' })} badgeClassName="text-muted-foreground" badgeStyle={{ background: 'var(--muted)' }} onClick={() => onSelect({ kind: 'filter', filter: 'inbox' })} />
           <NavItem icon={FileText} label="All Notes" count={activeCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'all' })} badgeClassName="bg-primary text-primary-foreground" onClick={() => onSelect({ kind: 'filter', filter: 'all' })} />
           <NavItem icon={Archive} label="Archive" count={archivedCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'archived' })} badgeClassName="text-muted-foreground" badgeStyle={{ background: 'var(--muted)' }} onClick={() => onSelect({ kind: 'filter', filter: 'archived' })} />
           <NavItem icon={Trash} label="Trash" count={trashedCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'trash' })} activeClassName="bg-destructive/10 text-destructive" badgeClassName="text-muted-foreground" badgeStyle={{ background: 'var(--muted)' }} onClick={() => onSelect({ kind: 'filter', filter: 'trash' })} />
-          {modifiedCount > 0 && (
-            <NavItem icon={GitDiff} label="Changes" count={modifiedCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'changes' })} activeClassName="bg-[color:var(--accent-orange)]/10 text-[var(--accent-orange)]" badgeClassName="text-white" badgeStyle={{ background: 'var(--accent-orange)' }} onClick={() => onSelect({ kind: 'filter', filter: 'changes' })} />
-          )}
-          <NavItem icon={Pulse} label="Pulse" isActive={isSelectionActive(selection, { kind: 'filter', filter: 'pulse' })} disabled={!isGitVault} disabledTooltip="Pulse is only available for git-enabled vaults" onClick={isGitVault ? () => onSelect({ kind: 'filter', filter: 'pulse' }) : undefined} />
         </div>
 
         {/* Sections header + visibility popover */}
@@ -333,6 +333,13 @@ export const Sidebar = memo(function Sidebar({
         </DndContext>
       </nav>
 
+      {/* Secondary area: Changes + Pulse */}
+      <div className="shrink-0 border-t border-border" data-testid="sidebar-secondary" style={{ padding: '4px 6px' }}>
+        {modifiedCount > 0 && (
+          <NavItem icon={GitDiff} label="Changes" count={modifiedCount} isActive={isSelectionActive(selection, { kind: 'filter', filter: 'changes' })} activeClassName="bg-[color:var(--accent-orange)]/10 text-[var(--accent-orange)]" badgeClassName="text-white" badgeStyle={{ background: 'var(--accent-orange)' }} onClick={() => onSelect({ kind: 'filter', filter: 'changes' })} compact />
+        )}
+        <NavItem icon={Pulse} label="Pulse" isActive={isSelectionActive(selection, { kind: 'filter', filter: 'pulse' })} disabled={!isGitVault} disabledTooltip="Pulse is only available for git-enabled vaults" onClick={isGitVault ? () => onSelect({ kind: 'filter', filter: 'pulse' }) : undefined} compact />
+      </div>
       <CommitButton modifiedCount={modifiedCount} onClick={onCommitPush} />
       <ContextMenuOverlay pos={contextMenuPos} type={contextMenuType} innerRef={contextMenuRef} onOpenCustomize={(type) => { closeContextMenu(); setCustomizeTarget(type) }} onStartRename={handleStartRename} />
       <CustomizeOverlay target={customizeTarget} typeEntryMap={typeEntryMap} innerRef={popoverRef} onCustomize={handleCustomize} onChangeTemplate={handleChangeTemplate} onClose={closeCustomizeTarget} />

src/components/SidebarParts.tsx

@@ -1,6 +1,7 @@
 import { type ComponentType, useState, useEffect, useRef } from 'react'
 import type { VaultEntry, SidebarSelection } from '../types'
 import { cn } from '@/lib/utils'
+import { isEmoji } from '../utils/emoji'
 import { ChevronRight, ChevronDown, Plus } from 'lucide-react'
 import { getTypeColor, getTypeLightColor } from '../utils/typeColors'
 import { type IconProps } from '@phosphor-icons/react'
@@ -18,15 +19,14 @@ export function isSelectionActive(current: SidebarSelection, check: SidebarSelec
   switch (check.kind) {
     case 'filter': return (current as typeof check).filter === check.filter
     case 'sectionGroup': return (current as typeof check).type === check.type
-    case 'entity':
-    case 'topic': return (current as typeof check).entry.path === check.entry.path
+    case 'entity': return (current as typeof check).entry.path === check.entry.path
     default: return false
   }
 }
 
 // --- NavItem ---
 
-export function NavItem({ icon: Icon, label, count, isActive, activeClassName = 'bg-primary/10 text-primary', badgeClassName, badgeStyle, onClick, disabled, disabledTooltip }: {
+export function NavItem({ icon: Icon, label, count, isActive, activeClassName = 'bg-primary/10 text-primary', badgeClassName, badgeStyle, onClick, disabled, disabledTooltip, compact }: {
   icon: ComponentType<IconProps>
   label: string
   count?: number
@@ -37,25 +37,30 @@ export function NavItem({ icon: Icon, label, count, isActive, activeClassName =
   onClick?: () => void
   disabled?: boolean
   disabledTooltip?: string
+  compact?: boolean
 }) {
+  const iconSize = compact ? 14 : 16
+  const textClass = compact ? 'text-[12px]' : 'text-[13px]'
+  const padding = compact ? '4px 16px' : '6px 16px'
+
   if (disabled) {
     return (
-      <div className="flex select-none items-center gap-2 rounded text-foreground" style={{ padding: '6px 16px', borderRadius: 4, opacity: 0.4, cursor: 'not-allowed' }} title={disabledTooltip ?? "Coming soon"}>
-        <Icon size={16} />
-        <span className="flex-1 text-[13px] font-medium">{label}</span>
+      <div className="flex select-none items-center gap-2 rounded text-foreground" style={{ padding, borderRadius: 4, opacity: 0.4, cursor: 'not-allowed' }} title={disabledTooltip ?? "Coming soon"}>
+        <Icon size={iconSize} />
+        <span className={cn("flex-1 font-medium", textClass)}>{label}</span>
       </div>
     )
   }
   return (
     <div
       className={cn("flex cursor-pointer select-none items-center gap-2 rounded transition-colors", isActive ? activeClassName : "text-foreground hover:bg-accent")}
-      style={{ padding: '6px 16px', borderRadius: 4 }}
+      style={{ padding, borderRadius: 4 }}
       onClick={onClick}
     >
-      <Icon size={16} />
-      <span className="flex-1 text-[13px] font-medium">{label}</span>
+      <Icon size={iconSize} />
+      <span className={cn("flex-1 font-medium", textClass)}>{label}</span>
       {count !== undefined && count > 0 && (
-        <span className={cn("flex items-center justify-center", badgeClassName)} style={{ height: 20, borderRadius: 9999, padding: '0 6px', fontSize: 10, ...badgeStyle }}>
+        <span className={cn("flex items-center justify-center", badgeClassName)} style={{ height: compact ? 18 : 20, borderRadius: 9999, padding: '0 6px', fontSize: 10, ...badgeStyle }}>
           {count}
         </span>
       )}
@@ -83,8 +88,8 @@ export interface SectionContentProps {
   onRenameCancel?: () => void
 }
 
-function childSelection(type: string, entry: VaultEntry): SidebarSelection {
-  return type === 'Topic' ? { kind: 'topic', entry } : { kind: 'entity', entry }
+function childSelection(entry: VaultEntry): SidebarSelection {
+  return { kind: 'entity', entry }
 }
 
 function resolveCreateHandler(type: string, onCreateType?: (type: string) => void, onCreateNewType?: () => void): (() => void) | undefined {
@@ -123,7 +128,7 @@ export function SectionContent({
       />
       {!isCollapsed && items.length > 0 && (
         <SectionChildList
-          items={items} type={type} selection={selection}
+          items={items} selection={selection}
           sectionColor={sectionColor} sectionLightColor={sectionLightColor}
           onSelect={onSelect} onSelectNote={onSelectNote}
         />
@@ -132,19 +137,19 @@ export function SectionContent({
   )
 }
 
-function SectionChildList({ items, type, selection, sectionColor, sectionLightColor, onSelect, onSelectNote }: {
-  items: VaultEntry[]; type: string; selection: SidebarSelection
+function SectionChildList({ items, selection, sectionColor, sectionLightColor, onSelect, onSelectNote }: {
+  items: VaultEntry[]; selection: SidebarSelection
   sectionColor: string; sectionLightColor: string
   onSelect: (sel: SidebarSelection) => void; onSelectNote?: (entry: VaultEntry) => void
 }) {
   return (
     <div style={{ display: 'flex', flexDirection: 'column', gap: 4 }}>
       {items.map((entry) => {
-        const sel = childSelection(type, entry)
+        const sel = childSelection(entry)
         const active = isSelectionActive(selection, sel)
         return (
           <SectionChildItem
-            key={entry.path} title={entry.title} isActive={active}
+            key={entry.path} title={entry.title} icon={entry.icon} isActive={active}
             sectionColor={active ? sectionColor : undefined}
             sectionLightColor={active ? sectionLightColor : undefined}
             onClick={() => { onSelect(sel); onSelectNote?.(entry) }}
@@ -233,8 +238,8 @@ function SectionHeader({ label, type, Icon, sectionColor, isCollapsed, isActive,
   )
 }
 
-function SectionChildItem({ title, isActive, sectionColor, sectionLightColor, onClick }: {
-  title: string; isActive: boolean
+function SectionChildItem({ title, icon, isActive, sectionColor, sectionLightColor, onClick }: {
+  title: string; icon?: string | null; isActive: boolean
   sectionColor?: string; sectionLightColor?: string
   onClick: () => void
 }) {
@@ -244,7 +249,7 @@ function SectionChildItem({ title, isActive, sectionColor, sectionLightColor, on
       style={{ padding: '4px 16px 4px 28px', ...(isActive && { backgroundColor: sectionLightColor, color: sectionColor }) }}
       onClick={onClick}
     >
-      {title}
+      {icon && isEmoji(icon) && <span className="mr-1">{icon}</span>}{title}
     </div>
   )
 }

src/components/StatusBar.test.tsx

@@ -428,6 +428,40 @@ describe('StatusBar', () => {
     expect(onReindexVault).toHaveBeenCalledOnce()
   })
 
+  it('shows Pull required label when syncStatus is pull_required', () => {
+    render(
+      <StatusBar noteCount={100} vaultPath="/Users/luca/Laputa" vaults={vaults} onSwitchVault={vi.fn()} syncStatus="pull_required" />
+    )
+    expect(screen.getByText('Pull required')).toBeInTheDocument()
+  })
+
+  it('calls onPullAndPush when clicking Pull required badge', () => {
+    const onPullAndPush = vi.fn()
+    render(
+      <StatusBar noteCount={100} vaultPath="/Users/luca/Laputa" vaults={vaults} onSwitchVault={vi.fn()} syncStatus="pull_required" onPullAndPush={onPullAndPush} />
+    )
+    fireEvent.click(screen.getByTestId('status-sync'))
+    expect(onPullAndPush).toHaveBeenCalledOnce()
+  })
+
+  it('shows git status popup when clicking idle sync badge', () => {
+    render(
+      <StatusBar
+        noteCount={100}
+        vaultPath="/Users/luca/Laputa"
+        vaults={vaults}
+        onSwitchVault={vi.fn()}
+        syncStatus="idle"
+        remoteStatus={{ branch: 'main', ahead: 2, behind: 1, hasRemote: true }}
+      />
+    )
+    fireEvent.click(screen.getByTestId('status-sync'))
+    expect(screen.getByTestId('git-status-popup')).toBeInTheDocument()
+    expect(screen.getByText('main')).toBeInTheDocument()
+    expect(screen.getByText(/2 ahead/)).toBeInTheDocument()
+    expect(screen.getByText(/1 behind/)).toBeInTheDocument()
+  })
+
   it('hides indexed time badge when no lastIndexedTime', () => {
     render(
       <StatusBar

src/components/StatusBar.tsx

@@ -1,6 +1,6 @@
 import { useState, useRef, useEffect } from 'react'
-import { Package, RefreshCw, FileText, Bell, Settings, FolderOpen, Check, Github, CircleDot, AlertTriangle, Loader2, GitCommitHorizontal, Search, X, Cpu } from 'lucide-react'
-import type { LastCommitInfo, SyncStatus } from '../types'
+import { Package, RefreshCw, FileText, Bell, Settings, FolderOpen, Check, Github, CircleDot, AlertTriangle, Loader2, GitCommitHorizontal, Search, X, Cpu, ArrowDown, GitBranch } from 'lucide-react'
+import type { GitRemoteStatus, LastCommitInfo, SyncStatus } from '../types'
 import type { IndexingProgress } from '../hooks/useIndexing'
 import type { McpStatus } from '../hooks/useMcpStatus'
 import { openExternalUrl } from '../utils/url'
@@ -27,7 +27,9 @@ interface StatusBarProps {
   lastSyncTime?: number | null
   conflictCount?: number
   lastCommitInfo?: LastCommitInfo | null
+  remoteStatus?: GitRemoteStatus | null
   onTriggerSync?: () => void
+  onPullAndPush?: () => void
   onOpenConflictResolver?: () => void
   zoomLevel?: number
   onZoomReset?: () => void
@@ -159,10 +161,10 @@ function VaultMenu({ vaults, vaultPath, onSwitchVault, onOpenLocalFolder, onConn
 const ICON_STYLE = { display: 'flex', alignItems: 'center', gap: 4 } as const
 const DISABLED_STYLE = { display: 'flex', alignItems: 'center', opacity: 0.4, cursor: 'not-allowed' } as const
 const SEP_STYLE = { color: 'var(--border)' } as const
-const SYNC_ICON_MAP: Record<string, typeof RefreshCw> = { syncing: Loader2, conflict: AlertTriangle }
+const SYNC_ICON_MAP: Record<string, typeof RefreshCw> = { syncing: Loader2, conflict: AlertTriangle, pull_required: ArrowDown }
 
-const SYNC_LABELS: Record<string, string> = { syncing: 'Syncing…', conflict: 'Conflict', error: 'Sync failed' }
-const SYNC_COLORS: Record<string, string> = { conflict: 'var(--accent-orange)', error: 'var(--muted-foreground)' }
+const SYNC_LABELS: Record<string, string> = { syncing: 'Syncing…', conflict: 'Conflict', error: 'Sync failed', pull_required: 'Pull required' }
+const SYNC_COLORS: Record<string, string> = { conflict: 'var(--accent-orange)', error: 'var(--muted-foreground)', pull_required: 'var(--accent-orange)' }
 
 function formatElapsedSync(lastSyncTime: number | null): string {
   if (!lastSyncTime) return 'Not synced'
@@ -201,21 +203,114 @@ function CommitBadge({ info }: { info: LastCommitInfo }) {
   )
 }
 
-function SyncBadge({ status, lastSyncTime, onTriggerSync, onOpenConflictResolver }: { status: SyncStatus; lastSyncTime: number | null; onTriggerSync?: () => void; onOpenConflictResolver?: () => void }) {
+function syncBadgeTitle(status: SyncStatus): string {
+  if (status === 'conflict') return 'Click to resolve conflicts'
+  if (status === 'syncing') return 'Syncing…'
+  if (status === 'pull_required') return 'Click to pull from remote and push'
+  return 'Click to sync now'
+}
+
+function SyncBadge({ status, lastSyncTime, remoteStatus, onTriggerSync, onPullAndPush, onOpenConflictResolver }: { status: SyncStatus; lastSyncTime: number | null; remoteStatus?: GitRemoteStatus | null; onTriggerSync?: () => void; onPullAndPush?: () => void; onOpenConflictResolver?: () => void }) {
+  const [showPopup, setShowPopup] = useState(false)
+  const popupRef = useRef<HTMLDivElement>(null)
   const SyncIcon = SYNC_ICON_MAP[status] ?? RefreshCw
   const isSyncing = status === 'syncing'
   const isConflict = status === 'conflict'
-  const handleClick = isConflict ? onOpenConflictResolver : onTriggerSync
+  const isPullRequired = status === 'pull_required'
+
+  const handleClick = () => {
+    if (isConflict) { onOpenConflictResolver?.(); return }
+    if (isPullRequired) { onPullAndPush?.(); return }
+    setShowPopup(v => !v)
+  }
+
+  useEffect(() => {
+    if (!showPopup) return
+    const handleOutside = (e: MouseEvent) => {
+      if (popupRef.current && !popupRef.current.contains(e.target as Node)) setShowPopup(false)
+    }
+    document.addEventListener('mousedown', handleOutside)
+    return () => document.removeEventListener('mousedown', handleOutside)
+  }, [showPopup])
+
   return (
-    <span
-      role="button"
-      onClick={handleClick}
-      style={{ ...ICON_STYLE, cursor: handleClick ? 'pointer' : 'default', padding: '2px 4px', borderRadius: 3 }}
-      title={isConflict ? 'Click to resolve conflicts' : isSyncing ? 'Syncing…' : 'Click to sync now'}
-      data-testid="status-sync"
+    <div ref={popupRef} style={{ position: 'relative' }}>
+      <span
+        role="button"
+        onClick={handleClick}
+        style={{ ...ICON_STYLE, cursor: 'pointer', padding: '2px 4px', borderRadius: 3 }}
+        title={syncBadgeTitle(status)}
+        data-testid="status-sync"
+      >
+        <SyncIcon size={13} style={{ color: syncIconColor(status) }} className={isSyncing ? 'animate-spin' : ''} />{formatSyncLabel(status, lastSyncTime)}
+      </span>
+      {showPopup && (
+        <GitStatusPopup
+          status={status}
+          remoteStatus={remoteStatus ?? null}
+          onPull={onTriggerSync}
+          onClose={() => setShowPopup(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+function GitStatusPopup({ status, remoteStatus, onPull, onClose }: { status: SyncStatus; remoteStatus: GitRemoteStatus | null; onPull?: () => void; onClose: () => void }) {
+  const branch = remoteStatus?.branch || '—'
+  const ahead = remoteStatus?.ahead ?? 0
+  const behind = remoteStatus?.behind ?? 0
+  const hasRemote = remoteStatus?.hasRemote ?? false
+
+  return (
+    <div
+      data-testid="git-status-popup"
+      style={{
+        position: 'absolute', bottom: '100%', left: 0, marginBottom: 4,
+        background: 'var(--sidebar)', border: '1px solid var(--border)',
+        borderRadius: 6, padding: 8, minWidth: 220, boxShadow: '0 4px 12px rgba(0,0,0,0.3)',
+        zIndex: 1000, fontSize: 12, color: 'var(--foreground)',
+      }}
     >
-      <SyncIcon size={13} style={{ color: syncIconColor(status) }} className={isSyncing ? 'animate-spin' : ''} />{formatSyncLabel(status, lastSyncTime)}
-    </span>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginBottom: 6 }}>
+        <GitBranch size={13} style={{ color: 'var(--muted-foreground)' }} />
+        <span style={{ fontWeight: 500 }}>{branch}</span>
+      </div>
+
+      {hasRemote && (
+        <div style={{ display: 'flex', gap: 12, marginBottom: 6, color: 'var(--muted-foreground)' }}>
+          {ahead > 0 && <span title={`${ahead} commit${ahead > 1 ? 's' : ''} ahead of remote`}>↑ {ahead} ahead</span>}
+          {behind > 0 && <span title={`${behind} commit${behind > 1 ? 's' : ''} behind remote`} style={{ color: 'var(--accent-orange)' }}>↓ {behind} behind</span>}
+          {ahead === 0 && behind === 0 && <span>In sync with remote</span>}
+        </div>
+      )}
+
+      {!hasRemote && (
+        <div style={{ color: 'var(--muted-foreground)', marginBottom: 6 }}>No remote configured</div>
+      )}
+
+      <div style={{ display: 'flex', alignItems: 'center', gap: 6, marginBottom: 4, color: 'var(--muted-foreground)' }}>
+        Status: {status === 'idle' ? 'Synced' : status === 'pull_required' ? 'Pull required' : status === 'conflict' ? 'Conflicts' : status === 'error' ? 'Error' : status === 'syncing' ? 'Syncing…' : status}
+      </div>
+
+      {hasRemote && (
+        <div style={{ display: 'flex', gap: 4, marginTop: 6, borderTop: '1px solid var(--border)', paddingTop: 6 }}>
+          <button
+            onClick={() => { onPull?.(); onClose() }}
+            style={{
+              display: 'flex', alignItems: 'center', gap: 4, padding: '3px 8px',
+              background: 'transparent', border: '1px solid var(--border)', borderRadius: 4,
+              fontSize: 11, color: 'var(--foreground)', cursor: 'pointer',
+            }}
+            onMouseEnter={e => { e.currentTarget.style.background = 'var(--hover)' }}
+            onMouseLeave={e => { e.currentTarget.style.background = 'transparent' }}
+            data-testid="git-status-pull-btn"
+          >
+            <ArrowDown size={11} />Pull
+          </button>
+        </div>
+      )}
+    </div>
   )
 }
 
@@ -356,7 +451,7 @@ function McpBadge({ status, onInstall }: { status: McpStatus; onInstall?: () =>
   )
 }
 
-export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onSwitchVault, onOpenSettings, onOpenLocalFolder, onConnectGitHub, onClickPending, hasGitHub, syncStatus = 'idle', lastSyncTime = null, conflictCount = 0, lastCommitInfo, onTriggerSync, onOpenConflictResolver, zoomLevel = 100, onZoomReset, buildNumber, onCheckForUpdates, indexingProgress, lastIndexedTime, onRetryIndexing, onReindexVault, onRemoveVault, mcpStatus, onInstallMcp }: StatusBarProps) {
+export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onSwitchVault, onOpenSettings, onOpenLocalFolder, onConnectGitHub, onClickPending, hasGitHub, syncStatus = 'idle', lastSyncTime = null, conflictCount = 0, lastCommitInfo, remoteStatus, onTriggerSync, onPullAndPush, onOpenConflictResolver, zoomLevel = 100, onZoomReset, buildNumber, onCheckForUpdates, indexingProgress, lastIndexedTime, onRetryIndexing, onReindexVault, onRemoveVault, mcpStatus, onInstallMcp }: StatusBarProps) {
   const [, setTick] = useState(0)
   useEffect(() => {
     const id = setInterval(() => setTick((t) => t + 1), 30_000)
@@ -378,7 +473,7 @@ export function StatusBar({ noteCount, modifiedCount = 0, vaultPath, vaults, onS
           onMouseLeave={onCheckForUpdates ? (e) => { e.currentTarget.style.background = 'transparent' } : undefined}
         ><Package size={13} />{buildNumber ?? 'b?'}</span>
         <span style={SEP_STYLE}>|</span>
-        <SyncBadge status={syncStatus} lastSyncTime={lastSyncTime} onTriggerSync={onTriggerSync} onOpenConflictResolver={onOpenConflictResolver} />
+        <SyncBadge status={syncStatus} lastSyncTime={lastSyncTime} remoteStatus={remoteStatus} onTriggerSync={onTriggerSync} onPullAndPush={onPullAndPush} onOpenConflictResolver={onOpenConflictResolver} />
         {lastCommitInfo && <CommitBadge info={lastCommitInfo} />}
         <ConflictBadge count={conflictCount} onClick={onOpenConflictResolver} />
         <PendingBadge count={modifiedCount} onClick={onClickPending} />

src/components/TabBar.tsx

@@ -5,6 +5,7 @@ import { cn } from '@/lib/utils'
 import { X } from 'lucide-react'
 import { Plus, Columns, ArrowsOutSimple, ArrowLeft, ArrowRight } from '@phosphor-icons/react'
 import { computeTabMaxWidth } from '@/utils/tabLayout'
+import { isEmoji } from '../utils/emoji'
 
 interface Tab {
   entry: VaultEntry
@@ -181,7 +182,7 @@ function DropIndicator({ side }: { side: 'left' | 'right' }) {
 }
 
 const STATUS_DOT: Record<string, { color: string; testId: string; title: string; pulse?: boolean }> = {
-  unsaved: { color: 'var(--accent-blue, #3b82f6)', testId: 'tab-unsaved-indicator', title: 'Unsaved — Cmd+S to save' },
+  unsaved: { color: 'var(--accent-blue, #3b82f6)', testId: 'tab-unsaved-indicator', title: 'Auto-saving…', pulse: true },
   pendingSave: { color: 'var(--accent-green)', testId: 'tab-pending-save-indicator', title: 'Saving to disk…', pulse: true },
   new: { color: 'var(--accent-green)', testId: 'tab-new-indicator', title: 'New (uncommitted)' },
   modified: { color: 'var(--accent-orange)', testId: 'tab-modified-indicator', title: 'Modified (uncommitted)' },
@@ -241,7 +242,8 @@ function TabItem({ tab, isActive, isEditing, noteStatus, isDragging, showDropBef
       {isEditing ? (
         <InlineTabEdit initialValue={tab.entry.title} onSave={onRenameSave} onCancel={onRenameCancel} />
       ) : (
-        <span className="truncate" style={noteStatus === 'unsaved' ? { fontStyle: 'italic' } : undefined} onDoubleClick={(e) => { e.stopPropagation(); onDoubleClick() }}>
+        <span className="truncate" onDoubleClick={(e) => { e.stopPropagation(); onDoubleClick() }}>
+          {tab.entry.icon && isEmoji(tab.entry.icon) && <span className="mr-1">{tab.entry.icon}</span>}
           {tab.entry.title}
         </span>
       )}

src/components/TitleField.test.tsx

@@ -72,6 +72,29 @@ describe('TitleField', () => {
     expect(input).toHaveValue('Original')
   })
 
+  it('shows new title optimistically after commit (before prop updates)', () => {
+    const onChange = vi.fn()
+    const { rerender } = render(<TitleField title="Old Title" filename="old-title.md" onTitleChange={onChange} />)
+    const input = screen.getByTestId('title-field-input')
+    fireEvent.focus(input)
+    fireEvent.change(input, { target: { value: 'New Title' } })
+    fireEvent.blur(input)
+    // After commit, should show new title even though prop is still "Old Title"
+    expect(input).toHaveValue('New Title')
+    // After prop updates to match, should still show new title
+    rerender(<TitleField title="New Title" filename="new-title.md" onTitleChange={onChange} />)
+    expect(input).toHaveValue('New Title')
+  })
+
+  it('resets optimistic title when prop changes from external source', () => {
+    const onChange = vi.fn()
+    const { rerender } = render(<TitleField title="Title A" filename="title-a.md" onTitleChange={onChange} />)
+    const input = screen.getByTestId('title-field-input')
+    // Simulate external title change (e.g., tab switch)
+    rerender(<TitleField title="Title B" filename="title-b.md" onTitleChange={onChange} />)
+    expect(input).toHaveValue('Title B')
+  })
+
   it('responds to laputa:focus-editor event with selectTitle', () => {
     render(<TitleField title="Focus Me" filename="focus-me.md" onTitleChange={() => {}} />)
     const input = screen.getByTestId('title-field-input')

src/components/TitleField.tsx

@@ -9,20 +9,50 @@ interface TitleFieldProps {
   onTitleChange: (newTitle: string) => void
 }
 
+/** Manages local edit + optimistic title state for TitleField. */
+function useOptimisticTitle(title: string, onTitleChange: (t: string) => void) {
+  const [localValue, setLocalValue] = useState<string | null>(null)
+  // [optimisticTitle, forPropTitle]: shown after commit until title prop catches up
+  const [optimistic, setOptimistic] = useState<[string, string] | null>(null)
+  const isFocusedRef = useRef(false)
+
+  // Clear optimistic once the prop changes (rename completed or tab switched)
+  const optimisticValue = optimistic && optimistic[1] === title ? optimistic[0] : null
+  const value = localValue ?? optimisticValue ?? title
+  const isEditing = localValue !== null || optimisticValue !== null
+
+  const handleFocus = useCallback(() => {
+    isFocusedRef.current = true
+    setLocalValue(title)
+  }, [title])
+
+  const commitTitle = useCallback(() => {
+    isFocusedRef.current = false
+    const trimmed = (localValue ?? '').trim()
+    if (trimmed && trimmed !== title) {
+      setLocalValue(null)
+      setOptimistic([trimmed, title])
+      onTitleChange(trimmed)
+    } else {
+      setLocalValue(null)
+    }
+  }, [localValue, title, onTitleChange])
+
+  const revert = useCallback(() => setLocalValue(null), [])
+  const setEdit = useCallback((v: string) => setLocalValue(v), [])
+
+  return { value, isEditing, handleFocus, commitTitle, revert, setEdit }
+}
+
 /**
  * Dedicated title input field above the editor.
  * Displays the title as an editable field and shows the resulting filename below.
- * Replaces the H1 block as the primary title editing surface.
  */
 export function TitleField({ title, filename, editable = true, onTitleChange }: TitleFieldProps) {
-  const [localValue, setLocalValue] = useState<string | null>(null)
   const inputRef = useRef<HTMLInputElement>(null)
-  const isFocusedRef = useRef(false)
+  const { value, isEditing, handleFocus, commitTitle, revert, setEdit } =
+    useOptimisticTitle(title, onTitleChange)
 
-  // The displayed value: use local edit value while focused, otherwise prop title
-  const value = localValue ?? title
-
-  // Listen for laputa:focus-editor with selectTitle to focus this field
   useEffect(() => {
     const handler = (e: Event) => {
       const detail = (e as CustomEvent).detail
@@ -35,34 +65,20 @@ export function TitleField({ title, filename, editable = true, onTitleChange }:
     return () => window.removeEventListener('laputa:focus-editor', handler)
   }, [])
 
-  const handleFocus = useCallback(() => {
-    isFocusedRef.current = true
-    setLocalValue(title)
-  }, [title])
-
-  const commitTitle = useCallback(() => {
-    isFocusedRef.current = false
-    const trimmed = (localValue ?? '').trim()
-    if (trimmed && trimmed !== title) {
-      onTitleChange(trimmed)
-    }
-    setLocalValue(null) // reset to prop-driven
-  }, [localValue, title, onTitleChange])
-
   const handleKeyDown = useCallback((e: React.KeyboardEvent) => {
     if (e.key === 'Enter') {
       e.preventDefault()
       inputRef.current?.blur()
     }
     if (e.key === 'Escape') {
-      setLocalValue(null) // revert to prop
+      revert()
       inputRef.current?.blur()
     }
-  }, [])
+  }, [revert])
 
   const expectedSlug = slugify(value.trim() || title)
   const currentStem = filename.replace(/\.md$/, '')
-  const showFilename = localValue !== null || currentStem !== expectedSlug
+  const showFilename = isEditing || currentStem !== expectedSlug
 
   return (
     <div className="title-field" data-testid="title-field">
@@ -70,7 +86,7 @@ export function TitleField({ title, filename, editable = true, onTitleChange }:
         ref={inputRef}
         className="title-field__input"
         value={value}
-        onChange={e => setLocalValue(e.target.value)}
+        onChange={e => setEdit(e.target.value)}
         onFocus={handleFocus}
         onBlur={commitTitle}
         onKeyDown={handleKeyDown}

src/components/TypeSelector.tsx

@@ -22,17 +22,19 @@ function TypeSelectorItem({ type, typeColorKeys, typeIconKeys }: {
 function ReadOnlyType({ isA, customColorKey, onNavigate }: { isA?: string | null; customColorKey?: string | null; onNavigate?: (target: string) => void }) {
   if (!isA) return null
   return (
-    <div className="flex min-w-0 items-center justify-between gap-2 px-1.5">
+    <div className="grid min-w-0 grid-cols-2 items-center gap-2 px-1.5">
       <span className="font-mono-overline shrink-0 text-muted-foreground">Type</span>
-      {onNavigate ? (
-        <button
-          className="min-w-0 truncate border-none text-right cursor-pointer hover:opacity-80"
-          style={{ background: getTypeLightColor(isA, customColorKey), color: getTypeColor(isA, customColorKey), borderRadius: 6, padding: '2px 8px', fontSize: 12, fontWeight: 500 }}
-          onClick={() => onNavigate(isA.toLowerCase())} title={isA}
-        >{isA}</button>
-      ) : (
-        <span className="text-right text-[12px] text-secondary-foreground">{isA}</span>
-      )}
+      <div className="min-w-0">
+        {onNavigate ? (
+          <button
+            className="min-w-0 max-w-full truncate border-none cursor-pointer ring-inset hover:ring-1 hover:ring-current"
+            style={{ background: getTypeLightColor(isA, customColorKey), color: getTypeColor(isA, customColorKey), borderRadius: 6, padding: '2px 8px', fontSize: 12, fontWeight: 500 }}
+            onClick={() => onNavigate(isA.toLowerCase())} title={isA}
+          >{isA}</button>
+        ) : (
+          <span className="text-[12px] text-secondary-foreground">{isA}</span>
+        )}
+      </div>
     </div>
   )
 }
@@ -51,17 +53,28 @@ export function TypeSelector({ isA, customColorKey, availableTypes, typeColorKey
     ? [...availableTypes, isA].sort((a, b) => a.localeCompare(b))
     : availableTypes
 
+  const typeColor = isA ? getTypeColor(isA, typeColorKeys[isA] ?? customColorKey) : undefined
+  const typeLightColor = isA ? getTypeLightColor(isA, typeColorKeys[isA] ?? customColorKey) : undefined
+
   return (
-    <div className="flex min-w-0 items-center justify-between gap-2 px-1.5" data-testid="type-selector">
+    <div className="grid min-w-0 grid-cols-2 items-center gap-2 px-1.5" data-testid="type-selector">
       <span className="font-mono-overline shrink-0 text-muted-foreground">Type</span>
-      <Select value={currentValue} onValueChange={v => onUpdateProperty('type', v === TYPE_NONE ? null : v)}>
-        <SelectTrigger
-          size="sm"
-          className="h-[26px] shrink-0 gap-1 border-border bg-muted px-1.5 py-0 shadow-none"
-          style={{ fontSize: 12, borderRadius: 4 }}
-        >
-          <SelectValue placeholder="None" />
-        </SelectTrigger>
+      <div className="min-w-0">
+        <Select value={currentValue} onValueChange={v => onUpdateProperty('type', v === TYPE_NONE ? null : v)}>
+          <SelectTrigger
+            size="sm"
+            className={`h-auto max-w-full gap-1 border-none shadow-none [&_svg]:text-current ring-inset${isA ? ' hover:ring-1 hover:ring-current' : ' bg-muted hover:opacity-80'}`}
+            style={{
+              background: typeLightColor ?? undefined,
+              color: typeColor ?? undefined,
+              borderRadius: 6,
+              padding: '4px 8px',
+              fontSize: 12,
+              fontWeight: 500,
+            }}
+          >
+            <SelectValue placeholder="None" />
+          </SelectTrigger>
         <SelectContent position="popper" side="left">
           <SelectItem value={TYPE_NONE}>None</SelectItem>
           <SelectSeparator />
@@ -71,7 +84,8 @@ export function TypeSelector({ isA, customColorKey, availableTypes, typeColorKey
             </SelectItem>
           ))}
         </SelectContent>
-      </Select>
+        </Select>
+      </div>
     </div>
   )
 }

src/components/editorSchema.tsx

@@ -4,6 +4,7 @@ import { createReactInlineContentSpec } from '@blocknote/react'
 import { resolveWikilinkColor as resolveColor } from '../utils/wikilinkColors'
 import { resolveEntry } from '../utils/wikilink'
 import type { VaultEntry } from '../types'
+import { isEmoji } from '../utils/emoji'
 
 // Module-level cache so the WikiLink renderer (defined outside React) can access entries
 export const _wikilinkEntriesRef: { current: VaultEntry[] } = { current: [] }
@@ -12,15 +13,22 @@ function resolveWikilinkColor(target: string) {
   return resolveColor(_wikilinkEntriesRef.current, target)
 }
 
-/** Resolve the display text for a wikilink target.
+/** Resolve the display text and optional emoji for a wikilink target.
  *  Priority: pipe display text → entry title → humanised path stem */
-function resolveDisplayText(target: string): string {
+function resolveDisplayInfo(target: string): { text: string; emoji: string | null } {
   const pipeIdx = target.indexOf('|')
-  if (pipeIdx !== -1) return target.slice(pipeIdx + 1)
+  if (pipeIdx !== -1) {
+    const entry = resolveEntry(_wikilinkEntriesRef.current, target.slice(0, pipeIdx))
+    const emoji = entry?.icon && isEmoji(entry.icon) ? entry.icon : null
+    return { text: target.slice(pipeIdx + 1), emoji }
+  }
   const entry = resolveEntry(_wikilinkEntriesRef.current, target)
-  if (entry) return entry.title
+  if (entry) {
+    const emoji = entry.icon && isEmoji(entry.icon) ? entry.icon : null
+    return { text: entry.title, emoji }
+  }
   const last = target.split('/').pop() ?? target
-  return last.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase())
+  return { text: last.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()), emoji: null }
 }
 
 export const WikiLink = createReactInlineContentSpec(
@@ -35,14 +43,15 @@ export const WikiLink = createReactInlineContentSpec(
     render: (props) => {
       const target = props.inlineContent.props.target
       const { color, isBroken } = resolveWikilinkColor(target)
-      const displayText = resolveDisplayText(target)
+      const { text, emoji } = resolveDisplayInfo(target)
       return (
         <span
           className={`wikilink${isBroken ? ' wikilink--broken' : ''}`}
           data-target={target}
           style={{ color }}
         >
-          {displayText}
+          {emoji && <span className="wikilink-emoji">{emoji}{' '}</span>}
+          {text}
         </span>
       )
     },

src/components/inspector/BacklinksPanel.tsx

@@ -2,6 +2,7 @@ import { useState } from 'react'
 import type { VaultEntry } from '../../types'
 import { CaretRight, Trash } from '@phosphor-icons/react'
 import { getTypeColor } from '../../utils/typeColors'
+import { isEmoji } from '../../utils/emoji'
 import { entryStatusTitle } from './shared'
 import { StatusSuffix } from './LinkButton'
 
@@ -29,6 +30,7 @@ function BacklinkEntry({ entry, context, typeEntryMap, onNavigate }: {
         style={{ color: isDimmed ? 'var(--muted-foreground)' : getTypeColor(entry.isA, te?.color) }}
       >
         {entry.trashed && <Trash size={12} className="shrink-0" />}
+        {entry.icon && isEmoji(entry.icon) && <span className="shrink-0">{entry.icon}</span>}
         {entry.title}
         <StatusSuffix isArchived={entry.archived} isTrashed={entry.trashed} />
       </span>

src/components/inspector/LinkButton.tsx

@@ -7,8 +7,9 @@ export function StatusSuffix({ isArchived, isTrashed }: { isArchived: boolean; i
   return null
 }
 
-export function LinkButton({ label, typeColor, bgColor, isArchived, isTrashed, onClick, onRemove, title, TypeIcon }: {
+export function LinkButton({ label, emoji, typeColor, bgColor, isArchived, isTrashed, onClick, onRemove, title, TypeIcon }: {
   label: string
+  emoji?: string | null
   typeColor: string
   bgColor?: string
   isArchived: boolean
@@ -33,6 +34,7 @@ export function LinkButton({ label, typeColor, bgColor, isArchived, isTrashed, o
     >
       <span className="flex items-center gap-1 flex-1 truncate">
         {isTrashed && <Trash size={12} className="shrink-0" />}
+        {emoji && <span className="shrink-0">{emoji}</span>}
         {label}
         <StatusSuffix isArchived={isArchived} isTrashed={isTrashed} />
       </span>

src/components/inspector/shared.ts

@@ -3,6 +3,7 @@ import type { VaultEntry } from '../../types'
 import { getTypeColor, getTypeLightColor } from '../../utils/typeColors'
 import { getTypeIcon } from '../NoteItem'
 import { findEntryByTarget } from '../../utils/wikilinkColors'
+import { isEmoji } from '../../utils/emoji'
 
 export function isWikilink(value: string): boolean {
   return /^\[\[.*\]\]$/.test(value)
@@ -30,8 +31,10 @@ export function resolveRefProps(ref: string, entries: VaultEntry[], typeEntryMap
   const resolved = resolveRef(ref, entries)
   const refType = resolved?.isA ?? null
   const te = typeEntryMap[refType ?? '']
+  const icon = resolved?.icon
   return {
     label: wikilinkDisplay(ref),
+    emoji: icon && isEmoji(icon) ? icon : null,
     typeColor: getTypeColor(refType, te?.color),
     bgColor: getTypeLightColor(refType, te?.color),
     isArchived: resolved?.archived ?? false,

src/components/note-list/FilterPills.tsx

@@ -15,14 +15,14 @@ const PILLS: { value: NoteListFilter; label: string }[] = [
 
 function FilterPillsInner({ active, counts, onChange }: FilterPillsProps) {
   return (
-    <div className="flex h-[45px] shrink-0 items-center gap-1 border-b border-border px-4" data-testid="filter-pills">
+    <div className="flex h-auto min-h-[45px] shrink-0 flex-wrap items-center gap-1 border-b border-border px-4 py-1.5" data-testid="filter-pills">
       {PILLS.map(({ value, label }) => (
         <button
           key={value}
           type="button"
           role="tab"
           aria-selected={active === value}
-          className={`inline-flex items-center gap-1.5 rounded-full border px-2.5 py-0.5 text-[12px] font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring ${
+          className={`inline-flex whitespace-nowrap items-center gap-1.5 rounded-full border px-2.5 py-0.5 text-[12px] font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring ${
             active === value
               ? 'border-foreground/20 bg-foreground/10 text-foreground'
               : 'border-transparent text-muted-foreground hover:bg-muted hover:text-foreground'

src/components/note-list/InboxFilterPills.tsx

@@ -0,0 +1,44 @@
+import { memo } from 'react'
+import type { InboxPeriod } from '../../types'
+
+interface InboxFilterPillsProps {
+  active: InboxPeriod
+  counts: Record<InboxPeriod, number>
+  onChange: (period: InboxPeriod) => void
+}
+
+const PILLS: { value: InboxPeriod; label: string }[] = [
+  { value: 'week', label: 'This week' },
+  { value: 'month', label: 'This month' },
+  { value: 'quarter', label: 'This quarter' },
+  { value: 'all', label: 'All time' },
+]
+
+function InboxFilterPillsInner({ active, counts, onChange }: InboxFilterPillsProps) {
+  return (
+    <div className="flex h-auto min-h-[45px] shrink-0 flex-wrap items-center gap-1 border-b border-border px-4 py-1.5" data-testid="inbox-filter-pills">
+      {PILLS.map(({ value, label }) => (
+        <button
+          key={value}
+          type="button"
+          role="tab"
+          aria-selected={active === value}
+          className={`inline-flex whitespace-nowrap items-center gap-1.5 rounded-full border px-2.5 py-0.5 text-[12px] font-medium transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring ${
+            active === value
+              ? 'border-foreground/20 bg-foreground/10 text-foreground'
+              : 'border-transparent text-muted-foreground hover:bg-muted hover:text-foreground'
+          }`}
+          onClick={() => onChange(value)}
+          data-testid={`inbox-pill-${value}`}
+        >
+          {label}
+          <span className={`text-[10px] tabular-nums ${active === value ? 'text-foreground/70' : 'text-muted-foreground/70'}`}>
+            {counts[value]}
+          </span>
+        </button>
+      ))}
+    </div>
+  )
+}
+
+export const InboxFilterPills = memo(InboxFilterPillsInner)

src/components/note-list/NoteListViews.tsx

@@ -11,11 +11,12 @@ function ListViewHeader({ isTrashView, expiredTrashCount }: {
   return <TrashWarningBanner expiredCount={isTrashView ? expiredTrashCount : 0} />
 }
 
-function resolveEmptyText(isChangesView: boolean, changesError: string | null | undefined, isTrashView: boolean, isArchivedView: boolean, query: string): string {
+function resolveEmptyText(isChangesView: boolean, changesError: string | null | undefined, isTrashView: boolean, isArchivedView: boolean, isInboxView: boolean, query: string): string {
   if (isChangesView && changesError) return `Failed to load changes: ${changesError}`
   if (isChangesView) return 'No pending changes'
   if (isTrashView) return 'Trash is empty'
   if (isArchivedView) return 'No archived notes'
+  if (isInboxView) return query ? 'No matching notes' : 'All notes are organized'
   return query ? 'No matching notes' : 'No notes found'
 }
 
@@ -39,13 +40,13 @@ export function EntityView({ entity, groups, query, collapsedGroups, sortPrefs,
   )
 }
 
-export function ListView({ isTrashView, isArchivedView, isChangesView, changesError, expiredTrashCount, deletedCount = 0, searched, query, renderItem, virtuosoRef }: {
-  isTrashView: boolean; isArchivedView?: boolean; isChangesView?: boolean; changesError?: string | null; expiredTrashCount: number
+export function ListView({ isTrashView, isArchivedView, isChangesView, isInboxView, changesError, expiredTrashCount, deletedCount = 0, searched, query, renderItem, virtuosoRef }: {
+  isTrashView: boolean; isArchivedView?: boolean; isChangesView?: boolean; isInboxView?: boolean; changesError?: string | null; expiredTrashCount: number
   deletedCount?: number; searched: VaultEntry[]; query: string
   renderItem: (entry: VaultEntry) => React.ReactNode
   virtuosoRef?: React.RefObject<VirtuosoHandle | null>
 }) {
-  const emptyText = resolveEmptyText(!!isChangesView, changesError ?? null, isTrashView, !!isArchivedView, query)
+  const emptyText = resolveEmptyText(!!isChangesView, changesError ?? null, isTrashView, !!isArchivedView, !!isInboxView, query)
   const hasHeader = isTrashView && expiredTrashCount > 0
   const hasDeletedOnly = !!isChangesView && deletedCount > 0 && searched.length === 0
 

src/components/note-list/PinnedCard.tsx

@@ -2,6 +2,7 @@ import type { VaultEntry } from '../../types'
 import { getTypeColor, getTypeLightColor } from '../../utils/typeColors'
 import { getTypeIcon } from '../NoteItem'
 import { relativeDate, getDisplayDate } from '../../utils/noteListHelpers'
+import { isEmoji } from '../../utils/emoji'
 
 export function PinnedCard({ entry, typeEntryMap, onClickNote, showDate }: {
   entry: VaultEntry
@@ -17,7 +18,10 @@ export function PinnedCard({ entry, typeEntryMap, onClickNote, showDate }: {
     <div className="relative cursor-pointer border-b border-[var(--border)]" style={{ backgroundColor: bgColor, padding: '14px 16px' }} onClick={(e: React.MouseEvent) => onClickNote(entry, e)}>
       {/* eslint-disable-next-line react-hooks/static-components */}
       <Icon width={16} height={16} className="absolute right-3 top-3.5" style={{ color }} data-testid="type-icon" />
-      <div className="pr-6 text-[14px] font-bold" style={{ color }}>{entry.title}</div>
+      <div className="pr-6 text-[14px] font-bold" style={{ color }}>
+        {entry.icon && isEmoji(entry.icon) && <span className="mr-1">{entry.icon}</span>}
+        {entry.title}
+      </div>
       <div className="mt-1 text-[12px] leading-[1.5] opacity-80" style={{ color, display: '-webkit-box', WebkitLineClamp: 2, WebkitBoxOrient: 'vertical', overflow: 'hidden' }}>{entry.snippet}</div>
       {showDate && <div className="mt-1 text-[11px] opacity-60" style={{ color }}>{relativeDate(getDisplayDate(entry))}</div>}
     </div>

src/components/note-list/noteListHooks.ts

@@ -3,10 +3,11 @@ import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus } from '../
 import {
   type SortOption, type SortDirection, type SortConfig, type NoteListFilter,
   getSortComparator, extractSortableProperties,
-  buildRelationshipGroups, filterEntries,
+  buildRelationshipGroups, filterEntries, filterInboxEntries,
   loadSortPreferences, saveSortPreferences,
   parseSortConfig, serializeSortConfig, clearListSortFromLocalStorage,
 } from '../../utils/noteListHelpers'
+import type { InboxPeriod } from '../../types'
 import { buildTypeEntryMap } from '../../utils/typeColors'
 import { filterByQuery, filterGroupsByQuery, countExpiredTrash, createNoteStatusResolver, isModifiedEntry } from './noteListUtils'
 import type { MultiSelectState } from '../../hooks/useMultiSelect'
@@ -19,14 +20,16 @@ export function useTypeEntryMap(entries: VaultEntry[]) {
 
 // --- useFilteredEntries ---
 
-export function useFilteredEntries(entries: VaultEntry[], selection: SidebarSelection, modifiedPathSet: Set<string>, modifiedSuffixes: string[], subFilter?: NoteListFilter) {
+export function useFilteredEntries(entries: VaultEntry[], selection: SidebarSelection, modifiedPathSet: Set<string>, modifiedSuffixes: string[], subFilter?: NoteListFilter, inboxPeriod?: InboxPeriod) {
   const isEntityView = selection.kind === 'entity'
   const isChangesView = selection.kind === 'filter' && selection.filter === 'changes'
+  const isInboxView = selection.kind === 'filter' && selection.filter === 'inbox'
   return useMemo(() => {
     if (isEntityView) return []
     if (isChangesView) return entries.filter((e) => isModifiedEntry(e.path, modifiedPathSet, modifiedSuffixes))
+    if (isInboxView) return filterInboxEntries(entries, inboxPeriod ?? 'month')
     return filterEntries(entries, selection, subFilter)
-  }, [entries, selection, isEntityView, isChangesView, modifiedPathSet, modifiedSuffixes, subFilter])
+  }, [entries, selection, isEntityView, isChangesView, isInboxView, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod])
 }
 
 // --- useNoteListData ---
@@ -36,14 +39,15 @@ interface NoteListDataParams {
   query: string; listSort: SortOption; listDirection: SortDirection
   modifiedPathSet: Set<string>; modifiedSuffixes: string[]
   subFilter?: NoteListFilter
+  inboxPeriod?: InboxPeriod
 }
 
-export function useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter }: NoteListDataParams) {
+export function useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod }: NoteListDataParams) {
   const isEntityView = selection.kind === 'entity'
   const isTrashView = (selection.kind === 'filter' && selection.filter === 'trash') || subFilter === 'trashed'
   const isArchivedView = (selection.kind === 'filter' && selection.filter === 'archived') || subFilter === 'archived'
 
-  const filteredEntries = useFilteredEntries(entries, selection, modifiedPathSet, modifiedSuffixes, subFilter)
+  const filteredEntries = useFilteredEntries(entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod)
 
   const searched = useMemo(() => {
     const sorted = [...filteredEntries].sort(getSortComparator(listSort, listDirection))
@@ -52,7 +56,10 @@ export function useNoteListData({ entries, selection, query, listSort, listDirec
 
   const searchedGroups = useMemo(() => {
     if (!isEntityView) return []
-    const groups = buildRelationshipGroups(selection.entry, entries)
+    // Look up the fresh entry from the entries array to pick up relationship
+    // updates that happened after the selection was captured.
+    const freshEntry = entries.find((e) => e.path === selection.entry.path) ?? selection.entry
+    const groups = buildRelationshipGroups(freshEntry, entries)
     return filterGroupsByQuery(groups, query)
   }, [isEntityView, selection, entries, query])
 
@@ -125,11 +132,12 @@ export interface UseNoteListSortParams {
   modifiedPathSet: Set<string>
   modifiedSuffixes: string[]
   subFilter?: NoteListFilter
+  inboxPeriod?: InboxPeriod
   onUpdateTypeSort?: (path: string, key: string, value: string | number | boolean | string[] | null) => void
   updateEntry?: (path: string, patch: Partial<VaultEntry>) => void
 }
 
-export function useNoteListSort({ entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, onUpdateTypeSort, updateEntry }: UseNoteListSortParams) {
+export function useNoteListSort({ entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod, onUpdateTypeSort, updateEntry }: UseNoteListSortParams) {
   const [sortPrefs, setSortPrefs] = useState<Record<string, SortConfig>>(loadSortPreferences)
 
   const typeDocument = useMemo(() => {
@@ -157,7 +165,7 @@ export function useNoteListSort({ entries, selection, modifiedPathSet, modifiedS
     }
   }, [typeDocument, persistence])
 
-  const filteredEntries = useFilteredEntries(entries, selection, modifiedPathSet, modifiedSuffixes, subFilter)
+  const filteredEntries = useFilteredEntries(entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod)
   const customProperties = useMemo(() => extractSortableProperties(filteredEntries), [filteredEntries])
   const listSort = useMemo<SortOption>(() => deriveEffectiveSort(listConfig.option, customProperties), [listConfig.option, customProperties])
   const listDirection = listSort === listConfig.option ? listConfig.direction : 'desc'

src/components/note-list/noteListUtils.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi } from 'vitest'
+import { routeNoteClick, type ClickActions } from './noteListUtils'
+import type { VaultEntry } from '../../types'
+
+function makeEntry(path = '/test.md'): VaultEntry {
+  return {
+    path, filename: 'test.md', title: 'Test', isA: null,
+    aliases: [], belongsTo: [], relatedTo: [], status: null,
+    archived: false, trashed: false, trashedAt: null,
+    modifiedAt: null, createdAt: null, fileSize: 0,
+    snippet: '', wordCount: 0, relationships: {},
+    icon: null, color: null, order: null, sidebarLabel: null,
+    template: null, sort: null, view: null, visible: null,
+    outgoingLinks: [], properties: {},
+  }
+}
+
+function makeActions(): ClickActions {
+  return {
+    onReplace: vi.fn(),
+    onSelect: vi.fn(),
+    onOpenInNewWindow: vi.fn(),
+    multiSelect: {
+      selectRange: vi.fn(),
+      clear: vi.fn(),
+      setAnchor: vi.fn(),
+    },
+  }
+}
+
+function makeMouseEvent(overrides: Partial<React.MouseEvent> = {}): React.MouseEvent {
+  return { metaKey: false, ctrlKey: false, shiftKey: false, ...overrides } as React.MouseEvent
+}
+
+describe('routeNoteClick', () => {
+  it('plain click replaces active tab', () => {
+    const entry = makeEntry()
+    const actions = makeActions()
+    routeNoteClick(entry, makeMouseEvent(), actions)
+    expect(actions.onReplace).toHaveBeenCalledWith(entry)
+    expect(actions.multiSelect.clear).toHaveBeenCalled()
+    expect(actions.multiSelect.setAnchor).toHaveBeenCalledWith(entry.path)
+  })
+
+  it('Cmd+click opens as new tab', () => {
+    const entry = makeEntry()
+    const actions = makeActions()
+    routeNoteClick(entry, makeMouseEvent({ metaKey: true }), actions)
+    expect(actions.onSelect).toHaveBeenCalledWith(entry)
+    expect(actions.multiSelect.clear).toHaveBeenCalled()
+  })
+
+  it('Shift+click selects range', () => {
+    const entry = makeEntry()
+    const actions = makeActions()
+    routeNoteClick(entry, makeMouseEvent({ shiftKey: true }), actions)
+    expect(actions.multiSelect.selectRange).toHaveBeenCalledWith(entry.path)
+  })
+
+  it('Cmd+Shift+click opens in new window', () => {
+    const entry = makeEntry()
+    const actions = makeActions()
+    routeNoteClick(entry, makeMouseEvent({ metaKey: true, shiftKey: true }), actions)
+    expect(actions.onOpenInNewWindow).toHaveBeenCalledWith(entry)
+    expect(actions.onReplace).not.toHaveBeenCalled()
+    expect(actions.onSelect).not.toHaveBeenCalled()
+  })
+
+  it('Cmd+Shift+click is a no-op when handler is undefined', () => {
+    const entry = makeEntry()
+    const actions = makeActions()
+    actions.onOpenInNewWindow = undefined
+    routeNoteClick(entry, makeMouseEvent({ metaKey: true, shiftKey: true }), actions)
+    expect(actions.onReplace).not.toHaveBeenCalled()
+    expect(actions.onSelect).not.toHaveBeenCalled()
+  })
+})

src/components/note-list/noteListUtils.ts

@@ -7,6 +7,7 @@ export function resolveHeaderTitle(selection: SidebarSelection, typeDocument: Va
   if (selection.kind === 'filter' && selection.filter === 'archived') return 'Archive'
   if (selection.kind === 'filter' && selection.filter === 'trash') return 'Trash'
   if (selection.kind === 'filter' && selection.filter === 'changes') return 'Changes'
+  if (selection.kind === 'filter' && selection.filter === 'inbox') return 'Inbox'
   return 'Notes'
 }
 
@@ -27,11 +28,13 @@ export function countExpiredTrash(entries: VaultEntry[]): number {
 export interface ClickActions {
   onReplace: (entry: VaultEntry) => void
   onSelect: (entry: VaultEntry) => void
+  onOpenInNewWindow?: (entry: VaultEntry) => void
   multiSelect: { selectRange: (path: string) => void; clear: () => void; setAnchor: (path: string) => void }
 }
 
 export function routeNoteClick(entry: VaultEntry, e: React.MouseEvent, actions: ClickActions) {
-  if (e.shiftKey) { actions.multiSelect.selectRange(entry.path) }
+  if ((e.metaKey || e.ctrlKey) && e.shiftKey) { actions.onOpenInNewWindow?.(entry) }
+  else if (e.shiftKey) { actions.multiSelect.selectRange(entry.path) }
   else if (e.metaKey || e.ctrlKey) { actions.multiSelect.clear(); actions.onSelect(entry) }
   else { actions.multiSelect.clear(); actions.multiSelect.setAnchor(entry.path); actions.onReplace(entry) }
 }

src/hooks/frontmatterOps.ts

@@ -13,12 +13,38 @@ const ENTRY_DELETE_MAP: Record<string, Partial<VaultEntry>> = {
   template: { template: null }, sort: { sort: null }, visible: { visible: null },
 }
 
+/** Check if a string contains a wikilink pattern `[[...]]`. */
+function isWikilink(s: string): boolean {
+  return s.startsWith('[[') && s.includes(']]')
+}
+
+/** Extract wikilink strings from a FrontmatterValue. Returns empty array if none. */
+function extractWikilinks(value: FrontmatterValue): string[] {
+  if (typeof value === 'string') return isWikilink(value) ? [value] : []
+  if (Array.isArray(value)) return value.filter((v): v is string => typeof v === 'string' && isWikilink(v))
+  return []
+}
+
+/**
+ * Relationship patch: a partial update to merge into `entry.relationships`.
+ * Keys map to their new ref arrays. A `null` value means "remove this key".
+ */
+export type RelationshipPatch = Record<string, string[] | null>
+
+export interface EntryPatchResult {
+  patch: Partial<VaultEntry>
+  relationshipPatch: RelationshipPatch | null
+}
+
 /** Map a frontmatter key+value to the corresponding VaultEntry field(s). */
 export function frontmatterToEntryPatch(
   op: 'update' | 'delete', key: string, value?: FrontmatterValue,
-): Partial<VaultEntry> {
+): EntryPatchResult {
   const k = key.toLowerCase().replace(/\s+/g, '_')
-  if (op === 'delete') return ENTRY_DELETE_MAP[k] ?? {}
+  if (op === 'delete') {
+    const relPatch: RelationshipPatch = { [key]: null }
+    return { patch: ENTRY_DELETE_MAP[k] ?? {}, relationshipPatch: relPatch }
+  }
   const str = value != null ? String(value) : null
   const arr = Array.isArray(value) ? value.map(String) : []
   const updates: Record<string, Partial<VaultEntry>> = {
@@ -32,7 +58,11 @@ export function frontmatterToEntryPatch(
     view: { view: str },
     visible: { visible: value === false ? false : null },
   }
-  return updates[k] ?? {}
+  // Also update the relationships map for wikilink-containing values
+  const wikilinks = value != null ? extractWikilinks(value) : []
+  const relationshipPatch: RelationshipPatch | null =
+    wikilinks.length > 0 ? { [key]: wikilinks } : null
+  return { patch: updates[k] ?? {}, relationshipPatch }
 }
 
 async function invokeFrontmatter(command: string, args: Record<string, unknown>): Promise<string> {
@@ -60,18 +90,53 @@ async function executeFrontmatterOp(op: 'update' | 'delete', path: string, key:
   return isTauri() ? invokeFrontmatter('delete_frontmatter_property', { path, key }) : applyMockFrontmatterDelete(path, key)
 }
 
-/** Run a frontmatter update/delete and apply the result to state. */
+export interface FrontmatterOpOptions {
+  /** Suppress toast feedback (caller manages its own toast). */
+  silent?: boolean
+}
+
+/** Apply a relationship patch by merging into the existing relationships map. */
+export function applyRelationshipPatch(
+  existing: Record<string, string[]>, relPatch: RelationshipPatch,
+): Record<string, string[]> {
+  const merged = { ...existing }
+  for (const [k, v] of Object.entries(relPatch)) {
+    if (v === null) delete merged[k]
+    else merged[k] = v
+  }
+  return merged
+}
+
+/** Run a frontmatter update/delete and apply the result to state.
+ *  Returns the new file content on success, or undefined on failure. */
 export async function runFrontmatterAndApply(
   op: 'update' | 'delete', path: string, key: string, value: FrontmatterValue | undefined,
-  callbacks: { updateTab: (p: string, c: string) => void; updateEntry: (p: string, patch: Partial<VaultEntry>) => void; toast: (m: string | null) => void },
-): Promise<void> {
+  callbacks: {
+    updateTab: (p: string, c: string) => void
+    updateEntry: (p: string, patch: Partial<VaultEntry>) => void
+    toast: (m: string | null) => void
+    getEntry?: (p: string) => VaultEntry | undefined
+  },
+  options?: FrontmatterOpOptions,
+): Promise<string | undefined> {
   try {
-    callbacks.updateTab(path, await executeFrontmatterOp(op, path, key, value))
-    const patch = frontmatterToEntryPatch(op, key, value)
-    if (Object.keys(patch).length > 0) callbacks.updateEntry(path, patch)
-    callbacks.toast(op === 'update' ? 'Property updated' : 'Property deleted')
+    const newContent = await executeFrontmatterOp(op, path, key, value)
+    callbacks.updateTab(path, newContent)
+    const { patch, relationshipPatch } = frontmatterToEntryPatch(op, key, value)
+    const fullPatch = { ...patch }
+    if (relationshipPatch && callbacks.getEntry) {
+      const current = callbacks.getEntry(path)
+      if (current) {
+        fullPatch.relationships = applyRelationshipPatch(current.relationships, relationshipPatch)
+      }
+    }
+    if (Object.keys(fullPatch).length > 0) callbacks.updateEntry(path, fullPatch)
+    if (!options?.silent) callbacks.toast(op === 'update' ? 'Property updated' : 'Property deleted')
+    return newContent
   } catch (err) {
     console.error(`Failed to ${op} frontmatter:`, err)
+    if (options?.silent) throw err
     callbacks.toast(`Failed to ${op} property`)
+    return undefined
   }
 }

src/hooks/useAppCommands.ts

@@ -4,7 +4,7 @@ import { useCommandRegistry } from './useCommandRegistry'
 import type { CommandAction } from './useCommandRegistry'
 import { useKeyboardNavigation } from './useKeyboardNavigation'
 import { useMenuEvents } from './useMenuEvents'
-import type { SidebarSelection, ThemeFile, VaultEntry } from '../types'
+import type { SidebarSelection, SidebarFilter, ThemeFile, VaultEntry } from '../types'
 import type { NoteListFilter } from '../utils/noteListHelpers'
 import type { ViewMode } from './useViewMode'
 
@@ -31,6 +31,7 @@ interface AppCommandsConfig {
   onArchiveNote: (path: string) => void
   onUnarchiveNote: (path: string) => void
   onCommitPush: () => void
+  onPull?: () => void
   onResolveConflicts?: () => void
   onSetViewMode: (mode: ViewMode) => void
   onToggleInspector: () => void
@@ -77,6 +78,7 @@ interface AppCommandsConfig {
   activeNoteHasIcon?: boolean
   noteListFilter?: NoteListFilter
   onSetNoteListFilter?: (filter: NoteListFilter) => void
+  onOpenInNewWindow?: () => void
 }
 
 /** Sets up keyboard shortcuts, command registry, menu events, and keyboard navigation. */
@@ -97,7 +99,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
 
   const { onSelect } = config
 
-  const selectFilter = useCallback((filter: 'all' | 'archived' | 'trash' | 'changes' | 'pulse') => {
+  const selectFilter = useCallback((filter: SidebarFilter) => {
     onSelect({ kind: 'filter', filter })
   }, [onSelect])
 
@@ -124,6 +126,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onToggleAIChat: config.onToggleAIChat,
     onToggleRawEditor: config.onToggleRawEditor,
     onReopenClosedTab: config.onReopenClosedTab,
+    onOpenInNewWindow: config.onOpenInNewWindow,
     activeTabPathRef: config.activeTabPathRef,
     handleCloseTabRef: config.handleCloseTabRef,
   })
@@ -157,6 +160,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onCreateTheme: config.onCreateTheme,
     onRestoreDefaultThemes: config.onRestoreDefaultThemes,
     onCommitPush: config.onCommitPush,
+    onPull: config.onPull,
     onResolveConflicts: config.onResolveConflicts,
     onViewChanges: viewChanges,
     onInstallMcp: config.onInstallMcp,
@@ -165,6 +169,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onRepairVault: config.onRepairVault,
     onEmptyTrash: config.onEmptyTrash,
     onReopenClosedTab: config.onReopenClosedTab,
+    onOpenInNewWindow: config.onOpenInNewWindow,
     activeTabPathRef: config.activeTabPathRef,
     handleCloseTabRef: config.handleCloseTabRef,
     activeTabPath: config.activeTabPath,
@@ -185,6 +190,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onArchiveNote: config.onArchiveNote,
     onUnarchiveNote: config.onUnarchiveNote,
     onCommitPush: config.onCommitPush,
+    onPull: config.onPull,
     onResolveConflicts: config.onResolveConflicts,
     onSetViewMode: config.onSetViewMode,
     onToggleInspector: config.onToggleInspector,
@@ -229,6 +235,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     selection: config.selection,
     noteListFilter: config.noteListFilter,
     onSetNoteListFilter: config.onSetNoteListFilter,
+    onOpenInNewWindow: config.onOpenInNewWindow,
   })
 
   useKeyboardNavigation({

src/hooks/useAppKeyboard.test.ts

@@ -217,4 +217,12 @@ describe('useAppKeyboard', () => {
       expect(onToggleAIChat).toHaveBeenCalled()
     })
   })
+
+  it('Cmd+Shift+O triggers open in new window', () => {
+    const actions = makeActions()
+    const onOpenInNewWindow = vi.fn()
+    renderHook(() => useAppKeyboard({ ...actions, onOpenInNewWindow }))
+    fireKey('o', { metaKey: true, shiftKey: true })
+    expect(onOpenInNewWindow).toHaveBeenCalled()
+  })
 })

src/hooks/useAppKeyboard.ts

@@ -20,6 +20,7 @@ interface KeyboardActions {
   onToggleAIChat?: () => void
   onToggleRawEditor?: () => void
   onReopenClosedTab?: () => void
+  onOpenInNewWindow?: () => void
   activeTabPathRef: React.MutableRefObject<string | null>
   handleCloseTabRef: React.MutableRefObject<(path: string) => void>
 }
@@ -65,7 +66,7 @@ function handleCmdKey(e: KeyboardEvent, keyMap: Record<string, ShortcutHandler>)
 
 export function useAppKeyboard({
   onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote,
-  onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, onReopenClosedTab, activeTabPathRef, handleCloseTabRef,
+  onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, onReopenClosedTab, onOpenInNewWindow, activeTabPathRef, handleCloseTabRef,
 }: KeyboardActions) {
   useEffect(() => {
     const withActiveTab = (fn: (path: string) => void): ShortcutHandler => () => {
@@ -107,11 +108,17 @@ export function useAppKeyboard({
         onReopenClosedTab?.()
         return
       }
+      // Cmd+Shift+O: open active note in new window
+      if ((e.metaKey || e.ctrlKey) && e.shiftKey && (e.key === 'o' || e.key === 'O')) {
+        e.preventDefault()
+        onOpenInNewWindow?.()
+        return
+      }
       if (!handleViewModeKey(e, onSetViewMode)) {
         handleCmdKey(e, cmdKeyMap)
       }
     }
     window.addEventListener('keydown', handleKeyDown)
     return () => window.removeEventListener('keydown', handleKeyDown)
-  }, [onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote, activeTabPathRef, handleCloseTabRef, onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, onReopenClosedTab])
+  }, [onQuickOpen, onCommandPalette, onSearch, onCreateNote, onOpenDailyNote, onSave, onOpenSettings, onTrashNote, onArchiveNote, activeTabPathRef, handleCloseTabRef, onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, onReopenClosedTab, onOpenInNewWindow])
 }

src/hooks/useAutoSync.test.ts

@@ -107,20 +107,32 @@ describe('useAutoSync', () => {
     })
   })
 
-  it('pulls on window focus', async () => {
+  it('pulls on window focus after cooldown expires', async () => {
+    const now = vi.spyOn(Date, 'now')
+    let clock = 1000
+    now.mockImplementation(() => clock)
+
     renderSync()
     await waitFor(() => {
       expect(mockInvokeFn).toHaveBeenCalledWith('git_pull', { vaultPath: '/Users/luca/Laputa' })
     })
 
+    // Focus within cooldown — should NOT trigger pull
     mockInvokeFn.mockClear()
-    await act(async () => {
-      window.dispatchEvent(new Event('focus'))
-    })
+    clock += 5_000 // only 5s later
+    await act(async () => { window.dispatchEvent(new Event('focus')) })
+    const pullCalls = mockInvokeFn.mock.calls.filter((c: unknown[]) => c[0] === 'git_pull')
+    expect(pullCalls).toHaveLength(0)
+
+    // Focus after cooldown — should trigger pull
+    clock += 30_000 // 30s later
+    await act(async () => { window.dispatchEvent(new Event('focus')) })
 
     await waitFor(() => {
       expect(mockInvokeFn).toHaveBeenCalledWith('git_pull', { vaultPath: '/Users/luca/Laputa' })
     })
+
+    now.mockRestore()
   })
 
   it('triggerSync allows manual pull', async () => {

src/hooks/useAutoSync.ts

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from '../mock-tauri'
-import type { GitPullResult, LastCommitInfo, SyncStatus } from '../types'
+import type { GitPullResult, GitPushResult, GitRemoteStatus, LastCommitInfo, SyncStatus } from '../types'
 
 const DEFAULT_INTERVAL_MS = 5 * 60_000
 
@@ -23,11 +23,16 @@ export interface AutoSyncState {
   lastSyncTime: number | null
   conflictFiles: string[]
   lastCommitInfo: LastCommitInfo | null
+  remoteStatus: GitRemoteStatus | null
   triggerSync: () => void
+  /** Pull from remote, then push if there are local commits ahead. */
+  pullAndPush: () => void
   /** Pause auto-pull (e.g. while conflict resolver modal is open). */
   pausePull: () => void
   /** Resume auto-pull after pausing. */
   resumePull: () => void
+  /** Notify that a push was rejected so the status updates to pull_required. */
+  handlePushRejected: () => void
 }
 
 export function useAutoSync({
@@ -42,11 +47,22 @@ export function useAutoSync({
   const [lastSyncTime, setLastSyncTime] = useState<number | null>(null)
   const [conflictFiles, setConflictFiles] = useState<string[]>([])
   const [lastCommitInfo, setLastCommitInfo] = useState<LastCommitInfo | null>(null)
+  const [remoteStatus, setRemoteStatus] = useState<GitRemoteStatus | null>(null)
   const syncingRef = useRef(false)
   const pauseRef = useRef(false)
   const callbacksRef = useRef({ onVaultUpdated, onSyncUpdated, onConflict, onToast })
   callbacksRef.current = { onVaultUpdated, onSyncUpdated, onConflict, onToast }
 
+  const refreshRemoteStatus = useCallback(async () => {
+    try {
+      const status = await tauriCall<GitRemoteStatus>('git_remote_status', { vaultPath })
+      setRemoteStatus(status)
+      return status
+    } catch {
+      return null
+    }
+  }, [vaultPath])
+
   /** Check for pre-existing conflicts (e.g. from a prior session or interrupted rebase). */
   const checkExistingConflicts = useCallback(async (): Promise<boolean> => {
     try {
@@ -63,6 +79,12 @@ export function useAutoSync({
     return false
   }, [vaultPath])
 
+  const refreshCommitInfo = useCallback(() => {
+    tauriCall<LastCommitInfo | null>('get_last_commit_info', { vaultPath })
+      .then(info => setLastCommitInfo(info))
+      .catch(() => {})
+  }, [vaultPath])
+
   const performPull = useCallback(async () => {
     if (syncingRef.current || pauseRef.current) return
     syncingRef.current = true
@@ -71,9 +93,7 @@ export function useAutoSync({
     try {
       const result = await tauriCall<GitPullResult>('git_pull', { vaultPath })
       setLastSyncTime(Date.now())
-      tauriCall<LastCommitInfo | null>('get_last_commit_info', { vaultPath })
-        .then(info => setLastCommitInfo(info))
-        .catch(() => {})
+      refreshCommitInfo()
 
       if (result.status === 'updated') {
         setSyncStatus('idle')
@@ -96,24 +116,95 @@ export function useAutoSync({
         setSyncStatus('idle')
         setConflictFiles([])
       }
+
+      // Refresh remote status after pull
+      refreshRemoteStatus()
     } catch {
       setSyncStatus('error')
       setLastSyncTime(Date.now())
     } finally {
       syncingRef.current = false
     }
-  }, [vaultPath, checkExistingConflicts])
+  }, [vaultPath, checkExistingConflicts, refreshCommitInfo, refreshRemoteStatus])
+
+  /** Pull from remote, then auto-push if successful. Used for divergence recovery. */
+  const pullAndPush = useCallback(async () => {
+    if (syncingRef.current) return
+    syncingRef.current = true
+    setSyncStatus('syncing')
+
+    try {
+      const pullResult = await tauriCall<GitPullResult>('git_pull', { vaultPath })
+      setLastSyncTime(Date.now())
+      refreshCommitInfo()
+
+      if (pullResult.status === 'conflict') {
+        setSyncStatus('conflict')
+        setConflictFiles(pullResult.conflictFiles)
+        callbacksRef.current.onConflict(pullResult.conflictFiles)
+        return
+      }
+
+      if (pullResult.status === 'error') {
+        const hasConflicts = await checkExistingConflicts()
+        if (!hasConflicts) {
+          setSyncStatus('error')
+          callbacksRef.current.onToast('Pull failed: ' + pullResult.message)
+        }
+        return
+      }
+
+      if (pullResult.status === 'updated') {
+        callbacksRef.current.onVaultUpdated()
+        callbacksRef.current.onSyncUpdated?.()
+      }
+
+      // Now push
+      const pushResult = await tauriCall<GitPushResult>('git_push', { vaultPath })
+      if (pushResult.status === 'ok') {
+        setSyncStatus('idle')
+        setConflictFiles([])
+        callbacksRef.current.onToast('Pulled and pushed successfully')
+      } else if (pushResult.status === 'rejected') {
+        // Still diverged — shouldn't happen after pull but handle gracefully
+        setSyncStatus('pull_required')
+        callbacksRef.current.onToast('Push still rejected after pull — try again')
+      } else {
+        setSyncStatus('error')
+        callbacksRef.current.onToast(pushResult.message)
+      }
+
+      refreshRemoteStatus()
+    } catch {
+      setSyncStatus('error')
+      setLastSyncTime(Date.now())
+    } finally {
+      syncingRef.current = false
+    }
+  }, [vaultPath, checkExistingConflicts, refreshCommitInfo, refreshRemoteStatus])
+
+  const handlePushRejected = useCallback(() => {
+    setSyncStatus('pull_required')
+  }, [])
 
   // Check for pre-existing conflicts on mount, then pull
   useEffect(() => {
     checkExistingConflicts().then(hasConflicts => {
       if (!hasConflicts) performPull()
     })
-  }, [checkExistingConflicts, performPull])
+    refreshRemoteStatus()
+  }, [checkExistingConflicts, performPull, refreshRemoteStatus])
 
-  // Pull on window focus (app foreground)
+  // Pull on window focus (app foreground) — with cooldown to avoid repeated pulls
+  const lastPullTimeRef = useRef(0)
   useEffect(() => {
-    const handleFocus = () => { performPull() }
+    const FOCUS_COOLDOWN_MS = 30_000
+    const handleFocus = () => {
+      const now = Date.now()
+      if (now - lastPullTimeRef.current < FOCUS_COOLDOWN_MS) return
+      lastPullTimeRef.current = now
+      performPull()
+    }
     window.addEventListener('focus', handleFocus)
     return () => window.removeEventListener('focus', handleFocus)
   }, [performPull])
@@ -128,5 +219,5 @@ export function useAutoSync({
   const pausePull = useCallback(() => { pauseRef.current = true }, [])
   const resumePull = useCallback(() => { pauseRef.current = false }, [])
 
-  return { syncStatus, lastSyncTime, conflictFiles, lastCommitInfo, triggerSync: performPull, pausePull, resumePull }
+  return { syncStatus, lastSyncTime, conflictFiles, lastCommitInfo, remoteStatus, triggerSync: performPull, pullAndPush, pausePull, resumePull, handlePushRejected }
 }

src/hooks/useCodeMirror.test.ts

@@ -67,6 +67,40 @@ describe('useCodeMirror', () => {
     spy.mockRestore()
   })
 
+  it('syncs content prop changes to the editor', () => {
+    const ref = { current: container }
+    const onDocChange = vi.fn()
+    const callbacks = { ...noopCallbacks, onDocChange }
+    const { result, rerender } = renderHook(
+      ({ content }) => useCodeMirror(ref, content, false, callbacks),
+      { initialProps: { content: '---\ntitle: Hello\n---\nBody' } },
+    )
+    const view = result.current.current!
+    expect(view.state.doc.toString()).toBe('---\ntitle: Hello\n---\nBody')
+
+    // Simulate external content update (e.g. frontmatter written to disk)
+    rerender({ content: '---\ntitle: Hello\nTrashed: true\n---\nBody' })
+
+    expect(view.state.doc.toString()).toBe('---\ntitle: Hello\nTrashed: true\n---\nBody')
+    // External sync should NOT trigger onDocChange (would cause infinite loop)
+    expect(onDocChange).not.toHaveBeenCalled()
+  })
+
+  it('does not sync when content matches current editor state', () => {
+    const ref = { current: container }
+    const { result, rerender } = renderHook(
+      ({ content }) => useCodeMirror(ref, content, false, noopCallbacks),
+      { initialProps: { content: 'hello' } },
+    )
+    const view = result.current.current!
+    const spy = vi.spyOn(view, 'dispatch')
+
+    // Re-render with same content — no dispatch needed
+    rerender({ content: 'hello' })
+    expect(spy).not.toHaveBeenCalled()
+    spy.mockRestore()
+  })
+
   it('installs zoomCursorFix that overrides posAtCoords on the view instance', () => {
     const ref = { current: container }
     const { result } = renderHook(() =>

src/hooks/useCodeMirror.ts

@@ -82,6 +82,19 @@ export function useCodeMirror(
   const viewRef = useRef<EditorView | null>(null)
   const callbacksRef = useRef(callbacks)
   callbacksRef.current = callbacks
+  // Track whether we're dispatching an external sync so the updateListener skips it
+  const externalSyncRef = useRef(false)
+
+  // Sync content prop changes to the editor (e.g. after frontmatter update on disk)
+  useEffect(() => {
+    const view = viewRef.current
+    if (!view) return
+    const current = view.state.doc.toString()
+    if (current === content) return
+    externalSyncRef.current = true
+    view.dispatch({ changes: { from: 0, to: current.length, insert: content } })
+    externalSyncRef.current = false
+  }, [content])
 
   useEffect(() => {
     const parent = containerRef.current
@@ -101,7 +114,7 @@ export function useCodeMirror(
         frontmatterHighlightPlugin,
         zoomCursorFix(),
         EditorView.updateListener.of((update) => {
-          if (update.docChanged) {
+          if (update.docChanged && !externalSyncRef.current) {
             callbacksRef.current.onDocChange(update.state.doc.toString())
           }
           if (update.selectionSet || update.docChanged) {
@@ -113,6 +126,9 @@ export function useCodeMirror(
 
     const view = new EditorView({ state, parent })
     viewRef.current = view
+    // Expose EditorView on the parent DOM for Playwright test access
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(parent as any).__cmView = view
 
     // When CSS zoom changes on the document, CodeMirror's cached measurements
     // (scaleX/scaleY, line heights, character widths) become stale because
@@ -123,6 +139,8 @@ export function useCodeMirror(
 
     return () => {
       window.removeEventListener('laputa-zoom-change', handleZoomChange)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      delete (parent as any).__cmView
       view.destroy()
       viewRef.current = null
     }

src/hooks/useCommandRegistry.ts

@@ -30,6 +30,7 @@ interface CommandRegistryConfig {
   onRepairVault?: () => void
   onSetNoteIcon?: () => void
   onRemoveNoteIcon?: () => void
+  onOpenInNewWindow?: () => void
 
   onQuickOpen: () => void
   onCreateNote: () => void
@@ -43,6 +44,7 @@ interface CommandRegistryConfig {
   onArchiveNote: (path: string) => void
   onUnarchiveNote: (path: string) => void
   onCommitPush: () => void
+  onPull?: () => void
   onResolveConflicts?: () => void
   onSetViewMode: (mode: ViewMode) => void
   onToggleInspector: () => void
@@ -200,7 +202,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     activeTabPath, entries, modifiedCount,
     onQuickOpen, onCreateNote, onCreateNoteOfType, onSave, onOpenSettings,
     onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
-    onCommitPush, onResolveConflicts, onSetViewMode, onToggleInspector, onToggleDiff, onToggleRawEditor, onToggleAIChat, onOpenVault,
+    onCommitPush, onPull, onResolveConflicts, onSetViewMode, onToggleInspector, onToggleDiff, onToggleRawEditor, onToggleAIChat, onOpenVault,
     activeNoteModified,
     onZoomIn, onZoomOut, onZoomReset, zoomLevel,
     onSelect, onOpenDailyNote, onCloseTab,
@@ -217,6 +219,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     onSetNoteIcon,
     onRemoveNoteIcon,
     activeNoteHasIcon,
+    onOpenInNewWindow,
     selection, noteListFilter, onSetNoteListFilter,
   } = config
 
@@ -242,6 +245,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
       { id: 'empty-trash', label: 'Empty Trash', group: 'Note', keywords: ['delete', 'permanently', 'purge', 'clear', 'trash'], enabled: (trashedCount ?? 0) > 0, execute: () => onEmptyTrash?.() },
       { id: 'go-changes', label: 'Go to Changes', group: 'Navigation', keywords: ['git', 'modified', 'pending'], enabled: true, execute: () => onSelect({ kind: 'filter', filter: 'changes' }) },
       { id: 'go-pulse', label: 'Go to Pulse', group: 'Navigation', keywords: ['activity', 'history', 'commits', 'git', 'feed'], enabled: true, execute: () => onSelect({ kind: 'filter', filter: 'pulse' }) },
+      { id: 'go-inbox', label: 'Go to Inbox', group: 'Navigation', keywords: ['inbox', 'unlinked', 'orphan', 'unorganized', 'triage'], enabled: true, execute: () => onSelect({ kind: 'filter', filter: 'inbox' }) },
       { id: 'go-back', label: 'Go Back', group: 'Navigation', shortcut: '⌘[', keywords: ['previous', 'history', 'back'], enabled: !!canGoBack, execute: () => onGoBack?.() },
       { id: 'go-forward', label: 'Go Forward', group: 'Navigation', shortcut: '⌘]', keywords: ['next', 'history', 'forward'], enabled: !!canGoForward, execute: () => onGoForward?.() },
 
@@ -273,9 +277,16 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
         enabled: hasActiveNote && !!activeNoteHasIcon && !!onRemoveNoteIcon,
         execute: () => onRemoveNoteIcon?.(),
       },
+      {
+        id: 'open-in-new-window', label: 'Open in New Window', group: 'Note', shortcut: '⌘⇧O',
+        keywords: ['window', 'new', 'detach', 'pop', 'external', 'separate'],
+        enabled: hasActiveNote,
+        execute: () => onOpenInNewWindow?.(),
+      },
 
       // Git
       { id: 'commit-push', label: 'Commit & Push', group: 'Git', keywords: ['git', 'save', 'sync'], enabled: modifiedCount > 0, execute: onCommitPush },
+      { id: 'git-pull', label: 'Pull from Remote', group: 'Git', keywords: ['git', 'pull', 'fetch', 'download', 'sync', 'remote'], enabled: true, execute: () => onPull?.() },
       { id: 'resolve-conflicts', label: 'Resolve Conflicts', group: 'Git', keywords: ['conflict', 'merge', 'git', 'sync'], enabled: true, execute: () => onResolveConflicts?.() },
       { id: 'view-changes', label: 'View Pending Changes', group: 'Git', keywords: ['modified', 'diff'], enabled: true, execute: () => onSelect({ kind: 'filter', filter: 'changes' }) },
 
@@ -311,17 +322,17 @@ export function useCommandRegistry(config: CommandRegistryConfig): CommandAction
     hasActiveNote, activeTabPath, isArchived, isTrashed, modifiedCount, activeNoteModified,
     onQuickOpen, onCreateNote, onCreateNoteOfType, onCreateType, onSave, onOpenSettings,
     onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
-    onCommitPush, onResolveConflicts, onSetViewMode, onToggleInspector, onToggleDiff, onToggleRawEditor, onToggleAIChat, onOpenVault,
+    onCommitPush, onPull, onResolveConflicts, onSetViewMode, onToggleInspector, onToggleDiff, onToggleRawEditor, onToggleAIChat, onOpenVault,
     onCheckForUpdates,
     onZoomIn, onZoomOut, onZoomReset, zoomLevel,
     onSelect, onOpenDailyNote, onCloseTab,
     onGoBack, onGoForward, canGoBack, canGoForward,
     vaultTypes, themes, activeThemeId, onSwitchTheme, onCreateTheme, onOpenTheme, onRestoreDefaultThemes,
     onRemoveActiveVault, onRestoreGettingStarted, isGettingStartedHidden, vaultCount,
-    mcpStatus, onInstallMcp,
-    onEmptyTrash, trashedCount,
+    mcpStatus, onInstallMcp, onEmptyTrash, trashedCount,
     onReindexVault, onReloadVault, onRepairVault,
     onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon,
     isSectionGroup, noteListFilter, onSetNoteListFilter,
+    onOpenInNewWindow,
   ])
 }

src/hooks/useCommitFlow.test.ts

@@ -7,16 +7,18 @@ describe('useCommitFlow', () => {
   let loadModifiedFiles: vi.Mock
   let commitAndPush: vi.Mock
   let setToastMessage: vi.Mock
+  let onPushRejected: vi.Mock
 
   beforeEach(() => {
     savePending = vi.fn().mockResolvedValue(undefined)
     loadModifiedFiles = vi.fn().mockResolvedValue(undefined)
-    commitAndPush = vi.fn().mockResolvedValue('Committed and pushed')
+    commitAndPush = vi.fn().mockResolvedValue({ status: 'ok', message: 'Pushed to remote' })
     setToastMessage = vi.fn()
+    onPushRejected = vi.fn()
   })
 
   function renderCommitFlow() {
-    return renderHook(() => useCommitFlow({ savePending, loadModifiedFiles, commitAndPush, setToastMessage }))
+    return renderHook(() => useCommitFlow({ savePending, loadModifiedFiles, commitAndPush, setToastMessage, onPushRejected }))
   }
 
   it('openCommitDialog saves pending, refreshes files, then opens dialog', async () => {
@@ -46,6 +48,18 @@ describe('useCommitFlow', () => {
     expect(result.current.showCommitDialog).toBe(false)
   })
 
+  it('handleCommitPush calls onPushRejected when push is rejected', async () => {
+    commitAndPush.mockResolvedValueOnce({ status: 'rejected', message: 'Push rejected' })
+    const { result } = renderCommitFlow()
+
+    await act(async () => {
+      await result.current.handleCommitPush('test message')
+    })
+
+    expect(onPushRejected).toHaveBeenCalledTimes(1)
+    expect(setToastMessage).toHaveBeenCalledWith(expect.stringContaining('push rejected'))
+  })
+
   it('handleCommitPush shows error toast on failure', async () => {
     commitAndPush.mockRejectedValueOnce(new Error('push failed'))
     const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})

src/hooks/useCommitFlow.ts

@@ -1,14 +1,16 @@
 import { useCallback, useState } from 'react'
+import type { GitPushResult } from '../types'
 
 interface CommitFlowConfig {
   savePending: () => Promise<void | boolean>
   loadModifiedFiles: () => Promise<void>
-  commitAndPush: (message: string) => Promise<string>
+  commitAndPush: (message: string) => Promise<GitPushResult>
   setToastMessage: (msg: string | null) => void
+  onPushRejected?: () => void
 }
 
 /** Manages the Commit & Push dialog state and the save→commit→push flow. */
-export function useCommitFlow({ savePending, loadModifiedFiles, commitAndPush, setToastMessage }: CommitFlowConfig) {
+export function useCommitFlow({ savePending, loadModifiedFiles, commitAndPush, setToastMessage, onPushRejected }: CommitFlowConfig) {
   const [showCommitDialog, setShowCommitDialog] = useState(false)
 
   const openCommitDialog = useCallback(async () => {
@@ -22,13 +24,20 @@ export function useCommitFlow({ savePending, loadModifiedFiles, commitAndPush, s
     try {
       await savePending()
       const result = await commitAndPush(message)
-      setToastMessage(result)
+      if (result.status === 'ok') {
+        setToastMessage('Committed and pushed')
+      } else if (result.status === 'rejected') {
+        setToastMessage('Committed, but push rejected — remote has new commits. Pull first.')
+        onPushRejected?.()
+      } else {
+        setToastMessage(result.message)
+      }
       loadModifiedFiles()
     } catch (err) {
       console.error('Commit failed:', err)
       setToastMessage(`Commit failed: ${err}`)
     }
-  }, [savePending, commitAndPush, loadModifiedFiles, setToastMessage])
+  }, [savePending, commitAndPush, loadModifiedFiles, setToastMessage, onPushRejected])
 
   const closeCommitDialog = useCallback(() => setShowCommitDialog(false), [])
 

src/hooks/useEditorSave.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest'
 import { renderHook, act } from '@testing-library/react'
 import { useEditorSave } from './useEditorSave'
 
@@ -219,6 +219,151 @@ describe('useEditorSave', () => {
     expect(updateVaultContent).toHaveBeenCalledWith('/vault/note.md', edited)
   })
 
+  it('calls onNotePersisted with path and content after saving pending content', async () => {
+    const onNotePersisted = vi.fn()
+    const { result } = renderHook(() =>
+      useEditorSave({ updateVaultContent, setTabs, setToastMessage, onNotePersisted })
+    )
+
+    act(() => {
+      result.current.handleContentChange('/vault/theme/default.md', '---\nbackground: "#FFD700"\n---\n')
+    })
+
+    await act(async () => {
+      await result.current.handleSave()
+    })
+
+    expect(onNotePersisted).toHaveBeenCalledWith(
+      '/vault/theme/default.md',
+      '---\nbackground: "#FFD700"\n---\n',
+    )
+  })
+
+  it('calls onNotePersisted for unsaved fallback when no pending content', async () => {
+    const onNotePersisted = vi.fn()
+    const { result } = renderHook(() =>
+      useEditorSave({ updateVaultContent, setTabs, setToastMessage, onNotePersisted })
+    )
+
+    // No handleContentChange — simulate Cmd+S on a newly created unsaved note
+    await act(async () => {
+      await result.current.handleSave({ path: '/vault/theme/default.md', content: '---\nbackground: "#FF0000"\n---\n' })
+    })
+
+    expect(onNotePersisted).toHaveBeenCalledWith(
+      '/vault/theme/default.md',
+      '---\nbackground: "#FF0000"\n---\n',
+    )
+  })
+
+  describe('auto-save debounce', () => {
+    beforeEach(() => { vi.useFakeTimers() })
+    afterEach(() => { vi.useRealTimers() })
+
+    it('auto-saves 500ms after last content change', async () => {
+      const onNotePersisted = vi.fn()
+      const { result } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage, onNotePersisted })
+      )
+
+      act(() => {
+        result.current.handleContentChange('/test/note.md', 'auto-saved content')
+      })
+
+      // Not saved yet
+      expect(mockInvokeFn).not.toHaveBeenCalled()
+
+      // Advance 500ms
+      await act(async () => { vi.advanceTimersByTime(500) })
+
+      expect(mockInvokeFn).toHaveBeenCalledWith('save_note_content', {
+        path: '/test/note.md',
+        content: 'auto-saved content',
+      })
+      expect(onNotePersisted).toHaveBeenCalledWith('/test/note.md', 'auto-saved content')
+    })
+
+    it('resets debounce timer on each content change', async () => {
+      const { result } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage })
+      )
+
+      act(() => { result.current.handleContentChange('/test/note.md', 'v1') })
+
+      // Advance 400ms (not yet 500ms)
+      await act(async () => { vi.advanceTimersByTime(400) })
+      expect(mockInvokeFn).not.toHaveBeenCalled()
+
+      // New edit resets timer
+      act(() => { result.current.handleContentChange('/test/note.md', 'v2') })
+
+      // Another 400ms (800ms total, but only 400ms from last edit)
+      await act(async () => { vi.advanceTimersByTime(400) })
+      expect(mockInvokeFn).not.toHaveBeenCalled()
+
+      // 100ms more = 500ms from last edit
+      await act(async () => { vi.advanceTimersByTime(100) })
+      expect(mockInvokeFn).toHaveBeenCalledWith('save_note_content', {
+        path: '/test/note.md',
+        content: 'v2',
+      })
+    })
+
+    it('auto-save does not show toast', async () => {
+      const { result } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage })
+      )
+
+      act(() => { result.current.handleContentChange('/test/note.md', 'content') })
+      await act(async () => { vi.advanceTimersByTime(500) })
+
+      expect(setToastMessage).not.toHaveBeenCalled()
+    })
+
+    it('Cmd+S cancels pending auto-save and saves immediately', async () => {
+      const { result } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage })
+      )
+
+      act(() => { result.current.handleContentChange('/test/note.md', 'content') })
+
+      // Cmd+S before debounce fires
+      await act(async () => { await result.current.handleSave() })
+
+      expect(mockInvokeFn).toHaveBeenCalledTimes(1)
+      expect(setToastMessage).toHaveBeenCalledWith('Saved')
+
+      // Advancing timer should NOT cause a second save
+      await act(async () => { vi.advanceTimersByTime(500) })
+      expect(mockInvokeFn).toHaveBeenCalledTimes(1)
+    })
+
+    it('auto-save calls onAfterSave', async () => {
+      const onAfterSave = vi.fn()
+      const { result } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage, onAfterSave })
+      )
+
+      act(() => { result.current.handleContentChange('/test/note.md', 'content') })
+      await act(async () => { vi.advanceTimersByTime(500) })
+
+      expect(onAfterSave).toHaveBeenCalled()
+    })
+
+    it('clears auto-save timer on unmount', async () => {
+      const { result, unmount } = renderHook(() =>
+        useEditorSave({ updateVaultContent, setTabs, setToastMessage })
+      )
+
+      act(() => { result.current.handleContentChange('/test/note.md', 'content') })
+      unmount()
+
+      await act(async () => { vi.advanceTimersByTime(500) })
+      // Should not save after unmount
+      expect(mockInvokeFn).not.toHaveBeenCalled()
+    })
+  })
+
   it('successive edits and saves persist each version correctly', async () => {
     const { result } = renderSaveHook()
 

src/hooks/useEditorSave.ts

@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react'
+import { useCallback, useEffect, useRef } from 'react'
 import type { SetStateAction } from 'react'
 import { useSaveNote } from './useSaveNote'
 
@@ -18,13 +18,16 @@ interface EditorSaveConfig {
 }
 
 /**
- * Hook that manages explicit save (Cmd+S) for editor content.
- * Tracks pending (unsaved) content and provides save + pre-rename helpers.
+ * Hook that manages editor content persistence with auto-save.
+ * Content is auto-saved 500ms after the last edit. Cmd+S flushes immediately.
  */
 const noop = () => {}
 
+const AUTO_SAVE_DEBOUNCE_MS = 500
+
 export function useEditorSave({ updateVaultContent, setTabs, setToastMessage, onAfterSave = noop, onNotePersisted }: EditorSaveConfig) {
   const pendingContentRef = useRef<{ path: string; content: string } | null>(null)
+  const autoSaveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const updateTabAndContent = useCallback((path: string, content: string) => {
     updateVaultContent(path, content)
@@ -47,9 +50,22 @@ export function useEditorSave({ updateVaultContent, setTabs, setToastMessage, on
     return true
   }, [saveNote, onNotePersisted])
 
+  // Stable ref for onAfterSave so the auto-save timer closure always calls the latest version
+  const onAfterSaveRef = useRef(onAfterSave)
+  useEffect(() => { onAfterSaveRef.current = onAfterSave }, [onAfterSave])
+
+  /** Cancel any pending auto-save timer. */
+  const cancelAutoSave = useCallback(() => {
+    if (autoSaveTimerRef.current) {
+      clearTimeout(autoSaveTimerRef.current)
+      autoSaveTimerRef.current = null
+    }
+  }, [])
+
   /** Called by Cmd+S — persists the current editor content to disk.
    *  Accepts optional fallback for unsaved notes with no pending edits. */
   const handleSave = useCallback(async (unsavedFallback?: { path: string; content: string }) => {
+    cancelAutoSave()
     try {
       const saved = await flushPending()
       if (!saved && unsavedFallback) {
@@ -65,26 +81,39 @@ export function useEditorSave({ updateVaultContent, setTabs, setToastMessage, on
       console.error('Save failed:', err)
       setToastMessage(`Save failed: ${err}`)
     }
-  }, [flushPending, setToastMessage, onAfterSave, saveNote, onNotePersisted])
+  }, [cancelAutoSave, flushPending, setToastMessage, onAfterSave, saveNote, onNotePersisted])
 
-  /** Called by Editor onChange — buffers the latest content and syncs tab state
-   *  so consumers (e.g. AI panel) always see current editor content. */
+  /** Called by Editor onChange — buffers the latest content, syncs tab state,
+   *  and schedules an auto-save after 500ms of inactivity. */
   const handleContentChange = useCallback((path: string, content: string) => {
     pendingContentRef.current = { path, content }
     setTabs((prev: Tab[]) =>
       prev.map((t) => t.entry.path === path ? { ...t, content } : t)
     )
-  }, [setTabs])
+    cancelAutoSave()
+    autoSaveTimerRef.current = setTimeout(async () => {
+      autoSaveTimerRef.current = null
+      try {
+        const saved = await flushPending()
+        if (saved) onAfterSaveRef.current()
+      } catch (err) {
+        console.error('Auto-save failed:', err)
+      }
+    }, AUTO_SAVE_DEBOUNCE_MS)
+  }, [setTabs, cancelAutoSave, flushPending])
 
-  /** Save pending content for a specific path (used before rename) */
+  // Clear auto-save timer on unmount
+  useEffect(() => () => cancelAutoSave(), [cancelAutoSave])
+
+  /** Save pending content for a specific path (used before rename / tab close) */
   const savePendingForPath = useCallback(
-    (path: string): Promise<boolean> => flushPending(path),
-    [flushPending],
+    (path: string): Promise<boolean> => { cancelAutoSave(); return flushPending(path) },
+    [cancelAutoSave, flushPending],
   )
 
   /** Flush any pending content to disk silently (used before git commit).
    * Does NOT call onAfterSave — callers manage their own refresh. */
-  const savePending = useCallback((): Promise<boolean> => flushPending(), [flushPending])
+  const savePending = useCallback((): Promise<boolean> => { cancelAutoSave(); return flushPending() }, [cancelAutoSave, flushPending])
 
   return { handleSave, handleContentChange, savePendingForPath, savePending }
 }

src/hooks/useEditorTabSwap.ts

@@ -1,4 +1,3 @@
-import type React from 'react'
 import { useCallback, useEffect, useRef } from 'react'
 import type { useCreateBlockNote } from '@blocknote/react'
 import type { VaultEntry } from '../types'
@@ -15,10 +14,6 @@ interface UseEditorTabSwapOptions {
   activeTabPath: string | null
   editor: ReturnType<typeof useCreateBlockNote>
   onContentChange?: (path: string, content: string) => void
-  /** Called on every editor change with the H1 text (null if no H1 first block). */
-  onH1Change?: (h1Text: string | null) => void
-  /** When .current is false, handleEditorChange won't update frontmatter title from H1. */
-  syncActiveRef?: React.MutableRefObject<boolean>
   /** When true, the BlockNote editor is hidden (raw/CodeMirror mode active). */
   rawMode?: boolean
 }
@@ -63,7 +58,7 @@ export function replaceTitleInFrontmatter(frontmatter: string, newTitle: string)
  *
  * Returns `handleEditorChange`, the onChange callback for SingleEditorView.
  */
-export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange, onH1Change, syncActiveRef, rawMode }: UseEditorTabSwapOptions) {
+export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange, rawMode }: UseEditorTabSwapOptions) {
   // Cache parsed blocks + scroll position per tab path for instant switching
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- BlockNote block arrays
   const tabCacheRef = useRef<Map<string, { blocks: any[]; scrollTop: number }>>(new Map())
@@ -81,8 +76,6 @@ export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange,
   // Keep refs to callbacks for the onChange handler
   const onContentChangeRef = useRef(onContentChange)
   onContentChangeRef.current = onContentChange
-  const onH1ChangeRef = useRef(onH1Change)
-  onH1ChangeRef.current = onH1Change
   const tabsRef = useRef(tabs)
   tabsRef.current = tabs
 
@@ -122,18 +115,10 @@ export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange,
 
     // Reconstruct full file: frontmatter + body (which now includes H1 if present)
     const [frontmatter] = splitFrontmatter(tab.content)
-    const h1Text = getH1TextFromBlocks(blocks)
-
-    // Keep frontmatter title: in sync with H1 when sync is active
-    const isSyncActive = syncActiveRef?.current !== false
-    const fm = (isSyncActive && h1Text)
-      ? replaceTitleInFrontmatter(frontmatter, h1Text)
-      : frontmatter
-    const fullContent = `${fm}${bodyMarkdown}`
+    const fullContent = `${frontmatter}${bodyMarkdown}`
 
     onContentChangeRef.current?.(path, fullContent)
-    onH1ChangeRef.current?.(h1Text)
-  }, [editor, syncActiveRef])
+  }, [editor])
 
   // Swap document content when active tab changes.
   // Uses queueMicrotask to defer BlockNote mutations outside React's commit phase,

src/hooks/useEntryActions.test.ts

@@ -67,8 +67,8 @@ describe('useEntryActions', () => {
         await result.current.handleTrashNote('/vault/note/test.md')
       })
 
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed', true)
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at', expect.stringMatching(/^\d{4}-\d{2}-\d{2}$/))
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed', true, { silent: true })
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at', expect.stringMatching(/^\d{4}-\d{2}-\d{2}$/), { silent: true })
       expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', {
         trashed: true,
         trashedAt: expect.any(Number),
@@ -76,6 +76,19 @@ describe('useEntryActions', () => {
       expect(setToastMessage).toHaveBeenCalledWith('Note moved to trash')
       expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
     })
+
+    it('final toast is contextual, not "Property updated"', async () => {
+      const { result } = setup()
+      const toastCalls: (string | null)[] = []
+      setToastMessage.mockImplementation((msg: string | null) => toastCalls.push(msg))
+
+      await act(async () => {
+        await result.current.handleTrashNote('/vault/note/test.md')
+      })
+
+      // The only toast should be "Note moved to trash", never "Property updated"
+      expect(toastCalls).toEqual(['Note moved to trash'])
+    })
   })
 
   describe('handleRestoreNote', () => {
@@ -86,8 +99,9 @@ describe('useEntryActions', () => {
         await result.current.handleRestoreNote('/vault/note/test.md')
       })
 
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed', false)
-      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at')
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed', { silent: true })
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at', { silent: true })
+      expect(handleUpdateFrontmatter).not.toHaveBeenCalled()
       expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', {
         trashed: false,
         trashedAt: null,
@@ -105,11 +119,23 @@ describe('useEntryActions', () => {
         await result.current.handleArchiveNote('/vault/note/test.md')
       })
 
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'archived', true)
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'archived', true, { silent: true })
       expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', { archived: true })
       expect(setToastMessage).toHaveBeenCalledWith('Note archived')
       expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
     })
+
+    it('final toast is contextual, not "Property updated"', async () => {
+      const { result } = setup()
+      const toastCalls: (string | null)[] = []
+      setToastMessage.mockImplementation((msg: string | null) => toastCalls.push(msg))
+
+      await act(async () => {
+        await result.current.handleArchiveNote('/vault/note/test.md')
+      })
+
+      expect(toastCalls).toEqual(['Note archived'])
+    })
   })
 
   describe('handleUnarchiveNote', () => {
@@ -120,7 +146,8 @@ describe('useEntryActions', () => {
         await result.current.handleUnarchiveNote('/vault/note/test.md')
       })
 
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'archived', false)
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'archived', { silent: true })
+      expect(handleUpdateFrontmatter).not.toHaveBeenCalled()
       expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', { archived: false })
       expect(setToastMessage).toHaveBeenCalledWith('Note unarchived')
       expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
@@ -443,7 +470,7 @@ describe('useEntryActions', () => {
     })
 
     it('rolls back restore state when frontmatter write fails', async () => {
-      handleUpdateFrontmatter.mockRejectedValueOnce(new Error('disk full'))
+      handleDeleteProperty.mockRejectedValueOnce(new Error('disk full'))
       const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       const { result } = setup()
 
@@ -461,7 +488,7 @@ describe('useEntryActions', () => {
     })
 
     it('rolls back unarchive state when frontmatter write fails', async () => {
-      handleUpdateFrontmatter.mockRejectedValueOnce(new Error('disk full'))
+      handleDeleteProperty.mockRejectedValueOnce(new Error('disk full'))
       const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       const { result } = setup()
 

src/hooks/useEntryActions.ts

@@ -1,11 +1,12 @@
 import { useCallback } from 'react'
 import type { VaultEntry } from '../types'
+import type { FrontmatterOpOptions } from './frontmatterOps'
 
 interface EntryActionsConfig {
   entries: VaultEntry[]
   updateEntry: (path: string, updates: Partial<VaultEntry>) => void
-  handleUpdateFrontmatter: (path: string, key: string, value: string | number | boolean | string[]) => Promise<void>
-  handleDeleteProperty: (path: string, key: string) => Promise<void>
+  handleUpdateFrontmatter: (path: string, key: string, value: string | number | boolean | string[], options?: FrontmatterOpOptions) => Promise<void>
+  handleDeleteProperty: (path: string, key: string, options?: FrontmatterOpOptions) => Promise<void>
   setToastMessage: (msg: string | null) => void
   createTypeEntry: (typeName: string) => Promise<VaultEntry>
   onFrontmatterPersisted?: () => void
@@ -34,8 +35,8 @@ export function useEntryActions({
     setToastMessage('Note moved to trash')
     const now = new Date().toISOString().slice(0, 10)
     try {
-      await handleUpdateFrontmatter(path, 'Trashed', true)
-      await handleUpdateFrontmatter(path, 'Trashed at', now)
+      await handleUpdateFrontmatter(path, 'Trashed', true, { silent: true })
+      await handleUpdateFrontmatter(path, 'Trashed at', now, { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { trashed: false, trashedAt: null })
@@ -49,15 +50,15 @@ export function useEntryActions({
     updateEntry(path, { trashed: false, trashedAt: null })
     setToastMessage('Note restored from trash')
     try {
-      await handleUpdateFrontmatter(path, 'Trashed', false)
-      await handleDeleteProperty(path, 'Trashed at')
+      await handleDeleteProperty(path, 'Trashed', { silent: true })
+      await handleDeleteProperty(path, 'Trashed at', { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { trashed: true, trashedAt: Date.now() / 1000 })
       setToastMessage('Failed to restore note — rolled back')
       console.error('Optimistic restore rollback:', err)
     }
-  }, [handleUpdateFrontmatter, handleDeleteProperty, updateEntry, setToastMessage, onFrontmatterPersisted])
+  }, [handleDeleteProperty, updateEntry, setToastMessage, onFrontmatterPersisted])
 
   const handleArchiveNote = useCallback(async (path: string) => {
     await onBeforeAction?.(path)
@@ -65,7 +66,7 @@ export function useEntryActions({
     updateEntry(path, { archived: true })
     setToastMessage('Note archived')
     try {
-      await handleUpdateFrontmatter(path, 'archived', true)
+      await handleUpdateFrontmatter(path, 'archived', true, { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { archived: false })
@@ -79,14 +80,14 @@ export function useEntryActions({
     updateEntry(path, { archived: false })
     setToastMessage('Note unarchived')
     try {
-      await handleUpdateFrontmatter(path, 'archived', false)
+      await handleDeleteProperty(path, 'archived', { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { archived: true })
       setToastMessage('Failed to unarchive note — rolled back')
       console.error('Optimistic unarchive rollback:', err)
     }
-  }, [handleUpdateFrontmatter, updateEntry, setToastMessage, onFrontmatterPersisted])
+  }, [handleDeleteProperty, updateEntry, setToastMessage, onFrontmatterPersisted])
 
   const handleCustomizeType = useCallback(async (typeName: string, icon: string, color: string) => {
     const typeEntry = await findOrCreateType(entries, typeName, createTypeEntry)

src/hooks/useHeadingTitleSync.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { renderHook, act } from '@testing-library/react'
-import { useHeadingTitleSync } from './useHeadingTitleSync'
-
-describe('useHeadingTitleSync', () => {
-  beforeEach(() => { vi.useFakeTimers() })
-  afterEach(() => { vi.useRealTimers() })
-
-  it('calls onTitleSync after debounce when H1 differs from title', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Old Title', onTitleSync })
-    )
-
-    act(() => { result.current.onH1Changed('New Title') })
-    expect(onTitleSync).not.toHaveBeenCalled()
-
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).toHaveBeenCalledWith('/note.md', 'New Title')
-  })
-
-  it('does not call onTitleSync when H1 matches current title', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Same Title', onTitleSync })
-    )
-
-    act(() => { result.current.onH1Changed('Same Title') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).not.toHaveBeenCalled()
-  })
-
-  it('does not call onTitleSync when H1 is null', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Title', onTitleSync })
-    )
-
-    act(() => { result.current.onH1Changed(null) })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).not.toHaveBeenCalled()
-  })
-
-  it('debounces rapid H1 changes and uses last value', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Old', onTitleSync })
-    )
-
-    act(() => { result.current.onH1Changed('New 1') })
-    act(() => { vi.advanceTimersByTime(200) })
-    act(() => { result.current.onH1Changed('New 2') })
-    act(() => { vi.advanceTimersByTime(200) })
-    act(() => { result.current.onH1Changed('New 3') })
-    act(() => { vi.advanceTimersByTime(500) })
-
-    expect(onTitleSync).toHaveBeenCalledTimes(1)
-    expect(onTitleSync).toHaveBeenCalledWith('/note.md', 'New 3')
-  })
-
-  it('does not call onTitleSync when no active tab', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: null, currentTitle: null, onTitleSync })
-    )
-
-    act(() => { result.current.onH1Changed('Title') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).not.toHaveBeenCalled()
-  })
-
-  it('resets sync state when active tab changes', () => {
-    const onTitleSync = vi.fn()
-    const { result, rerender } = renderHook(
-      ({ path, title }) => useHeadingTitleSync({ activeTabPath: path, currentTitle: title, onTitleSync }),
-      { initialProps: { path: '/a.md', title: 'A' } }
-    )
-
-    // Break sync on tab A
-    act(() => { result.current.onManualRename('Custom', 'A H1') })
-
-    // H1 change should be ignored (sync broken)
-    act(() => { result.current.onH1Changed('New A') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).not.toHaveBeenCalled()
-
-    // Switch to tab B — sync resets
-    rerender({ path: '/b.md', title: 'B' })
-
-    // H1 change should now work
-    act(() => { result.current.onH1Changed('New B') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).toHaveBeenCalledWith('/b.md', 'New B')
-  })
-
-  it('breaks sync when manual rename differs from H1', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Title', onTitleSync })
-    )
-
-    act(() => { result.current.onManualRename('Custom Name', 'Title') })
-
-    // H1 changes should be ignored
-    act(() => { result.current.onH1Changed('New H1') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).not.toHaveBeenCalled()
-  })
-
-  it('does not break sync when manual rename matches H1', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Old', onTitleSync })
-    )
-
-    act(() => { result.current.onManualRename('Same as H1', 'Same as H1') })
-
-    // Sync should still be active
-    act(() => { result.current.onH1Changed('Updated') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).toHaveBeenCalledWith('/note.md', 'Updated')
-  })
-
-  it('does not break sync when H1 is null during manual rename', () => {
-    const onTitleSync = vi.fn()
-    const { result } = renderHook(() =>
-      useHeadingTitleSync({ activeTabPath: '/note.md', currentTitle: 'Title', onTitleSync })
-    )
-
-    act(() => { result.current.onManualRename('New Name', null) })
-
-    // Sync should still be active (no H1 to compare)
-    act(() => { result.current.onH1Changed('H1 Text') })
-    act(() => { vi.advanceTimersByTime(500) })
-    expect(onTitleSync).toHaveBeenCalledWith('/note.md', 'H1 Text')
-  })
-
-  it('clears pending debounce timer on tab switch', () => {
-    const onTitleSync = vi.fn()
-    const { result, rerender } = renderHook(
-      ({ path, title }) => useHeadingTitleSync({ activeTabPath: path, currentTitle: title, onTitleSync }),
-      { initialProps: { path: '/a.md', title: 'A' } }
-    )
-
-    act(() => { result.current.onH1Changed('New A') })
-    // Switch tab before debounce fires
-    rerender({ path: '/b.md', title: 'B' })
-    act(() => { vi.advanceTimersByTime(500) })
-
-    // Should NOT fire for old tab
-    expect(onTitleSync).not.toHaveBeenCalled()
-  })
-})

src/hooks/useHeadingTitleSync.ts

@@ -1,68 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react'
-
-interface HeadingTitleSyncConfig {
-  activeTabPath: string | null
-  currentTitle: string | null
-  onTitleSync: (path: string, newTitle: string) => void
-}
-
-const DEBOUNCE_MS = 500
-
-/**
- * Syncs the note title with the editor's first H1 heading.
- *
- * - On every editor change, the caller passes the current H1 text via onH1Changed.
- * - After a 500ms debounce, VaultEntry.title is updated to match.
- * - If the user manually renames the title (via tab) to something different from
- *   the H1, sync breaks and stops updating until the tab is switched.
- * - If the H1 is deleted, the last synced title is kept (no clear).
- */
-export function useHeadingTitleSync({
-  activeTabPath,
-  currentTitle,
-  onTitleSync,
-}: HeadingTitleSyncConfig) {
-  const syncActiveRef = useRef(true)
-  const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)
-  const activeTabPathRef = useRef(activeTabPath)
-  // eslint-disable-next-line react-hooks/refs
-  activeTabPathRef.current = activeTabPath
-  const onTitleSyncRef = useRef(onTitleSync)
-  // eslint-disable-next-line react-hooks/refs
-  onTitleSyncRef.current = onTitleSync
-  const currentTitleRef = useRef(currentTitle)
-  // eslint-disable-next-line react-hooks/refs
-  currentTitleRef.current = currentTitle
-
-  // Reset sync state when switching tabs
-  useEffect(() => {
-    syncActiveRef.current = true
-    clearTimeout(debounceTimerRef.current)
-  }, [activeTabPath])
-
-  // Cleanup on unmount
-  useEffect(() => () => clearTimeout(debounceTimerRef.current), [])
-
-  /** Called on every editor change with the H1 text (null if no H1 first block). */
-  const onH1Changed = useCallback((h1Text: string | null) => {
-    if (!h1Text || !activeTabPathRef.current || !syncActiveRef.current) return
-    if (h1Text === currentTitleRef.current) return
-
-    clearTimeout(debounceTimerRef.current)
-    debounceTimerRef.current = setTimeout(() => {
-      if (syncActiveRef.current && activeTabPathRef.current) {
-        onTitleSyncRef.current(activeTabPathRef.current, h1Text)
-      }
-    }, DEBOUNCE_MS)
-  }, [])
-
-  /** Called when the user manually renames via tab double-click.
-   *  Breaks sync if the new title differs from the current H1. */
-  const onManualRename = useCallback((newTitle: string, currentH1: string | null) => {
-    if (currentH1 && currentH1 !== newTitle) {
-      syncActiveRef.current = false
-    }
-  }, [])
-
-  return { syncActiveRef, onH1Changed, onManualRename }
-}

src/hooks/useMenuEvents.test.ts

@@ -31,12 +31,14 @@ function makeHandlers(): MenuEventHandlers {
     onCreateTheme: vi.fn(),
     onRestoreDefaultThemes: vi.fn(),
     onCommitPush: vi.fn(),
+    onPull: vi.fn(),
     onResolveConflicts: vi.fn(),
     onViewChanges: vi.fn(),
     onInstallMcp: vi.fn(),
     onReindexVault: vi.fn(),
     onReloadVault: vi.fn(),
     onReopenClosedTab: vi.fn(),
+    onOpenInNewWindow: vi.fn(),
     activeTabPathRef: { current: '/vault/test.md' } as React.MutableRefObject<string | null>,
     handleCloseTabRef: { current: vi.fn() } as React.MutableRefObject<(path: string) => void>,
     activeTabPath: '/vault/test.md',
@@ -284,6 +286,12 @@ describe('dispatchMenuEvent', () => {
     expect(h.onCommitPush).toHaveBeenCalled()
   })
 
+  it('vault-pull triggers pull', () => {
+    const h = makeHandlers()
+    dispatchMenuEvent('vault-pull', h)
+    expect(h.onPull).toHaveBeenCalled()
+  })
+
   it('vault-resolve-conflicts triggers resolve conflicts', () => {
     const h = makeHandlers()
     dispatchMenuEvent('vault-resolve-conflicts', h)
@@ -321,6 +329,13 @@ describe('dispatchMenuEvent', () => {
     expect(h.onReopenClosedTab).toHaveBeenCalled()
   })
 
+  // Note: open in new window
+  it('note-open-in-new-window triggers open in new window', () => {
+    const h = makeHandlers()
+    dispatchMenuEvent('note-open-in-new-window', h)
+    expect(h.onOpenInNewWindow).toHaveBeenCalled()
+  })
+
   // Edge cases
   it('unknown event ID does nothing', () => {
     const h = makeHandlers()

src/hooks/useMenuEvents.ts

@@ -32,10 +32,12 @@ export interface MenuEventHandlers {
   onCreateTheme?: () => void
   onRestoreDefaultThemes?: () => void
   onCommitPush?: () => void
+  onPull?: () => void
   onResolveConflicts?: () => void
   onViewChanges?: () => void
   onInstallMcp?: () => void
   onReopenClosedTab?: () => void
+  onOpenInNewWindow?: () => void
   onReindexVault?: () => void
   onReloadVault?: () => void
   onRepairVault?: () => void
@@ -75,6 +77,7 @@ const FILTER_MAP: Record<string, SidebarFilter> = {
   'go-archived': 'archived',
   'go-trash': 'trash',
   'go-changes': 'changes',
+  'go-inbox': 'inbox',
 }
 
 type OptionalHandler =
@@ -82,9 +85,10 @@ type OptionalHandler =
   | 'onCreateType' | 'onToggleRawEditor' | 'onToggleDiff' | 'onToggleAIChat'
   | 'onOpenVault' | 'onRemoveActiveVault' | 'onRestoreGettingStarted'
   | 'onCreateTheme' | 'onRestoreDefaultThemes'
-  | 'onCommitPush' | 'onResolveConflicts' | 'onViewChanges' | 'onInstallMcp' | 'onReindexVault' | 'onReloadVault' | 'onRepairVault'
+  | 'onCommitPush' | 'onPull' | 'onResolveConflicts' | 'onViewChanges' | 'onInstallMcp' | 'onReindexVault' | 'onReloadVault' | 'onRepairVault'
   | 'onEmptyTrash'
   | 'onReopenClosedTab'
+  | 'onOpenInNewWindow'
 
 const OPTIONAL_EVENT_MAP: Record<string, OptionalHandler> = {
   'view-go-back': 'onGoBack',
@@ -100,6 +104,7 @@ const OPTIONAL_EVENT_MAP: Record<string, OptionalHandler> = {
   'vault-new-theme': 'onCreateTheme',
   'vault-restore-default-themes': 'onRestoreDefaultThemes',
   'vault-commit-push': 'onCommitPush',
+  'vault-pull': 'onPull',
   'vault-resolve-conflicts': 'onResolveConflicts',
   'vault-view-changes': 'onViewChanges',
   'vault-install-mcp': 'onInstallMcp',
@@ -108,6 +113,7 @@ const OPTIONAL_EVENT_MAP: Record<string, OptionalHandler> = {
   'vault-repair': 'onRepairVault',
   'note-empty-trash': 'onEmptyTrash',
   'file-reopen-closed-tab': 'onReopenClosedTab',
+  'note-open-in-new-window': 'onOpenInNewWindow',
 }
 
 function dispatchActiveTabEvent(id: string, h: MenuEventHandlers): boolean {

src/hooks/useNoteActions.test.ts

@@ -19,7 +19,7 @@ import {
   resolveTemplate,
 } from './useNoteCreation'
 import { needsRenameOnSave } from './useNoteRename'
-import { frontmatterToEntryPatch } from './frontmatterOps'
+import { frontmatterToEntryPatch, applyRelationshipPatch } from './frontmatterOps'
 import { useNoteActions } from './useNoteActions'
 import type { NoteActionsConfig } from './useNoteActions'
 
@@ -345,25 +345,45 @@ describe('frontmatterToEntryPatch', () => {
   ] as [string, unknown, Partial<VaultEntry>][])(
     'maps %s update to correct entry field',
     (key, value, expected) => {
-      expect(frontmatterToEntryPatch('update', key, value as never)).toEqual(expected)
+      expect(frontmatterToEntryPatch('update', key, value as never).patch).toEqual(expected)
     },
   )
 
   it('maps aliases update with array value', () => {
-    expect(frontmatterToEntryPatch('update', 'aliases', ['A', 'B'])).toEqual({ aliases: ['A', 'B'] })
+    expect(frontmatterToEntryPatch('update', 'aliases', ['A', 'B']).patch).toEqual({ aliases: ['A', 'B'] })
   })
 
   it('maps belongs_to update with array value', () => {
-    expect(frontmatterToEntryPatch('update', 'belongs_to', ['[[parent]]'])).toEqual({ belongsTo: ['[[parent]]'] })
+    const result = frontmatterToEntryPatch('update', 'belongs_to', ['[[parent]]'])
+    expect(result.patch).toEqual({ belongsTo: ['[[parent]]'] })
+    // Also produces a relationship patch for the wikilink
+    expect(result.relationshipPatch).toEqual({ 'belongs_to': ['[[parent]]'] })
   })
 
   it('handles case-insensitive keys with spaces (e.g. "Is A", "Belongs to")', () => {
-    expect(frontmatterToEntryPatch('update', 'Is A', 'Experiment')).toEqual({ isA: 'Experiment' })
-    expect(frontmatterToEntryPatch('update', 'Belongs to', ['[[x]]'])).toEqual({ belongsTo: ['[[x]]'] })
+    expect(frontmatterToEntryPatch('update', 'Is A', 'Experiment').patch).toEqual({ isA: 'Experiment' })
+    const result = frontmatterToEntryPatch('update', 'Belongs to', ['[[x]]'])
+    expect(result.patch).toEqual({ belongsTo: ['[[x]]'] })
+    expect(result.relationshipPatch).toEqual({ 'Belongs to': ['[[x]]'] })
   })
 
-  it('returns empty object for unknown keys', () => {
-    expect(frontmatterToEntryPatch('update', 'custom_field', 'value')).toEqual({})
+  it('returns empty patch for unknown non-wikilink keys', () => {
+    const result = frontmatterToEntryPatch('update', 'custom_field', 'value')
+    expect(result.patch).toEqual({})
+    // Non-wikilink value → no relationship change
+    expect(result.relationshipPatch).toBeNull()
+  })
+
+  it('produces relationship patch for wikilink values on unknown keys', () => {
+    const result = frontmatterToEntryPatch('update', 'Notes', ['[[note-a]]', '[[note-b|Note B]]'])
+    expect(result.patch).toEqual({})
+    expect(result.relationshipPatch).toEqual({ Notes: ['[[note-a]]', '[[note-b|Note B]]'] })
+  })
+
+  it('produces relationship patch for single wikilink string', () => {
+    const result = frontmatterToEntryPatch('update', 'Owner', '[[person/alice]]')
+    expect(result.patch).toEqual({})
+    expect(result.relationshipPatch).toEqual({ Owner: ['[[person/alice]]'] })
   })
 
   it.each([
@@ -377,12 +397,46 @@ describe('frontmatterToEntryPatch', () => {
   ] as [string, Partial<VaultEntry>][])(
     'maps delete of %s to null/default',
     (key, expected) => {
-      expect(frontmatterToEntryPatch('delete', key)).toEqual(expected)
+      expect(frontmatterToEntryPatch('delete', key).patch).toEqual(expected)
     },
   )
 
-  it('returns empty object for unknown key on delete', () => {
-    expect(frontmatterToEntryPatch('delete', 'unknown_key')).toEqual({})
+  it('returns empty patch for unknown key on delete, with relationship removal', () => {
+    const result = frontmatterToEntryPatch('delete', 'unknown_key')
+    expect(result.patch).toEqual({})
+    expect(result.relationshipPatch).toEqual({ unknown_key: null })
+  })
+
+  it('delete of known key also produces relationship removal', () => {
+    const result = frontmatterToEntryPatch('delete', 'status')
+    expect(result.patch).toEqual({ status: null })
+    expect(result.relationshipPatch).toEqual({ status: null })
+  })
+})
+
+describe('applyRelationshipPatch', () => {
+  it('adds new relationship key', () => {
+    const existing = { 'Belongs to': ['[[eng]]'] }
+    const result = applyRelationshipPatch(existing, { Notes: ['[[note-a]]', '[[note-b]]'] })
+    expect(result).toEqual({ 'Belongs to': ['[[eng]]'], Notes: ['[[note-a]]', '[[note-b]]'] })
+  })
+
+  it('overwrites existing relationship key', () => {
+    const existing = { Notes: ['[[old]]'] }
+    const result = applyRelationshipPatch(existing, { Notes: ['[[new-a]]', '[[new-b]]'] })
+    expect(result).toEqual({ Notes: ['[[new-a]]', '[[new-b]]'] })
+  })
+
+  it('removes relationship key when value is null', () => {
+    const existing = { Notes: ['[[a]]'], Owner: ['[[alice]]'] }
+    const result = applyRelationshipPatch(existing, { Notes: null })
+    expect(result).toEqual({ Owner: ['[[alice]]'] })
+  })
+
+  it('does not mutate the original map', () => {
+    const existing = { Notes: ['[[a]]'] }
+    applyRelationshipPatch(existing, { Notes: ['[[b]]'] })
+    expect(existing).toEqual({ Notes: ['[[a]]'] })
   })
 })
 

src/hooks/useNoteActions.ts

@@ -10,7 +10,7 @@ import {
   useNoteRename,
   performRename, loadNoteContent, renameToastMessage, reloadTabsAfterRename,
 } from './useNoteRename'
-import { runFrontmatterAndApply } from './frontmatterOps'
+import { runFrontmatterAndApply, type FrontmatterOpOptions } from './frontmatterOps'
 
 export interface NoteActionsConfig {
   addEntry: (entry: VaultEntry) => void
@@ -27,6 +27,8 @@ export interface NoteActionsConfig {
   markContentPending?: (path: string, content: string) => void
   onNewNotePersisted?: () => void
   replaceEntry?: (oldPath: string, patch: Partial<VaultEntry> & { path: string }) => void
+  /** Called after frontmatter is written to disk — used for live-reloading theme CSS vars. */
+  onFrontmatterContentChanged?: (path: string, content: string) => void
 }
 
 function isTitleKey(key: string): boolean {
@@ -114,9 +116,9 @@ export function useNoteActions(config: NoteActionsConfig) {
   )
 
   const runFrontmatterOp = useCallback(
-    (op: 'update' | 'delete', path: string, key: string, value?: FrontmatterValue) =>
-      runFrontmatterAndApply(op, path, key, value, { updateTab: updateTabContent, updateEntry, toast: setToastMessage }),
-    [updateTabContent, updateEntry, setToastMessage],
+    (op: 'update' | 'delete', path: string, key: string, value?: FrontmatterValue, options?: FrontmatterOpOptions) =>
+      runFrontmatterAndApply(op, path, key, value, { updateTab: updateTabContent, updateEntry, toast: setToastMessage, getEntry: (p) => entries.find((e) => e.path === p) }, options),
+    [updateTabContent, updateEntry, setToastMessage, entries],
   )
 
   return {
@@ -130,8 +132,9 @@ export function useNoteActions(config: NoteActionsConfig) {
     handleOpenDailyNote: creation.handleOpenDailyNote,
     handleCreateType: creation.handleCreateType,
     createTypeEntrySilent: creation.createTypeEntrySilent,
-    handleUpdateFrontmatter: useCallback(async (path: string, key: string, value: FrontmatterValue) => {
-      await runFrontmatterOp('update', path, key, value)
+    handleUpdateFrontmatter: useCallback(async (path: string, key: string, value: FrontmatterValue, options?: FrontmatterOpOptions) => {
+      const newContent = await runFrontmatterOp('update', path, key, value, options)
+      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
       if (shouldRenameOnTitleUpdate(key, value)) {
         try {
           await renameAfterTitleChange(path, value, {
@@ -142,9 +145,15 @@ export function useNoteActions(config: NoteActionsConfig) {
           console.error('Failed to rename note after title change:', err)
         }
       }
-    }, [runFrontmatterOp, config.vaultPath, config.replaceEntry, rename.tabsRef, setTabs, activeTabPathRef, handleSwitchTab, setToastMessage, updateTabContent]),
-    handleDeleteProperty: useCallback((path: string, key: string) => runFrontmatterOp('delete', path, key), [runFrontmatterOp]),
-    handleAddProperty: useCallback((path: string, key: string, value: FrontmatterValue) => runFrontmatterOp('update', path, key, value), [runFrontmatterOp]),
+    }, [runFrontmatterOp, config, rename.tabsRef, setTabs, activeTabPathRef, handleSwitchTab, setToastMessage, updateTabContent]),
+    handleDeleteProperty: useCallback(async (path: string, key: string, options?: FrontmatterOpOptions) => {
+      const newContent = await runFrontmatterOp('delete', path, key, undefined, options)
+      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
+    }, [runFrontmatterOp, config]),
+    handleAddProperty: useCallback(async (path: string, key: string, value: FrontmatterValue) => {
+      const newContent = await runFrontmatterOp('update', path, key, value)
+      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
+    }, [runFrontmatterOp, config]),
     handleRenameNote: rename.handleRenameNote,
   }
 }

src/hooks/usePropertyPanelState.ts

@@ -11,7 +11,8 @@ import {
 import { containsWikilinks } from '../components/DynamicPropertiesPanel'
 
 // Keys to skip showing in Properties (handled by dedicated UI or internal)
-const SKIP_KEYS = new Set(['aliases', 'workspace', 'title', 'type', 'is_a', 'Is A'])
+// Compared case-insensitively via isVisibleProperty()
+const SKIP_KEYS = new Set(['aliases', 'workspace', 'title', 'type', 'is_a', 'is a', 'trashed', 'trashed_at', 'archived', 'archived_at', 'icon'])
 
 function coerceValue(raw: string): FrontmatterValue {
   if (raw.toLowerCase() === 'true') return true
@@ -79,7 +80,7 @@ function collectAllVaultTags(entries: VaultEntry[] | undefined): Record<string,
 }
 
 function isVisibleProperty([key, value]: [string, FrontmatterValue]): boolean {
-  return !SKIP_KEYS.has(key) && !containsWikilinks(value)
+  return !SKIP_KEYS.has(key.toLowerCase()) && !containsWikilinks(value)
 }
 
 function parseAddedValue(rawValue: string, mode: PropertyDisplayMode): FrontmatterValue {

src/hooks/useThemeManager.test.ts

@@ -470,6 +470,38 @@ text-primary: "#e0e0e0"
     expect(document.documentElement.style.getPropertyValue('--sidebar')).toBe('#2a2a3e')
   })
 
+  it('notifyThemeSaved updates bullet-size and bullet-color CSS vars', async () => {
+    const { result } = renderHook(() =>
+      useThemeManager('/vault', entries, allContent)
+    )
+    await waitFor(() => {
+      expect(result.current.activeThemeId).toBe(THEME_PATH_DEFAULT)
+    })
+
+    const updatedContent = `---
+type: Theme
+Description: Light theme
+background: "#FFFFFF"
+foreground: "#37352F"
+primary: "#155DFF"
+sidebar: "#F7F6F3"
+text-primary: "#37352F"
+lists-bullet-size: 32px
+lists-bullet-color: "#FF0000"
+---
+
+# Default Theme
+`
+    act(() => {
+      result.current.notifyThemeSaved(THEME_PATH_DEFAULT, updatedContent)
+    })
+
+    await waitFor(() => {
+      expect(document.documentElement.style.getPropertyValue('--lists-bullet-size')).toBe('32px')
+    })
+    expect(document.documentElement.style.getPropertyValue('--lists-bullet-color')).toBe('#FF0000')
+  })
+
   it('notifyThemeSaved is a no-op for non-active theme path', async () => {
     const { result } = renderHook(() =>
       useThemeManager('/vault', entries, allContent)
@@ -547,4 +579,32 @@ background: "#FF0000"
     await new Promise(r => setTimeout(r, 50))
     expect(mockInvokeFn).not.toHaveBeenCalledWith('ensure_vault_themes', expect.anything())
   })
+
+  it('skips theme reload on focus within 30s cooldown', async () => {
+    const now = vi.spyOn(Date, 'now')
+    let clock = 1000
+    now.mockImplementation(() => clock)
+
+    renderHook(() => useThemeManager('/vault', entries, allContent))
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('get_vault_settings', { vaultPath: '/vault' })
+    })
+
+    mockInvokeFn.mockClear()
+
+    // Focus within cooldown — should NOT reload settings
+    clock += 5_000
+    await act(async () => { window.dispatchEvent(new Event('focus')) })
+    const settingsCalls = mockInvokeFn.mock.calls.filter((c: unknown[]) => c[0] === 'get_vault_settings')
+    expect(settingsCalls).toHaveLength(0)
+
+    // Focus after cooldown — should reload
+    clock += 30_000
+    await act(async () => { window.dispatchEvent(new Event('focus')) })
+    await waitFor(() => {
+      expect(mockInvokeFn).toHaveBeenCalledWith('get_vault_settings', { vaultPath: '/vault' })
+    })
+
+    now.mockRestore()
+  })
 })

src/hooks/useThemeManager.ts

@@ -79,15 +79,31 @@ function clearColorScheme(): void {
   delete root.dataset.themeMode
 }
 
+const THEME_STYLE_ID = 'laputa-theme-vars'
+
+function getOrCreateThemeStyle(): HTMLStyleElement {
+  let el = document.getElementById(THEME_STYLE_ID) as HTMLStyleElement | null
+  if (!el) {
+    el = document.createElement('style')
+    el.id = THEME_STYLE_ID
+    document.head.appendChild(el)
+  }
+  return el
+}
+
 function applyVarsToDom(vars: Record<string, string>): void {
   const root = document.documentElement
   for (const [key, value] of Object.entries(vars)) {
     root.style.setProperty(key, value)
   }
   updateColorScheme(vars)
-  // Force WebKit to recalculate ::before/::after pseudo-element styles
-  // when CSS custom properties change (WKWebView doesn't auto-invalidate).
-  void root.offsetHeight
+  // WKWebView doesn't invalidate ::before/::after pseudo-element styles when
+  // CSS custom properties change via inline styles alone — `void offsetHeight`
+  // triggers layout reflow but not style recalculation on pseudo-elements.
+  // Replacing a <style> element's content forces a full style tree invalidation
+  // that covers pseudo-elements using var() references (e.g. bullet size/color).
+  const css = Object.entries(vars).map(([k, v]) => `${k}:${v}`).join(';')
+  getOrCreateThemeStyle().textContent = `:root{${css}}`
 }
 
 function clearVarsFromDom(vars: Record<string, string>): void {
@@ -95,6 +111,7 @@ function clearVarsFromDom(vars: Record<string, string>): void {
   for (const key of Object.keys(vars)) {
     root.style.removeProperty(key)
   }
+  getOrCreateThemeStyle().textContent = ''
   clearColorScheme()
 }
 
@@ -146,9 +163,17 @@ function useThemeSetting(vaultPath: string | null) {
   // eslint-disable-next-line react-hooks/set-state-in-effect -- async fn; setState runs after await
   useEffect(() => { load() }, [load])
 
+  const lastLoadRef = useRef(0)
   useEffect(() => {
-    window.addEventListener('focus', load)
-    return () => window.removeEventListener('focus', load)
+    const FOCUS_COOLDOWN_MS = 30_000
+    const handleFocus = () => {
+      const now = Date.now()
+      if (now - lastLoadRef.current < FOCUS_COOLDOWN_MS) return
+      lastLoadRef.current = now
+      load()
+    }
+    window.addEventListener('focus', handleFocus)
+    return () => window.removeEventListener('focus', handleFocus)
   }, [load])
 
   return { activeThemeId, setActiveThemeId, reload: load }
@@ -205,11 +230,36 @@ function useThemeApplier(
   return { clearDom, isDark }
 }
 
+/** Deactivate the theme and persist `null` to vault settings. */
+function deactivateTheme(
+  vaultPath: string | null,
+  clearTheme: () => void,
+  setActiveThemeId: (id: string | null) => void,
+) {
+  clearTheme()
+  setActiveThemeId(null)
+  if (vaultPath) tauriCall('set_active_theme', { vaultPath, themeId: null }).catch(() => {})
+}
+
+/** True when the active theme should be cleared (stale, trashed, or archived). */
+function shouldDeactivate(
+  activeThemeId: string | null,
+  themes: ThemeFile[],
+  entries: VaultEntry[],
+  userSetId: string | null,
+): boolean {
+  if (!activeThemeId) return false
+  // Stale ID from old theme system — skip IDs just set by user action
+  if (themes.length > 0 && activeThemeId !== userSetId && !themes.some(t => t.id === activeThemeId)) return true
+  // Trashed or archived
+  const entry = entries.find(e => e.path === activeThemeId)
+  return !!entry && isEntryRemoved(entry)
+}
+
 export function useThemeManager(
   vaultPath: string | null,
   entries: VaultEntry[],
 ): ThemeManager {
-  // Ensure default theme files exist on vault open (creates theme/ dir + defaults if missing)
   useEffect(() => {
     if (vaultPath) tauriCall('ensure_vault_themes', { vaultPath }).catch(() => {})
   }, [vaultPath])
@@ -217,14 +267,10 @@ export function useThemeManager(
   const { activeThemeId, setActiveThemeId, reload } = useThemeSetting(vaultPath)
   const [cachedThemeContent, setCachedThemeContent] = useState<string | undefined>(undefined)
 
-  // Clear cached content when theme changes — useThemeApplier will fetch from disk
   // eslint-disable-next-line react-hooks/set-state-in-effect
   useEffect(() => { setCachedThemeContent(undefined) }, [activeThemeId])
 
   const { clearDom: clearTheme, isDark } = useThemeApplier(activeThemeId, cachedThemeContent)
-
-  // Track IDs set by user actions (switchTheme/createTheme) so the stale-ID
-  // cleanup doesn't clear a newly-created theme that isn't in entries yet.
   const userSetIdRef = useRef<string | null>(null)
 
   const themes = useMemo(
@@ -239,30 +285,12 @@ export function useThemeManager(
     [themes, activeThemeId],
   )
 
-  // If active theme ID doesn't match any known theme (e.g. stale ID from old
-  // JSON-based theme system), clear it so the app doesn't try to load a
-  // non-existent path. Skip IDs just set by switchTheme/createTheme — the
-  // entry may not have appeared in `entries` yet.
+  // Deactivate stale, trashed, or archived theme
   useEffect(() => {
-    if (!activeThemeId || themes.length === 0) return
-    if (activeThemeId === userSetIdRef.current) return
-    const isKnown = themes.some(t => t.id === activeThemeId)
-    if (!isKnown) {
-      clearTheme()
-      setActiveThemeId(null)
-      if (vaultPath) tauriCall('set_active_theme', { vaultPath, themeId: null }).catch(() => {})
+    if (shouldDeactivate(activeThemeId, themes, entries, userSetIdRef.current)) {
+      deactivateTheme(vaultPath, clearTheme, setActiveThemeId)
     }
-  }, [activeThemeId, themes, clearTheme, vaultPath, setActiveThemeId])
-
-  // If active theme is trashed or archived: clear CSS vars and fall back to no theme
-  useEffect(() => {
-    if (!activeThemeId) return
-    const entry = entries.find(e => e.path === activeThemeId)
-    if (!entry || !isEntryRemoved(entry)) return
-    clearTheme()
-    setActiveThemeId(null)
-    if (vaultPath) tauriCall('set_active_theme', { vaultPath, themeId: null }).catch(() => {})
-  }, [entries, activeThemeId, clearTheme, vaultPath, setActiveThemeId])
+  }, [activeThemeId, themes, entries, clearTheme, vaultPath, setActiveThemeId])
 
   const switchTheme = useCallback(async (themeId: string) => {
     if (!vaultPath) return
@@ -294,9 +322,7 @@ export function useThemeManager(
     if (!activeThemeId) return
     try {
       const newContent = await tauriCall<string>('update_frontmatter', {
-        path: activeThemeId,
-        key,
-        value,
+        path: activeThemeId, key, value,
       })
       setCachedThemeContent(newContent)
     } catch (err) { console.error('Failed to update theme property:', err) }

src/hooks/useVaultLoader.test.ts

@@ -362,15 +362,15 @@ describe('useVaultLoader', () => {
         expect(result.current.entries).toHaveLength(1)
       })
 
-      let response = ''
+      let response: { status: string; message: string } = { status: '', message: '' }
       await act(async () => {
         response = await result.current.commitAndPush('test commit')
       })
 
-      expect(response).toBe('Committed and pushed')
+      expect(response.status).toBe('ok')
     })
 
-    it('returns actionable message when push is rejected', async () => {
+    it('returns rejected status when push is rejected', async () => {
       mockInvokeFn.mockImplementation(((cmd: string) => {
         if (cmd === 'list_vault') return Promise.resolve(mockEntries)
         if (cmd === 'get_all_content') return Promise.resolve(mockContent)
@@ -383,16 +383,16 @@ describe('useVaultLoader', () => {
       const { result } = renderHook(() => useVaultLoader('/vault'))
       await waitFor(() => { expect(result.current.entries).toHaveLength(1) })
 
-      let response = ''
+      let response: { status: string; message: string } = { status: '', message: '' }
       await act(async () => {
         response = await result.current.commitAndPush('test commit')
       })
 
-      expect(response).toContain('Pull first')
-      expect(response).not.toBe('Committed and pushed')
+      expect(response.status).toBe('rejected')
+      expect(response.message).toContain('Pull first')
     })
 
-    it('returns network error message on network failure', async () => {
+    it('returns network error status on network failure', async () => {
       mockInvokeFn.mockImplementation(((cmd: string) => {
         if (cmd === 'list_vault') return Promise.resolve(mockEntries)
         if (cmd === 'get_all_content') return Promise.resolve(mockContent)
@@ -405,12 +405,13 @@ describe('useVaultLoader', () => {
       const { result } = renderHook(() => useVaultLoader('/vault'))
       await waitFor(() => { expect(result.current.entries).toHaveLength(1) })
 
-      let response = ''
+      let response: { status: string; message: string } = { status: '', message: '' }
       await act(async () => {
         response = await result.current.commitAndPush('test commit')
       })
 
-      expect(response).toContain('network error')
+      expect(response.status).toBe('network_error')
+      expect(response.message).toContain('network error')
     })
   })
 

src/hooks/useVaultLoader.ts

@@ -15,15 +15,13 @@ async function loadVaultData(vaultPath: string) {
   return { entries }
 }
 
-async function commitWithPush(vaultPath: string, message: string): Promise<string> {
+async function commitWithPush(vaultPath: string, message: string): Promise<GitPushResult> {
   if (!isTauri()) {
     await mockInvoke<string>('git_commit', { message })
-    const pushResult = await mockInvoke<GitPushResult>('git_push', {})
-    return pushResult.status === 'ok' ? 'Committed and pushed' : pushResult.message
+    return mockInvoke<GitPushResult>('git_push', {})
   }
   await invoke<string>('git_commit', { vaultPath, message })
-  const pushResult = await invoke<GitPushResult>('git_push', { vaultPath })
-  return pushResult.status === 'ok' ? 'Committed and pushed' : pushResult.message
+  return invoke<GitPushResult>('git_push', { vaultPath })
 }
 
 function useNewNoteTracker() {
@@ -156,7 +154,7 @@ export function useVaultLoader(vaultPath: string) {
   const getNoteStatus = useCallback((path: string): NoteStatus =>
     resolveNoteStatus(path, tracker.newPaths, modifiedFiles, pendingSave.pendingSavePaths, unsaved.unsavedPaths), [tracker.newPaths, modifiedFiles, pendingSave.pendingSavePaths, unsaved.unsavedPaths])
 
-  const commitAndPush = useCallback((message: string): Promise<string> =>
+  const commitAndPush = useCallback((message: string): Promise<GitPushResult> =>
     commitWithPush(vaultPath, message), [vaultPath])
 
   const reloadVault = useCallback(

src/main.tsx

@@ -3,6 +3,8 @@ import { createRoot } from 'react-dom/client'
 import { TooltipProvider } from '@/components/ui/tooltip'
 import './index.css'
 import App from './App.tsx'
+import NoteWindow from './NoteWindow.tsx'
+import { isNoteWindow } from './utils/windowMode'
 
 // Disable native WebKit context menu in Tauri (WKWebView intercepts right-click
 // at native level before React's synthetic events can call preventDefault).
@@ -12,10 +14,12 @@ if ('__TAURI__' in window || '__TAURI_INTERNALS__' in window) {
   document.addEventListener('contextmenu', (e) => e.preventDefault(), true)
 }
 
+const RootComponent = isNoteWindow() ? NoteWindow : App
+
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
     <TooltipProvider>
-      <App />
+      <RootComponent />
     </TooltipProvider>
   </StrictMode>,
 )

src/mock-tauri/mock-handlers.ts

@@ -3,7 +3,7 @@
  * Each handler simulates a Tauri backend command.
  */
 
-import type { VaultEntry, VaultConfig, ModifiedFile, Settings, DeviceFlowStart, DeviceFlowPollResult, GitHubUser, GitPullResult, GitPushResult, LastCommitInfo, ThemeFile, VaultSettings, PulseCommit } from '../types'
+import type { VaultEntry, VaultConfig, ModifiedFile, Settings, DeviceFlowStart, DeviceFlowPollResult, GitHubUser, GitPullResult, GitPushResult, GitRemoteStatus, LastCommitInfo, ThemeFile, VaultSettings, PulseCommit } from '../types'
 import { MOCK_CONTENT } from './mock-content'
 import { MOCK_ENTRIES } from './mock-entries'
 
@@ -180,6 +180,7 @@ export const mockHandlers: Record<string, (args: any) => any> = {
   get_last_commit_info: (): LastCommitInfo => ({ shortHash: 'a1b2c3d', commitUrl: 'https://github.com/lucaong/laputa-vault/commit/a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0' }),
   git_pull: (): GitPullResult => ({ status: 'up_to_date', message: 'Already up to date', updatedFiles: [], conflictFiles: [] }),
   git_push: (): GitPushResult => ({ status: 'ok', message: 'Pushed to remote' }),
+  git_remote_status: (): GitRemoteStatus => ({ branch: 'main', ahead: 0, behind: 0, hasRemote: true }),
   get_vault_pulse: (args: { limit?: number }): PulseCommit[] => {
     const limit = args.limit ?? 30
     const ts = Math.floor(Date.now() / 1000)

src/types.ts

@@ -83,7 +83,14 @@ export interface GitPushResult {
   message: string
 }
 
-export type SyncStatus = 'idle' | 'syncing' | 'error' | 'conflict'
+export type SyncStatus = 'idle' | 'syncing' | 'error' | 'conflict' | 'pull_required'
+
+export interface GitRemoteStatus {
+  branch: string
+  ahead: number
+  behind: number
+  hasRemote: boolean
+}
 
 export interface DeviceFlowStart {
   device_code: string
@@ -148,7 +155,7 @@ export interface VaultSettings {
   theme: string | null
 }
 
-/** Vault-wide UI configuration stored in config/ui.config.md. */
+/** Vault-wide UI configuration stored in ui.config.md at vault root. */
 export interface VaultConfig {
   zoom: number | null
   view_mode: string | null
@@ -176,10 +183,11 @@ export interface PulseCommit {
   deleted: number
 }
 
-export type SidebarFilter = 'all' | 'archived' | 'trash' | 'changes' | 'pulse'
+export type SidebarFilter = 'all' | 'archived' | 'trash' | 'changes' | 'pulse' | 'inbox'
+
+export type InboxPeriod = 'week' | 'month' | 'quarter' | 'all'
 
 export type SidebarSelection =
   | { kind: 'filter'; filter: SidebarFilter }
   | { kind: 'sectionGroup'; type: string }
   | { kind: 'entity'; entry: VaultEntry }
-  | { kind: 'topic'; entry: VaultEntry }

src/utils/noteListHelpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from 'vitest'
-import { formatSubtitle, formatSearchSubtitle, relativeDate, buildRelationshipGroups, getSortComparator, extractSortableProperties, getSortOptionLabel, getDefaultDirection, parseSortConfig, serializeSortConfig } from './noteListHelpers'
+import { formatSubtitle, formatSearchSubtitle, relativeDate, buildRelationshipGroups, getSortComparator, extractSortableProperties, getSortOptionLabel, getDefaultDirection, parseSortConfig, serializeSortConfig, buildValidLinkTargets, isInboxEntry, filterInboxEntries } from './noteListHelpers'
 import type { VaultEntry } from '../types'
 
 function makeEntry(overrides: Partial<VaultEntry> = {}): VaultEntry {
@@ -324,6 +324,84 @@ describe('buildRelationshipGroups', () => {
     const groups = buildRelationshipGroups(entity, [entity, linker])
     expect(groups.find((g) => g.label === 'Backlinks')!.entries[0].title).toBe('Linker')
   })
+
+  it('resolves all entries in a large Notes relationship (regression: No Code)', () => {
+    // Simulates the No Code topic note with 32 Notes, 2 Referred by Data, 1 Belongs to
+    const noteRefs = [
+      '8020', 'airdev-build-hub', 'airdev-leader', 'budibase', 'bullet-launch',
+      'canvas', 'chameleon', 'felt', 'flutterflow', 'framer-ai',
+      'jumpstart', 'mailparser', 'make', 'michele-sampieri', 'n8n-a',
+      'n8n-ai', 'nocodey', 'outseta', 'lemon-squeezy', 'retool',
+      'rise-no-code', 'scene', 'scrapingbee', 'softr', 'superblocks',
+      'superwall', 'tails', 'supabase', 'varun-anand', 'xano',
+      'directus', 'framer-design',
+    ]
+    const noteEntries = noteRefs.map((slug, i) => makeEntry({
+      path: `/Laputa/${slug}.md`, filename: `${slug}.md`, title: `Title ${slug}`,
+      modifiedAt: 1700000000 - i * 100,
+    }))
+    const engineering = makeEntry({
+      path: '/Laputa/engineering.md', filename: 'engineering.md', title: 'Engineering',
+      modifiedAt: 1700000000,
+    })
+    const entity = makeEntry({
+      path: '/Laputa/no-code.md', filename: 'no-code.md', title: 'No Code',
+      isA: 'Topic',
+      relationships: {
+        'Belongs to': ['[[engineering|Engineering]]'],
+        Notes: noteRefs.map((slug) => `[[${slug}|Title ${slug}]]`),
+        'Referred by Data': ['[[michele-sampieri|Michele Sampieri]]', '[[varun-anand|Varun Anand]]'],
+      },
+    })
+    const allEntries = [entity, engineering, ...noteEntries]
+    const groups = buildRelationshipGroups(entity, allEntries)
+
+    const belongsGroup = groups.find((g) => g.label === 'Belongs to')
+    expect(belongsGroup).toBeDefined()
+    expect(belongsGroup!.entries).toHaveLength(1)
+
+    const notesGroup = groups.find((g) => g.label === 'Notes')
+    expect(notesGroup).toBeDefined()
+    expect(notesGroup!.entries).toHaveLength(32)
+
+    // michele-sampieri and varun-anand already consumed by Notes → Referred by Data has 0 new
+    const referredGroup = groups.find((g) => g.label === 'Referred by Data')
+    expect(referredGroup).toBeUndefined()
+  })
+
+  it('resolves refs by title when filename differs from wikilink target', () => {
+    // Wikilink [[Airdev]] but filename is airdev-tool.md, title is "Airdev"
+    const airdev = makeEntry({
+      path: '/vault/airdev-tool.md', filename: 'airdev-tool.md', title: 'Airdev',
+    })
+    const budibase = makeEntry({
+      path: '/vault/budibase-app.md', filename: 'budibase-app.md', title: 'Budibase',
+      aliases: ['Budi'],
+    })
+    const entity = makeEntry({
+      path: '/vault/no-code.md', filename: 'no-code.md', title: 'No Code',
+      relationships: { Notes: ['[[Airdev]]', '[[Budi]]'] },
+    })
+    const groups = buildRelationshipGroups(entity, [entity, airdev, budibase])
+    const notesGroup = groups.find((g) => g.label === 'Notes')
+    expect(notesGroup).toBeDefined()
+    expect(notesGroup!.entries).toHaveLength(2)
+    expect(notesGroup!.entries.map(e => e.title).sort()).toEqual(['Airdev', 'Budibase'])
+  })
+
+  it('resolves Children via title match when belongsTo target differs from filename', () => {
+    // Child's belongsTo uses [[No Code]] but entity filename is no-code-topic.md
+    const child = makeEntry({
+      path: '/vault/tool.md', filename: 'tool.md', title: 'Tool',
+      belongsTo: ['[[No Code]]'], modifiedAt: 1700000000,
+    })
+    const entity = makeEntry({
+      path: '/vault/no-code-topic.md', filename: 'no-code-topic.md', title: 'No Code',
+      relationships: {},
+    })
+    const groups = buildRelationshipGroups(entity, [entity, child])
+    expect(groups.find((g) => g.label === 'Children')!.entries).toHaveLength(1)
+  })
 })
 
 describe('getSortComparator — custom properties', () => {
@@ -485,3 +563,135 @@ describe('parseSortConfig', () => {
     }
   })
 })
+
+// --- Inbox ---
+
+describe('buildValidLinkTargets', () => {
+  it('builds a set of titles, filename stems, and path stems', () => {
+    const entries = [
+      makeEntry({ path: '/vault/project/my-project.md', filename: 'my-project.md', title: 'My Project', aliases: ['MP'] }),
+      makeEntry({ path: '/vault/note/test.md', filename: 'test.md', title: 'Test Note' }),
+    ]
+    const targets = buildValidLinkTargets(entries)
+    expect(targets.has('My Project')).toBe(true)
+    expect(targets.has('Test Note')).toBe(true)
+    expect(targets.has('my-project')).toBe(true)
+    expect(targets.has('test')).toBe(true)
+    expect(targets.has('MP')).toBe(true)
+    // path stems (last 2 segments without .md)
+    expect(targets.has('project/my-project')).toBe(true)
+    expect(targets.has('note/test')).toBe(true)
+  })
+})
+
+describe('isInboxEntry', () => {
+  const allEntries = [
+    makeEntry({ path: '/vault/topic/ai.md', filename: 'ai.md', title: 'AI', aliases: [] }),
+    makeEntry({ path: '/vault/project/laputa.md', filename: 'laputa.md', title: 'Laputa' }),
+  ]
+  const validTargets = buildValidLinkTargets(allEntries)
+
+  it('returns true for a note with no outgoing links and no relationships', () => {
+    const note = makeEntry({ outgoingLinks: [], relationships: {}, belongsTo: [], relatedTo: [] })
+    expect(isInboxEntry(note, validTargets)).toBe(true)
+  })
+
+  it('returns false for a trashed note', () => {
+    const note = makeEntry({ trashed: true, outgoingLinks: [], relationships: {} })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns false for an archived note', () => {
+    const note = makeEntry({ archived: true, outgoingLinks: [], relationships: {} })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns false for a note with valid outgoing links', () => {
+    const note = makeEntry({ outgoingLinks: ['AI'] })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns true for a note with only broken outgoing links (non-existent targets)', () => {
+    const note = makeEntry({ outgoingLinks: ['NonExistent Page', 'Another Missing'] })
+    expect(isInboxEntry(note, validTargets)).toBe(true)
+  })
+
+  it('returns false for a note with valid frontmatter relationships', () => {
+    const note = makeEntry({ outgoingLinks: [], relationships: { 'Related to': ['[[AI]]'] } })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns false for a note with belongsTo pointing to real note', () => {
+    const note = makeEntry({ outgoingLinks: [], belongsTo: ['[[Laputa]]'] })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns false for a note with relatedTo pointing to real note', () => {
+    const note = makeEntry({ outgoingLinks: [], relatedTo: ['[[AI]]'] })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+
+  it('returns true for a note with only broken relationship refs', () => {
+    const note = makeEntry({ outgoingLinks: [], relationships: { 'Relates': ['[[Ghost]]'] }, belongsTo: ['[[Missing]]'] })
+    expect(isInboxEntry(note, validTargets)).toBe(true)
+  })
+
+  it('excludes Type entries from inbox', () => {
+    const note = makeEntry({ isA: 'Type', outgoingLinks: [], relationships: {} })
+    expect(isInboxEntry(note, validTargets)).toBe(false)
+  })
+})
+
+describe('filterInboxEntries', () => {
+  const now = Math.floor(Date.now() / 1000)
+  const DAY = 86400
+
+  const allEntries = [
+    makeEntry({ path: '/vault/a.md', filename: 'a.md', title: 'A', createdAt: now - 2 * DAY, outgoingLinks: [] }),
+    makeEntry({ path: '/vault/b.md', filename: 'b.md', title: 'B', createdAt: now - 15 * DAY, outgoingLinks: [] }),
+    makeEntry({ path: '/vault/c.md', filename: 'c.md', title: 'C', createdAt: now - 60 * DAY, outgoingLinks: [] }),
+    makeEntry({ path: '/vault/d.md', filename: 'd.md', title: 'D', createdAt: now - 120 * DAY, outgoingLinks: [] }),
+    makeEntry({ path: '/vault/linked.md', filename: 'linked.md', title: 'Linked', createdAt: now - 1 * DAY, outgoingLinks: ['A'] }),
+  ]
+
+  it('filters by "week" period (last 7 days)', () => {
+    const result = filterInboxEntries(allEntries, 'week')
+    expect(result.map(e => e.title)).toEqual(['A'])
+  })
+
+  it('filters by "month" period (last 30 days)', () => {
+    const result = filterInboxEntries(allEntries, 'month')
+    expect(result.map(e => e.title)).toEqual(['A', 'B'])
+  })
+
+  it('filters by "quarter" period (last 90 days)', () => {
+    const result = filterInboxEntries(allEntries, 'quarter')
+    expect(result.map(e => e.title)).toEqual(['A', 'B', 'C'])
+  })
+
+  it('filters by "all" period', () => {
+    const result = filterInboxEntries(allEntries, 'all')
+    expect(result.map(e => e.title)).toEqual(['A', 'B', 'C', 'D'])
+  })
+
+  it('sorts by createdAt descending', () => {
+    const result = filterInboxEntries(allEntries, 'all')
+    for (let i = 1; i < result.length; i++) {
+      expect((result[i - 1].createdAt ?? 0)).toBeGreaterThanOrEqual((result[i].createdAt ?? 0))
+    }
+  })
+
+  it('excludes linked notes', () => {
+    const result = filterInboxEntries(allEntries, 'all')
+    expect(result.find(e => e.title === 'Linked')).toBeUndefined()
+  })
+
+  it('returns empty array when all notes have valid outgoing links', () => {
+    const linked = [
+      makeEntry({ path: '/vault/x.md', title: 'X', outgoingLinks: ['Y'] }),
+      makeEntry({ path: '/vault/y.md', title: 'Y', outgoingLinks: ['X'] }),
+    ]
+    const result = filterInboxEntries(linked, 'all')
+    expect(result).toEqual([])
+  })
+})

src/utils/noteListHelpers.ts

@@ -1,4 +1,5 @@
-import type { VaultEntry, SidebarSelection } from '../types'
+import type { VaultEntry, SidebarSelection, InboxPeriod } from '../types'
+import { wikilinkTarget, resolveEntry } from './wikilink'
 
 export type NoteListFilter = 'open' | 'archived' | 'trashed'
 
@@ -61,25 +62,12 @@ export function formatSearchSubtitle(entry: VaultEntry): string {
 }
 
 function refsMatch(refs: string[], entry: VaultEntry): boolean {
-  const stem = entry.path.replace(/^.*\/Laputa\//, '').replace(/\.md$/, '')
-  const fileStem = entry.filename.replace(/\.md$/, '')
-  return refs.some((ref) => {
-    const inner = ref.replace(/^\[\[/, '').replace(/\]\]$/, '').split('|')[0]
-    return inner === stem || inner.split('/').pop() === fileStem
-  })
+  return refs.some((ref) => resolveEntry([entry], wikilinkTarget(ref)) !== undefined)
 }
 
 function resolveRefs(refs: string[], entries: VaultEntry[]): VaultEntry[] {
   return refs
-    .map((ref) => {
-      const inner = ref.replace(/^\[\[/, '').replace(/\]\]$/, '').split('|')[0]
-      return entries.find((e) => {
-        const stem = e.path.replace(/^.*\/Laputa\//, '').replace(/\.md$/, '')
-        if (stem === inner) return true
-        const fileStem = e.filename.replace(/\.md$/, '')
-        return fileStem === inner.split('/').pop()
-      })
-    })
+    .map((ref) => resolveEntry(entries, wikilinkTarget(ref)))
     .filter((e): e is VaultEntry => e !== undefined)
 }
 
@@ -327,9 +315,7 @@ function filterByKind(entries: VaultEntry[], selection: SidebarSelection, subFil
     const typeEntries = entries.filter((e) => e.isA === selection.type)
     return subFilter ? applySubFilter(typeEntries, subFilter) : typeEntries.filter(isActive)
   }
-  if (selection.kind === 'topic') {
-    return entries.filter((e) => refsMatch(e.relatedTo, selection.entry) && isActive(e))
-  }
+  if (selection.filter === 'all' && subFilter) return applySubFilter(entries, subFilter)
   return filterByFilterType(entries, selection.filter)
 }
 
@@ -356,3 +342,99 @@ export function countByFilter(entries: VaultEntry[], type: string): Record<NoteL
   }
   return { open, archived, trashed }
 }
+
+/** Count notes per sub-filter across all entries (no type filter). */
+export function countAllByFilter(entries: VaultEntry[]): Record<NoteListFilter, number> {
+  let open = 0, archived = 0, trashed = 0
+  for (const e of entries) {
+    if (e.trashed) trashed++
+    else if (e.archived) archived++
+    else open++
+  }
+  return { open, archived, trashed }
+}
+
+// --- Inbox ---
+
+/** Build a set of all valid link targets (titles, aliases, filename stems, path stems). */
+export function buildValidLinkTargets(entries: VaultEntry[]): Set<string> {
+  const targets = new Set<string>()
+  for (const e of entries) {
+    targets.add(e.title)
+    const fileStem = e.filename.replace(/\.md$/, '')
+    targets.add(fileStem)
+    // path stem: everything after vault root, minus .md
+    // E.g. /Users/luca/Laputa/project/foo.md → project/foo
+    const parts = e.path.replace(/\.md$/, '').split('/')
+    // Try from index that gives "folder/name" pattern — skip first segments
+    if (parts.length >= 2) {
+      const last2 = parts.slice(-2).join('/')
+      if (last2 !== fileStem) targets.add(last2)
+    }
+    for (const alias of e.aliases) targets.add(alias)
+  }
+  return targets
+}
+
+function extractRef(raw: string): string {
+  return raw.replace(/^\[\[/, '').replace(/\]\]$/, '').split('|')[0]
+}
+
+function hasValidRef(refs: string[], validTargets: Set<string>): boolean {
+  return refs.some((raw) => {
+    const inner = extractRef(raw)
+    return validTargets.has(inner) || validTargets.has(inner.split('/').pop() ?? '')
+  })
+}
+
+/** Check if entry has any valid outgoing link (body or frontmatter) that resolves to a real note. */
+export function isInboxEntry(entry: VaultEntry, validTargets: Set<string>): boolean {
+  if (entry.trashed || entry.archived) return false
+  if (entry.isA === 'Type') return false
+
+  // Check body outgoing links
+  if (entry.outgoingLinks.some((link) => validTargets.has(link) || validTargets.has(link.split('/').pop() ?? ''))) return false
+
+  // Check frontmatter relationship refs
+  if (entry.belongsTo?.length && hasValidRef(entry.belongsTo, validTargets)) return false
+  if (entry.relatedTo?.length && hasValidRef(entry.relatedTo, validTargets)) return false
+  if (entry.relationships) {
+    for (const refs of Object.values(entry.relationships)) {
+      if (hasValidRef(refs, validTargets)) return false
+    }
+  }
+
+  return true
+}
+
+const INBOX_PERIOD_DAYS: Record<InboxPeriod, number> = {
+  week: 7, month: 30, quarter: 90, all: Infinity,
+}
+
+/** Filter entries for the Inbox view: no valid relationships, within the given time period, sorted by createdAt desc. */
+export function filterInboxEntries(entries: VaultEntry[], period: InboxPeriod): VaultEntry[] {
+  const validTargets = buildValidLinkTargets(entries)
+  const now = Math.floor(Date.now() / 1000)
+  const cutoff = period === 'all' ? 0 : now - INBOX_PERIOD_DAYS[period] * 86400
+
+  return entries
+    .filter((e) => isInboxEntry(e, validTargets) && (e.createdAt ?? 0) >= cutoff)
+    .sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0))
+}
+
+/** Count inbox entries per period. */
+export function countInboxByPeriod(entries: VaultEntry[]): Record<InboxPeriod, number> {
+  const validTargets = buildValidLinkTargets(entries)
+  const inbox = entries.filter((e) => isInboxEntry(e, validTargets))
+  const now = Math.floor(Date.now() / 1000)
+
+  let week = 0, month = 0, quarter = 0
+  for (const e of inbox) {
+    const age = now - (e.createdAt ?? 0)
+    if (age <= 7 * 86400) week++
+    if (age <= 30 * 86400) month++
+    if (age <= 90 * 86400) quarter++
+  }
+
+  return { week, month, quarter, all: inbox.length }
+}

src/utils/openNoteWindow.ts

@@ -0,0 +1,23 @@
+import { isTauri } from '../mock-tauri'
+
+/**
+ * Opens a note in a new Tauri window with a minimal editor-only layout.
+ * In browser mode (non-Tauri), this is a no-op.
+ */
+export async function openNoteInNewWindow(notePath: string, vaultPath: string, noteTitle: string): Promise<void> {
+  if (!isTauri()) return
+
+  const { WebviewWindow } = await import('@tauri-apps/api/webviewWindow')
+  const label = `note-${Date.now()}`
+  const url = `index.html?window=note&path=${encodeURIComponent(notePath)}&vault=${encodeURIComponent(vaultPath)}&title=${encodeURIComponent(noteTitle)}`
+
+  new WebviewWindow(label, {
+    url,
+    title: noteTitle,
+    width: 800,
+    height: 700,
+    resizable: true,
+    titleBarStyle: 'overlay',
+    hiddenTitle: true,
+  })
+}

src/utils/sidebarSections.ts

@@ -26,11 +26,11 @@ const BUILT_IN_SECTION_GROUPS: SectionGroup[] = [
 /** Metadata lookup for well-known types (icon/label only — NOT used to determine which sections to show) */
 const BUILT_IN_TYPE_MAP = new Map(BUILT_IN_SECTION_GROUPS.map((sg) => [sg.type, sg]))
 
-/** Collect unique isA values from active (non-trashed, non-archived) entries, excluding generic Note */
+/** Collect unique isA values from active (non-trashed, non-archived) entries. Untyped entries count as 'Note'. */
 export function collectActiveTypes(entries: VaultEntry[]): Set<string> {
   const types = new Set<string>()
   for (const e of entries) {
-    if (e.isA && e.isA !== 'Note' && !e.trashed && !e.archived) types.add(e.isA)
+    if (!e.trashed && !e.archived) types.add(e.isA || 'Note')
   }
   return types
 }

src/utils/windowMode.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { isNoteWindow, getNoteWindowParams } from './windowMode'
+
+describe('windowMode', () => {
+  let originalSearch: string
+
+  beforeEach(() => {
+    originalSearch = window.location.search
+  })
+
+  afterEach(() => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { ...window.location, search: originalSearch },
+    })
+  })
+
+  function setSearch(search: string) {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { ...window.location, search },
+    })
+  }
+
+  describe('isNoteWindow', () => {
+    it('returns false when no query params', () => {
+      setSearch('')
+      expect(isNoteWindow()).toBe(false)
+    })
+
+    it('returns true when window=note', () => {
+      setSearch('?window=note&path=/test.md&vault=/vault')
+      expect(isNoteWindow()).toBe(true)
+    })
+
+    it('returns false for other window values', () => {
+      setSearch('?window=main')
+      expect(isNoteWindow()).toBe(false)
+    })
+  })
+
+  describe('getNoteWindowParams', () => {
+    it('returns null when not a note window', () => {
+      setSearch('')
+      expect(getNoteWindowParams()).toBeNull()
+    })
+
+    it('returns null when path is missing', () => {
+      setSearch('?window=note&vault=/vault')
+      expect(getNoteWindowParams()).toBeNull()
+    })
+
+    it('returns null when vault is missing', () => {
+      setSearch('?window=note&path=/test.md')
+      expect(getNoteWindowParams()).toBeNull()
+    })
+
+    it('returns params when all are present', () => {
+      setSearch('?window=note&path=%2Fvault%2Ftest.md&vault=%2Fvault&title=My%20Note')
+      expect(getNoteWindowParams()).toEqual({
+        notePath: '/vault/test.md',
+        vaultPath: '/vault',
+        noteTitle: 'My Note',
+      })
+    })
+
+    it('defaults title to Untitled', () => {
+      setSearch('?window=note&path=/test.md&vault=/vault')
+      const params = getNoteWindowParams()
+      expect(params?.noteTitle).toBe('Untitled')
+    })
+  })
+})

src/utils/windowMode.ts

@@ -0,0 +1,24 @@
+/**
+ * Detects whether the current window is a secondary "note window" (opened via
+ * "Open in New Window") by inspecting URL query parameters.
+ */
+
+export interface NoteWindowParams {
+  notePath: string
+  vaultPath: string
+  noteTitle: string
+}
+
+export function isNoteWindow(): boolean {
+  return new URLSearchParams(window.location.search).get('window') === 'note'
+}
+
+export function getNoteWindowParams(): NoteWindowParams | null {
+  const params = new URLSearchParams(window.location.search)
+  if (params.get('window') !== 'note') return null
+  const notePath = params.get('path')
+  const vaultPath = params.get('vault')
+  const noteTitle = params.get('title') ?? 'Untitled'
+  if (!notePath || !vaultPath) return null
+  return { notePath, vaultPath, noteTitle }
+}

tests/smoke/emoji-icon-everywhere.spec.ts

@@ -0,0 +1,65 @@
+import { test, expect } from '@playwright/test'
+
+test.describe('Emoji icon shown everywhere title appears', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+    await page.waitForTimeout(2500)
+  })
+
+  test('emoji icon appears in tab bar, breadcrumb, and note list after setting it', async ({ page }) => {
+    // Open a note
+    const noteItem = page.locator('[data-testid="note-list-container"] .cursor-pointer').first()
+    await noteItem.waitFor({ timeout: 5000 })
+    await noteItem.click()
+    await page.waitForTimeout(500)
+
+    // Remove any existing icon first for a clean state
+    const iconDisplay = page.locator('[data-testid="note-icon-display"]')
+    if (await iconDisplay.isVisible()) {
+      await iconDisplay.click()
+      await page.locator('[data-testid="note-icon-remove"]').click()
+      await page.waitForTimeout(300)
+    }
+
+    // Set an emoji icon
+    const iconArea = page.locator('[data-testid="note-icon-area"]')
+    await iconArea.hover()
+    await page.locator('[data-testid="note-icon-add"]').click()
+    const firstEmoji = page.locator('[data-testid="emoji-option"]').first()
+    const emojiText = await firstEmoji.textContent()
+    expect(emojiText).toBeTruthy()
+    await firstEmoji.click()
+    await page.waitForTimeout(500)
+
+    // Verify emoji in note list item
+    const noteListText = await noteItem.textContent()
+    expect(noteListText).toContain(emojiText!)
+
+    // Verify emoji in the tab (active tab has the truncate span with title)
+    const tabArea = page.locator('.group .truncate').first()
+    const tabText = await tabArea.textContent()
+    expect(tabText).toContain(emojiText!)
+  })
+
+  test('note without emoji shows no emoji span in tab or note list', async ({ page }) => {
+    // Open a note
+    const noteItem = page.locator('[data-testid="note-list-container"] .cursor-pointer').first()
+    await noteItem.waitFor({ timeout: 5000 })
+    await noteItem.click()
+    await page.waitForTimeout(500)
+
+    // Remove icon if present
+    const iconDisplay = page.locator('[data-testid="note-icon-display"]')
+    if (await iconDisplay.isVisible()) {
+      await iconDisplay.click()
+      await page.locator('[data-testid="note-icon-remove"]').click()
+      await page.waitForTimeout(300)
+    }
+
+    // The note list item title row should not contain an emoji span (mr-1)
+    const titleRow = noteItem.locator('.truncate.text-foreground').first()
+    const emojiSpans = titleRow.locator('.mr-1')
+    await expect(emojiSpans).toHaveCount(0)
+  })
+})

tests/smoke/fix-note-filename-on-rename.spec.ts

@@ -9,43 +9,40 @@ function isKnownEditorError(msg: string): boolean {
 }
 
 /**
- * Helper: create a new note, select the existing H1 heading text,
- * replace it with a new title, then wait for the 500 ms title-sync debounce.
+ * Helper: create a new note and rename it via TitleField.
  */
 async function createNoteWithTitle(page: import('@playwright/test').Page, title: string) {
-  // 1. Cmd+N → new "Untitled note" (creates heading with "Untitled note")
+  // 1. Cmd+N → new "Untitled note"
   await page.locator('body').click()
   await sendShortcut(page, 'n', ['Control'])
   await expect(page.getByText(/Untitled note/).first()).toBeVisible({ timeout: 3000 })
 
-  // 2. Wait for the heading to render in BlockNote
-  const heading = page.locator('[data-content-type="heading"] h1')
-  await heading.waitFor({ timeout: 3000 })
+  // 2. Edit the title via TitleField
+  const titleInput = page.getByTestId('title-field-input')
+  await titleInput.waitFor({ timeout: 3000 })
+  await titleInput.click()
+  await titleInput.fill(title)
+  await titleInput.press('Enter')
 
-  // 3. Triple-click the heading to select all its text, then type replacement
-  await heading.click({ clickCount: 3 })
-  await page.keyboard.type(title, { delay: 20 })
-
-  // 4. Wait for the 500 ms useHeadingTitleSync debounce to fire + React re-render
-  await page.waitForTimeout(800)
+  // 3. Wait for async rename to complete
+  await page.waitForTimeout(1000)
 }
 
 test.describe('Note filename updates on title change + save', () => {
   test.beforeEach(async ({ page }) => {
     await page.goto('/')
     await page.waitForLoadState('networkidle')
-    // Wait for startup toast ("Laputa registered as MCP tool") to dismiss
+    // Wait for startup toast to dismiss
     await page.waitForTimeout(2500)
   })
 
-  test('Cmd+N creates untitled note, typing new title triggers rename via title sync', async ({ page }) => {
+  test('Cmd+N creates untitled note, editing TitleField triggers rename', async ({ page }) => {
     const errors: string[] = []
     page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
 
     await createNoteWithTitle(page, 'Test Note ABC')
 
-    // Title sync now triggers a full rename (save + rename + wikilink update).
-    // The toast should show "Renamed" after the debounce fires.
+    // The toast should show "Renamed" after the TitleField commit
     const toast = page.locator('.fixed.bottom-8')
     await expect(toast).toContainText('Renamed', { timeout: 5000 })
 
@@ -82,20 +79,19 @@ test.describe('Note filename updates on title change + save', () => {
     expect(toastText).not.toContain('Renamed')
   })
 
-  test('rapid title changes only rename to final title', async ({ page }) => {
+  test('rapid TitleField edits only rename to final title', async ({ page }) => {
     const errors: string[] = []
     page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
 
     await createNoteWithTitle(page, 'First Title')
 
-    // Select heading text again and replace with final title
-    const heading = page.locator('[data-content-type="heading"] h1')
-    await heading.click({ clickCount: 3 })
-    await page.keyboard.type('Final Title', { delay: 20 })
-
-    // Wait for debounce to fire — title sync triggers rename automatically
-    await page.waitForTimeout(800)
+    // Edit TitleField again with final title
+    const titleInput = page.getByTestId('title-field-input')
+    await titleInput.click()
+    await titleInput.fill('Final Title')
+    await titleInput.press('Enter')
 
+    // Wait for rename
     const toast = page.locator('.fixed.bottom-8')
     await expect(toast).toContainText('Renamed', { timeout: 5000 })
 

tests/smoke/focus-no-freeze.spec.ts

@@ -0,0 +1,50 @@
+import { test, expect } from '@playwright/test'
+
+test.describe('Focus event does not freeze the UI', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('window focus event completes without blocking UI for >500ms', async ({ page }) => {
+    // Verify the app loaded
+    await expect(page.locator('[data-testid="sidebar"]').or(page.locator('nav')).first()).toBeVisible()
+
+    // Measure how long the UI is blocked after a focus event.
+    // We dispatch focus, then immediately schedule a rAF callback.
+    // If the main thread is blocked (sync IPC), the rAF callback is delayed.
+    const blockMs = await page.evaluate(() => {
+      return new Promise<number>((resolve) => {
+        const t0 = performance.now()
+        window.dispatchEvent(new Event('focus'))
+        requestAnimationFrame(() => {
+          resolve(performance.now() - t0)
+        })
+      })
+    })
+
+    // The focus handler must not block the main thread for more than 500ms.
+    // Before the fix, git_pull ran synchronously and blocked for 2-3 seconds.
+    expect(blockMs).toBeLessThan(500)
+  })
+
+  test('rapid focus events (5x) do not accumulate freezes', async ({ page }) => {
+    await expect(page.locator('[data-testid="sidebar"]').or(page.locator('nav')).first()).toBeVisible()
+
+    const totalMs = await page.evaluate(() => {
+      return new Promise<number>((resolve) => {
+        const t0 = performance.now()
+        for (let i = 0; i < 5; i++) {
+          window.dispatchEvent(new Event('focus'))
+        }
+        requestAnimationFrame(() => {
+          resolve(performance.now() - t0)
+        })
+      })
+    })
+
+    // 5 rapid focus events should still complete in under 500ms total
+    // thanks to the cooldown preventing redundant work.
+    expect(totalMs).toBeLessThan(500)
+  })
+})

tests/smoke/git-divergence-conflicts.spec.ts

@@ -0,0 +1,90 @@
+import { test, expect } from '@playwright/test'
+import { openCommandPalette, executeCommand } from './helpers'
+
+test.describe('Git divergence, conflicts, and manual pull', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('push rejection sets pull_required status in bottom bar', async ({ page }) => {
+    // Override git_push mock to return rejected
+    await page.evaluate(() => {
+      window.__mockHandlers!.git_push = () => ({
+        status: 'rejected',
+        message: 'Push rejected: remote has new commits. Pull first, then push.',
+      })
+    })
+
+    // Commit to trigger push
+    await openCommandPalette(page)
+    await executeCommand(page, 'Commit & Push')
+
+    const textarea = page.locator('textarea[placeholder="Commit message..."]')
+    await textarea.waitFor({ timeout: 5000 })
+    await textarea.fill('test commit')
+    await page.getByRole('button', { name: 'Commit & Push' }).click()
+
+    // Verify toast shows rejection message
+    const toast = page.locator('.fixed.bottom-8')
+    await expect(toast).toContainText('push rejected', { timeout: 5000 })
+
+    // Verify "Pull required" label appears in the status bar
+    const syncBadge = page.getByTestId('status-sync')
+    await expect(syncBadge).toContainText('Pull required', { timeout: 5000 })
+  })
+
+  test('Pull from Remote command exists in command palette', async ({ page }) => {
+    await openCommandPalette(page)
+
+    const input = page.locator('input[placeholder="Type a command..."]')
+    await input.fill('Pull')
+
+    // Verify the Pull from Remote command appears as the selected item
+    const match = page.locator('[data-selected="true"]').first()
+    await expect(match).toContainText('Pull from Remote', { timeout: 3000 })
+  })
+
+  test('git status popup shows branch and sync info when clicking sync badge', async ({ page }) => {
+    // Override git_remote_status to return data with ahead/behind
+    await page.evaluate(() => {
+      window.__mockHandlers!.git_remote_status = () => ({
+        branch: 'main',
+        ahead: 3,
+        behind: 1,
+        hasRemote: true,
+      })
+    })
+
+    // Trigger a sync so the remote status gets fetched
+    const syncBadge = page.getByTestId('status-sync')
+    await syncBadge.click()
+
+    // The popup should appear
+    const popup = page.getByTestId('git-status-popup')
+    await expect(popup).toBeVisible({ timeout: 3000 })
+    await expect(popup).toContainText('main')
+  })
+
+  test('conflict badge shows count when conflicts exist', async ({ page }) => {
+    // Override git_pull to return conflicts
+    await page.evaluate(() => {
+      window.__mockHandlers!.git_pull = () => ({
+        status: 'conflict',
+        message: 'Merge conflict in 2 file(s)',
+        updatedFiles: [],
+        conflictFiles: ['note-a.md', 'note-b.md'],
+      })
+      window.__mockHandlers!.get_conflict_files = () => ['note-a.md', 'note-b.md']
+    })
+
+    // Trigger a sync
+    await openCommandPalette(page)
+    await executeCommand(page, 'Pull from Remote')
+
+    // Verify conflict count badge appears
+    const conflictBadge = page.getByTestId('status-conflict-count')
+    await expect(conflictBadge).toBeVisible({ timeout: 5000 })
+    await expect(conflictBadge).toContainText('2 conflicts')
+  })
+})

tests/smoke/h1-title-decoupled.spec.ts

@@ -0,0 +1,85 @@
+import { test, expect } from '@playwright/test'
+import { sendShortcut } from './helpers'
+
+/** Known BlockNote/ProseMirror error that fires during editor re-mount after rename. */
+const KNOWN_EDITOR_ERRORS = ['isConnected']
+
+function isKnownEditorError(msg: string): boolean {
+  return KNOWN_EDITOR_ERRORS.some(k => msg.includes(k))
+}
+
+test.describe('H1 decoupled from title + non-blocking rename', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+    await page.waitForTimeout(2500)
+  })
+
+  test('editing H1 in editor does NOT update TitleField', async ({ page }) => {
+    const errors: string[] = []
+    page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
+
+    // Create a new note
+    await page.locator('body').click()
+    await sendShortcut(page, 'n', ['Control'])
+    await expect(page.getByText(/Untitled note/).first()).toBeVisible({ timeout: 3000 })
+
+    // Note the initial TitleField value
+    const titleInput = page.getByTestId('title-field-input')
+    await titleInput.waitFor({ timeout: 3000 })
+    const initialTitle = await titleInput.inputValue()
+
+    // Type an H1 in the editor body
+    const heading = page.locator('[data-content-type="heading"] h1')
+    if (await heading.isVisible()) {
+      await heading.click({ clickCount: 3 })
+    } else {
+      // Click into the editor and type an H1
+      const editor = page.locator('.bn-editor')
+      await editor.click()
+    }
+    await page.keyboard.type('My Custom H1 Heading', { delay: 15 })
+
+    // Wait well past the old debounce time (500ms)
+    await page.waitForTimeout(1500)
+
+    // TitleField should NOT have changed from its initial value
+    const titleAfterH1 = await titleInput.inputValue()
+    expect(titleAfterH1).toBe(initialTitle)
+
+    expect(errors).toEqual([])
+  })
+
+  test('TitleField rename is non-blocking (no freeze)', async ({ page }) => {
+    const errors: string[] = []
+    page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
+
+    // Create a new note
+    await page.locator('body').click()
+    await sendShortcut(page, 'n', ['Control'])
+    await expect(page.getByText(/Untitled note/).first()).toBeVisible({ timeout: 3000 })
+
+    // Focus the TitleField and type a new title
+    const titleInput = page.getByTestId('title-field-input')
+    await titleInput.waitFor({ timeout: 3000 })
+    await titleInput.click()
+    await titleInput.fill('Responsive Rename Test')
+
+    // Measure time for blur (commit) — should be near-instant
+    const start = Date.now()
+    await titleInput.press('Enter')
+    const elapsed = Date.now() - start
+
+    // The blur/commit should complete in under 500ms (no blocking rename)
+    expect(elapsed).toBeLessThan(500)
+
+    // TitleField should show the new title optimistically
+    await expect(titleInput).toHaveValue('Responsive Rename Test', { timeout: 1000 })
+
+    // Wait for rename to complete in background
+    const toast = page.locator('.fixed.bottom-8')
+    await expect(toast).toContainText('Renamed', { timeout: 5000 })
+
+    expect(errors).toEqual([])
+  })
+})

tests/smoke/note-list-incomplete-relationships.spec.ts

@@ -0,0 +1,103 @@
+import { test, expect } from '@playwright/test'
+import { sendShortcut } from './helpers'
+
+test.describe('Note list shows complete relationships when opening from sidebar', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.setViewportSize({ width: 1600, height: 900 })
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('entity view shows relationship groups with correct counts after sidebar click', async ({ page }) => {
+    // Navigate to Responsibilities type to find entity notes in the sidebar
+    // First, click on a sidebar type that contains entity notes
+    // We'll use the sidebar search to filter to "Sponsorships"
+    const searchToggle = page.locator('[data-testid="search-toggle"]')
+    if (await searchToggle.isVisible()) {
+      await searchToggle.click()
+    }
+
+    // Type in sidebar search to find Sponsorships
+    const sidebarSearch = page.locator('[data-testid="note-list-search"]')
+    if (await sidebarSearch.isVisible()) {
+      await sidebarSearch.fill('Sponsorships')
+      await page.waitForTimeout(500)
+    }
+
+    // Click the Sponsorships note in the note list to trigger entity view
+    const sponsorshipsItem = page.locator('[data-entry-path*="sponsorships"]').first()
+    if (await sponsorshipsItem.isVisible({ timeout: 3000 }).catch(() => false)) {
+      await sponsorshipsItem.click()
+      await page.waitForTimeout(1000)
+    } else {
+      // Fallback: open via quick open — then click in sidebar
+      await page.locator('body').click()
+      await sendShortcut(page, 'p', ['Control'])
+      const searchInput = page.locator('input[placeholder="Search notes..."]')
+      await expect(searchInput).toBeVisible()
+      await searchInput.fill('Sponsorships')
+      await page.waitForTimeout(500)
+      await page.keyboard.press('Enter')
+      await page.waitForTimeout(1000)
+    }
+
+    // The inspector panel (right side) should show relationship labels with font-mono-overline
+    // This verifies the note loaded and relationships were parsed correctly
+    const measuresLabel = page.locator('span.font-mono-overline').filter({ hasText: 'Has Measures' })
+    await expect(measuresLabel).toBeVisible({ timeout: 5000 })
+
+    const proceduresLabel = page.locator('span.font-mono-overline').filter({ hasText: 'Has Procedures' })
+    await expect(proceduresLabel).toBeVisible({ timeout: 5000 })
+
+    // Verify the relationships panel shows the correct number of items
+    // Has Measures should have 2 entries (measure-sponsorship-mrr, measure-close-rate)
+    const measuresSection = measuresLabel.locator('xpath=ancestor::div[1]')
+    const measureItems = measuresSection.locator('a, button').filter({ hasText: /measure|Measure/ })
+    // At least 1 resolved relationship entry
+    const hasItems = await measureItems.count()
+    expect(hasItems).toBeGreaterThanOrEqual(1)
+  })
+
+  test('relationship labels persist after navigating away and back', async ({ page }) => {
+    // Open Sponsorships via quick open
+    await page.locator('body').click()
+    await sendShortcut(page, 'p', ['Control'])
+    const searchInput = page.locator('input[placeholder="Search notes..."]')
+    await expect(searchInput).toBeVisible()
+    await searchInput.fill('Sponsorships')
+    await page.waitForTimeout(500)
+    await page.keyboard.press('Enter')
+    await page.waitForTimeout(1000)
+
+    // Verify Has Measures relationship appears in inspector
+    const measuresLabel = page.locator('span.font-mono-overline').filter({ hasText: 'Has Measures' })
+    await expect(measuresLabel).toBeVisible({ timeout: 5000 })
+
+    // Navigate to different note
+    await page.locator('body').click()
+    await sendShortcut(page, 'p', ['Control'])
+    const searchInput2 = page.locator('input[placeholder="Search notes..."]')
+    await expect(searchInput2).toBeVisible()
+    await searchInput2.fill('Start Laputa App')
+    await page.waitForTimeout(500)
+    await page.keyboard.press('Enter')
+    await page.waitForTimeout(1000)
+
+    // Navigate back to Sponsorships
+    await page.locator('body').click()
+    await sendShortcut(page, 'p', ['Control'])
+    const searchInput3 = page.locator('input[placeholder="Search notes..."]')
+    await expect(searchInput3).toBeVisible()
+    await searchInput3.fill('Sponsorships')
+    await page.waitForTimeout(500)
+    await page.keyboard.press('Enter')
+    await page.waitForTimeout(1000)
+
+    // Relationships should still be visible — not stale or incomplete
+    const measuresLabelAgain = page.locator('span.font-mono-overline').filter({ hasText: 'Has Measures' })
+    await expect(measuresLabelAgain).toBeVisible({ timeout: 5000 })
+
+    const proceduresLabelAgain = page.locator('span.font-mono-overline').filter({ hasText: 'Has Procedures' })
+    await expect(proceduresLabelAgain).toBeVisible({ timeout: 5000 })
+  })
+})

tests/smoke/note-list-preview-snippet.spec.ts

@@ -6,34 +6,11 @@ test.describe('Note list preview snippet', () => {
     await page.waitForLoadState('networkidle')
   })
 
-  test('notes with content show a snippet in the note list', async ({ page }) => {
-    const noteListContainer = page.locator('[data-testid="note-list-container"]')
-    await expect(noteListContainer).toBeVisible()
-
-    // Wait for note items to render (cursor-pointer items inside the container)
-    const noteItems = noteListContainer.locator('.cursor-pointer')
-    await expect(noteItems.first()).toBeVisible({ timeout: 5000 })
-
-    // Each note item has a snippet div: 12px text with muted-foreground
-    // Check that at least one note has text content in its snippet area
-    const snippets = noteListContainer.locator('.text-muted-foreground')
-    const count = await snippets.count()
-    let foundSnippet = false
-    for (let i = 0; i < count; i++) {
-      const text = await snippets.nth(i).textContent()
-      if (text && text.length > 15 && !/^\d/.test(text.trim())) {
-        foundSnippet = true
-        break
-      }
-    }
-    expect(foundSnippet).toBe(true)
-  })
-
   test('snippet does not contain raw markdown formatting', async ({ page }) => {
     const noteListContainer = page.locator('[data-testid="note-list-container"]')
     await expect(noteListContainer).toBeVisible()
 
-    const snippets = noteListContainer.locator('.text-muted-foreground')
+    const snippets = noteListContainer.locator('[data-testid="note-snippet"]')
     const count = await snippets.count()
 
     for (let i = 0; i < Math.min(count, 8); i++) {
@@ -41,7 +18,6 @@ test.describe('Note list preview snippet', () => {
       if (text && text.length > 10) {
         expect(text).not.toMatch(/\*\*[^*]+\*\*/)
         expect(text).not.toContain('```')
-        expect(text).not.toMatch(/\[\[.*\]\]/)
       }
     }
   })
@@ -50,7 +26,7 @@ test.describe('Note list preview snippet', () => {
     const noteListContainer = page.locator('[data-testid="note-list-container"]')
     await expect(noteListContainer).toBeVisible()
 
-    const snippets = noteListContainer.locator('.text-muted-foreground')
+    const snippets = noteListContainer.locator('[data-testid="note-snippet"]')
     const count = await snippets.count()
 
     for (let i = 0; i < Math.min(count, 10); i++) {

tests/smoke/open-in-new-window.spec.ts

@@ -0,0 +1,41 @@
+import { test, expect } from '@playwright/test'
+import { openCommandPalette, findCommand } from './helpers'
+
+test.describe('Open in New Window', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('"Open in New Window" command appears in palette when note is active', async ({ page }) => {
+    // Open a note first (click first item in note list)
+    const firstNote = page.locator('.cursor-pointer.border-b').first()
+    await expect(firstNote).toBeVisible({ timeout: 3_000 })
+    await firstNote.click()
+
+    // Wait for editor to load
+    await expect(page.locator('.bn-editor')).toBeVisible({ timeout: 3_000 })
+
+    // Open command palette and search
+    await openCommandPalette(page)
+    const found = await findCommand(page, 'Open in New Window')
+    expect(found).toBe(true)
+  })
+
+  test('"Open in New Window" shows shortcut hint', async ({ page }) => {
+    // Open a note
+    const firstNote = page.locator('.cursor-pointer.border-b').first()
+    await expect(firstNote).toBeVisible({ timeout: 3_000 })
+    await firstNote.click()
+    await expect(page.locator('.bn-editor')).toBeVisible({ timeout: 3_000 })
+
+    // Open command palette and search for the command
+    await openCommandPalette(page)
+    const input = page.locator('input[placeholder="Type a command..."]')
+    await input.fill('Open in New Window')
+
+    // The shortcut hint should be visible
+    const commandRow = page.locator('text=Open in New Window').first()
+    await expect(commandRow).toBeVisible({ timeout: 2_000 })
+  })
+})

tests/smoke/theme-live-reload-fix.spec.ts

@@ -1,131 +0,0 @@
-import { test, expect, type Page } from '@playwright/test'
-import { openCommandPalette, executeCommand } from './helpers'
-
-async function getCssVar(page: Page, name: string): Promise<string> {
-  return page.evaluate(
-    (n) => document.documentElement.style.getPropertyValue(n),
-    name,
-  )
-}
-
-async function switchToDefaultTheme(page: Page) {
-  await openCommandPalette(page)
-  await executeCommand(page, 'Switch to Default Theme')
-  await expect(async () => {
-    expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
-  }).toPass({ timeout: 5000 })
-}
-
-async function openThemeNoteInRawMode(page: Page) {
-  await openCommandPalette(page)
-  await executeCommand(page, 'Edit Default Theme')
-  await page.waitForTimeout(500)
-
-  await openCommandPalette(page)
-  await executeCommand(page, 'Toggle Raw Editor')
-  await expect(page.locator('.cm-content')).toBeVisible({ timeout: 3000 })
-}
-
-/** Replace all text in the CodeMirror editor via its EditorView API. */
-async function setCmContent(page: Page, newContent: string) {
-  await page.evaluate((text) => {
-    const cmContent = document.querySelector('.cm-content') as HTMLElement | null
-    if (!cmContent) throw new Error('No .cm-content found')
-    // Access EditorView via CodeMirror's internal DOM reference
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const view = (cmContent as any).cmTile?.root?.view
-    if (!view) throw new Error('No EditorView found on .cm-content')
-    view.dispatch({
-      changes: { from: 0, to: view.state.doc.length, insert: text },
-    })
-  }, newContent)
-}
-
-test.describe('Theme live reload on save', () => {
-  // FIXME: these tests assume the default theme is light (#FFFFFF background)
-  // but the mock/test environment now starts with a dark theme (#1a1a2e).
-  // Skipping until the test fixture is updated.
-  test.skip()
-
-  test.beforeEach(async ({ page }) => {
-    // Block the vault API ping so the app falls back to mock content
-    // instead of reading real files from the filesystem.
-    await page.route('**/api/vault/ping', (route) =>
-      route.fulfill({ status: 404, body: 'blocked for testing' }),
-    )
-    await page.goto('/')
-    await page.waitForLoadState('networkidle')
-  })
-
-  test.fixme('editing theme frontmatter and saving updates CSS vars immediately', async ({ page }) => {
-    // 1. Switch to the default theme
-    await switchToDefaultTheme(page)
-    expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
-    expect(await getCssVar(page, '--sidebar')).toBe('#F7F6F3')
-
-    // 2. Open the theme note in raw editor mode
-    await openThemeNoteInRawMode(page)
-
-    // 3. Replace content via CodeMirror API with changed colors
-    const updatedContent = [
-      '---',
-      'type: Theme',
-      'title: Default',
-      'primary: "#155DFF"',
-      'background: "#1a1a2e"',
-      'foreground: "#37352F"',
-      'sidebar: "#2a2a3e"',
-      'border: "#E9E9E7"',
-      'muted: "#F0F0EF"',
-      'muted-foreground: "#9B9A97"',
-      'accent: "#F0F7FF"',
-      'accent-foreground: "#0A3B8F"',
-      'font-family: "\'Inter\', -apple-system, BlinkMacSystemFont, sans-serif"',
-      'font-size-base: 14',
-      'line-height-base: 1.6',
-      '---',
-      '',
-      '# Default',
-      '',
-      'Light theme with warm, paper-like tones.',
-    ].join('\n')
-    await setCmContent(page, updatedContent)
-
-    // Wait for debounce to flush (RawEditorView has 500ms debounce)
-    await page.waitForTimeout(700)
-
-    // 4. Save with Ctrl+S
-    await page.keyboard.press('Control+s')
-
-    // 5. Verify CSS vars updated live
-    await expect(async () => {
-      expect(await getCssVar(page, '--background')).toBe('#1a1a2e')
-    }).toPass({ timeout: 5000 })
-    expect(await getCssVar(page, '--sidebar')).toBe('#2a2a3e')
-  })
-
-  test.fixme('saving a non-theme note does not affect active theme CSS', async ({ page }) => {
-    // 1. Switch to the default theme
-    await switchToDefaultTheme(page)
-    expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
-
-    // 2. Open a regular note (first in list), switch to raw mode
-    const noteList = page.locator('[data-testid="note-list-container"]')
-    await noteList.waitFor({ timeout: 5000 })
-    await noteList.locator('.cursor-pointer').first().click()
-    await page.waitForTimeout(300)
-
-    await openCommandPalette(page)
-    await executeCommand(page, 'Toggle Raw Editor')
-    await expect(page.locator('.cm-content')).toBeVisible({ timeout: 3000 })
-
-    // 3. Type something and save
-    await page.locator('.cm-content').click()
-    await page.keyboard.type('test edit')
-    await page.keyboard.press('Control+s')
-    await page.waitForTimeout(500)
-
-    // 4. Theme CSS vars unchanged
-    expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
-  })
-})

tests/smoke/theme-live-reload-rework.spec.ts

@@ -0,0 +1,121 @@
+import { test, expect, type Page } from '@playwright/test'
+import { openCommandPalette, executeCommand } from './helpers'
+
+async function getCssVar(page: Page, name: string): Promise<string> {
+  return page.evaluate(
+    (n) => document.documentElement.style.getPropertyValue(n),
+    name,
+  )
+}
+
+/** Replace all text in the CodeMirror editor via the exposed __cmView. */
+async function setCmContent(page: Page, newContent: string) {
+  await page.evaluate((text) => {
+    const container = document.querySelector('[data-testid="raw-editor-codemirror"]')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const view = (container as any)?.__cmView
+    if (!view) throw new Error('No __cmView on raw-editor-codemirror container')
+    view.dispatch({
+      changes: { from: 0, to: view.state.doc.length, insert: text },
+    })
+  }, newContent)
+}
+
+test.describe('Theme live reload on raw editor save (rework)', () => {
+  test.beforeEach(async ({ page }) => {
+    // Block vault API so the app uses mock handlers
+    await page.route('**/api/vault/ping', (route) =>
+      route.fulfill({ status: 404, body: 'blocked for testing' }),
+    )
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('editing theme frontmatter in raw mode and saving updates CSS vars', async ({ page }) => {
+    // 1. Switch to the default theme
+    await openCommandPalette(page)
+    await executeCommand(page, 'Switch to Default Theme')
+    await expect(async () => {
+      expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
+    }).toPass({ timeout: 5000 })
+
+    // 2. Open the theme note in the editor
+    await openCommandPalette(page)
+    await executeCommand(page, 'Edit Default Theme')
+    await page.waitForTimeout(500)
+
+    // 3. Switch to raw editor mode
+    await openCommandPalette(page)
+    await executeCommand(page, 'Toggle Raw Editor')
+    await expect(page.locator('.cm-content')).toBeVisible({ timeout: 3000 })
+
+    // 4. Replace content with a changed background color
+    const updatedContent = [
+      '---',
+      'type: Theme',
+      'Description: Light theme with warm, paper-like tones',
+      'background: "#FFD700"',
+      'foreground: "#37352F"',
+      'primary: "#155DFF"',
+      'sidebar: "#F7F6F3"',
+      'text-primary: "#37352F"',
+      'lists-bullet-size: 32px',
+      'lists-bullet-color: "#FF0000"',
+      '---',
+      '',
+      '# Default',
+      '',
+      'Light theme with warm, paper-like tones.',
+    ].join('\n')
+    await setCmContent(page, updatedContent)
+
+    // Wait for debounce to flush (RawEditorView has 500ms debounce)
+    await page.waitForTimeout(700)
+
+    // 5. Save with Ctrl+S (works on all platforms in browser mode)
+    await page.keyboard.press('Control+s')
+
+    // 6. Verify CSS vars updated live
+    await expect(async () => {
+      expect(await getCssVar(page, '--background')).toBe('#FFD700')
+    }).toPass({ timeout: 5000 })
+
+    // Verify other vars also updated
+    expect(await getCssVar(page, '--sidebar')).toBe('#F7F6F3')
+    expect(await getCssVar(page, '--foreground')).toBe('#37352F')
+
+    // Verify bullet-size and bullet-color (rework regression)
+    expect(await getCssVar(page, '--lists-bullet-size')).toBe('32px')
+    expect(await getCssVar(page, '--lists-bullet-color')).toBe('#FF0000')
+  })
+
+  test('saving a non-theme note does not affect active theme CSS', async ({ page }) => {
+    // 1. Switch to the default theme
+    await openCommandPalette(page)
+    await executeCommand(page, 'Switch to Default Theme')
+    await expect(async () => {
+      expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
+    }).toPass({ timeout: 5000 })
+
+    // 2. Open a regular note (first in the note list)
+    const noteList = page.locator('[data-testid="note-list-container"]')
+    await noteList.waitFor({ timeout: 5000 })
+    await noteList.locator('.cursor-pointer').first().click()
+    await page.waitForTimeout(300)
+
+    // 3. Switch to raw editor mode
+    await openCommandPalette(page)
+    await executeCommand(page, 'Toggle Raw Editor')
+    await expect(page.locator('.cm-content')).toBeVisible({ timeout: 3000 })
+
+    // 4. Type something and save
+    await page.locator('.cm-content').click()
+    await page.keyboard.type('test edit ')
+    await page.waitForTimeout(600)
+    await page.keyboard.press('Control+s')
+    await page.waitForTimeout(500)
+
+    // 5. Theme CSS vars should be unchanged
+    expect(await getCssVar(page, '--background')).toBe('#FFFFFF')
+  })
+})

tests/smoke/title-field-alignment.spec.ts

@@ -0,0 +1,82 @@
+import { test, expect } from '@playwright/test'
+
+test.describe('TitleField alignment and separator', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForTimeout(500)
+
+    // Open a note so TitleField is visible
+    const noteItem = page.locator('.app__note-list .cursor-pointer').first()
+    await noteItem.click()
+    await page.waitForTimeout(500)
+  })
+
+  test('title-section and editor body share the same scroll container', async ({ page }) => {
+    // The .editor-scroll-area should contain both .title-section and .editor__blocknote-container
+    const scrollArea = page.locator('.editor-scroll-area')
+    await expect(scrollArea).toBeVisible({ timeout: 3000 })
+
+    const titleSection = scrollArea.locator('.title-section')
+    await expect(titleSection).toBeVisible()
+
+    const editorContainer = scrollArea.locator('.editor__blocknote-container')
+    await expect(editorContainer).toBeVisible()
+  })
+
+  test('separator line is visible between title and editor', async ({ page }) => {
+    const separator = page.locator('.title-section__separator')
+    await expect(separator).toBeVisible({ timeout: 3000 })
+
+    // Separator must have a visible border-bottom
+    const borderBottom = await separator.evaluate(
+      el => getComputedStyle(el).borderBottomStyle
+    )
+    expect(borderBottom).toBe('solid')
+  })
+
+  test('title-section and editor content are horizontally aligned', async ({ page }) => {
+    // Resize viewport to a wide width to test alignment
+    await page.setViewportSize({ width: 1400, height: 800 })
+    await page.waitForTimeout(300)
+
+    const titleSection = page.locator('.title-section')
+    const editorBlock = page.locator('.editor__blocknote-container .bn-editor')
+
+    await expect(titleSection).toBeVisible({ timeout: 3000 })
+    await expect(editorBlock).toBeVisible({ timeout: 3000 })
+
+    const titleBox = await titleSection.boundingBox()
+    const editorBox = await editorBlock.boundingBox()
+
+    expect(titleBox).not.toBeNull()
+    expect(editorBox).not.toBeNull()
+
+    // Both should have the same left edge (within 2px tolerance)
+    expect(Math.abs(titleBox!.x - editorBox!.x)).toBeLessThanOrEqual(2)
+  })
+
+  test('title field uses H1 CSS variables for font styling', async ({ page }) => {
+    // Verify the title-field__input element references the H1 heading CSS vars
+    const usesH1Vars = await page.evaluate(() => {
+      const sheets = Array.from(document.styleSheets)
+      for (const sheet of sheets) {
+        try {
+          for (const rule of Array.from(sheet.cssRules)) {
+            if (rule instanceof CSSStyleRule && rule.selectorText === '.title-field__input') {
+              const fontSize = rule.style.getPropertyValue('font-size')
+              const fontWeight = rule.style.getPropertyValue('font-weight')
+              return {
+                fontSize: fontSize.includes('--headings-h1-font-size'),
+                fontWeight: fontWeight.includes('--headings-h1-font-weight'),
+              }
+            }
+          }
+        } catch { /* cross-origin sheet */ }
+      }
+      return { fontSize: false, fontWeight: false }
+    })
+
+    expect(usesH1Vars.fontSize).toBe(true)
+    expect(usesH1Vars.fontWeight).toBe(true)
+  })
+})

tests/smoke/title-filename-sync.spec.ts

@@ -15,7 +15,7 @@ test.describe('Title/filename sync', () => {
     await page.waitForTimeout(2500)
   })
 
-  test('new note has title in frontmatter and filename = slug of title', async ({ page }) => {
+  test('new note renamed via TitleField updates frontmatter and filename', async ({ page }) => {
     const errors: string[] = []
     page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
 
@@ -24,14 +24,14 @@ test.describe('Title/filename sync', () => {
     await sendShortcut(page, 'n', ['Control'])
     await expect(page.getByText(/Untitled note/).first()).toBeVisible({ timeout: 3000 })
 
-    // Type a title in the heading
-    const heading = page.locator('[data-content-type="heading"] h1')
-    await heading.waitFor({ timeout: 3000 })
-    await heading.click({ clickCount: 3 })
-    await page.keyboard.type('Career Tracks Depend on Company Shape', { delay: 15 })
+    // Edit the title via TitleField (not H1)
+    const titleInput = page.getByTestId('title-field-input')
+    await titleInput.waitFor({ timeout: 3000 })
+    await titleInput.click()
+    await titleInput.fill('Career Tracks Depend on Company Shape')
+    await titleInput.press('Enter')
 
-    // Wait for debounce + rename
-    await page.waitForTimeout(800)
+    // Wait for async rename
     const toast = page.locator('.fixed.bottom-8')
     await expect(toast).toContainText('Renamed', { timeout: 5000 })
 
@@ -63,7 +63,7 @@ test.describe('Title/filename sync', () => {
     }
   })
 
-  test('rename via title editing updates both title and filename atomically', async ({ page }) => {
+  test('rename via TitleField updates both title and filename', async ({ page }) => {
     const errors: string[] = []
     page.on('pageerror', (err) => { if (!isKnownEditorError(err.message)) errors.push(err.message) })
 
@@ -72,21 +72,22 @@ test.describe('Title/filename sync', () => {
     await sendShortcut(page, 'n', ['Control'])
     await expect(page.getByText(/Untitled note/).first()).toBeVisible({ timeout: 3000 })
 
-    const heading = page.locator('[data-content-type="heading"] h1')
-    await heading.waitFor({ timeout: 3000 })
-    await heading.click({ clickCount: 3 })
-    await page.keyboard.type('Original Title XYZ', { delay: 15 })
+    // First rename via TitleField
+    const titleInput = page.getByTestId('title-field-input')
+    await titleInput.waitFor({ timeout: 3000 })
+    await titleInput.click()
+    await titleInput.fill('Original Title XYZ')
+    await titleInput.press('Enter')
 
     // Wait for rename
-    await page.waitForTimeout(800)
     await expect(page.locator('.fixed.bottom-8')).toContainText('Renamed', { timeout: 5000 })
 
-    // Now rename by editing the heading again
-    await heading.click({ clickCount: 3 })
-    await page.keyboard.type('Renamed Title XYZ', { delay: 15 })
+    // Second rename via TitleField
+    await titleInput.click()
+    await titleInput.fill('Renamed Title XYZ')
+    await titleInput.press('Enter')
 
-    // Wait for debounce + rename
-    await page.waitForTimeout(800)
+    // Wait for second rename
     await expect(page.locator('.fixed.bottom-8')).toContainText('Renamed', { timeout: 5000 })
 
     // Breadcrumb should show the new title

tests/smoke/trash-archive-ui-consistency.spec.ts

@@ -0,0 +1,99 @@
+import { test, expect } from '@playwright/test'
+import { openCommandPalette, executeCommand } from './helpers'
+
+const NOTE_ITEM = '[data-testid="note-list-container"] .cursor-pointer'
+
+test.describe('Trash/archive state consistency across UI', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+  })
+
+  test('trashing a note shows TrashedNoteBanner and updates Properties', async ({ page }) => {
+    // Select first note in the list
+    const firstNote = page.locator(NOTE_ITEM).first()
+    await firstNote.click()
+    await page.waitForTimeout(500)
+
+    // Verify no trash banner initially
+    await expect(page.locator('[data-testid="trashed-note-banner"]')).not.toBeVisible()
+
+    // Trash via command palette
+    await openCommandPalette(page)
+    await executeCommand(page, 'Trash Note')
+    await page.waitForTimeout(500)
+
+    // Banner should appear
+    await expect(page.locator('[data-testid="trashed-note-banner"]')).toBeVisible({ timeout: 3000 })
+
+    // Toast should say "Note moved to trash", NOT "Property updated"
+    const toast = page.locator('.fixed.bottom-8')
+    await expect(toast).toContainText(/moved to trash/i, { timeout: 3000 })
+  })
+
+  test('archiving a note shows ArchivedNoteBanner', async ({ page }) => {
+    // Select first note in the list
+    const firstNote = page.locator(NOTE_ITEM).first()
+    await firstNote.click()
+    await page.waitForTimeout(500)
+
+    // Verify no archive banner initially
+    await expect(page.locator('[data-testid="archived-note-banner"]')).not.toBeVisible()
+
+    // Archive via command palette
+    await openCommandPalette(page)
+    await executeCommand(page, 'Archive Note')
+    await page.waitForTimeout(500)
+
+    // Banner should appear
+    await expect(page.locator('[data-testid="archived-note-banner"]')).toBeVisible({ timeout: 3000 })
+  })
+
+  test('raw editor shows updated frontmatter after trash', async ({ page }) => {
+    // Select first note
+    const firstNote = page.locator(NOTE_ITEM).first()
+    await firstNote.click()
+    await page.waitForTimeout(500)
+
+    // Switch to raw editor mode
+    await openCommandPalette(page)
+    await executeCommand(page, 'Toggle Raw Editor')
+    await page.waitForTimeout(300)
+
+    const rawEditor = page.locator('[data-testid="raw-editor-codemirror"]')
+    await expect(rawEditor).toBeVisible({ timeout: 3000 })
+
+    // Trash the note
+    await openCommandPalette(page)
+    await executeCommand(page, 'Trash Note')
+    await page.waitForTimeout(500)
+
+    // Raw editor should show Trashed: true in frontmatter
+    const editorText = await rawEditor.textContent()
+    expect(editorText).toContain('Trashed')
+  })
+
+  test('Changes list updates after trashing a note', async ({ page }) => {
+    const sidebar = page.locator('.app__sidebar')
+    const secondaryArea = sidebar.locator('[data-testid="sidebar-secondary"]')
+    const changesRow = secondaryArea.locator('div', { hasText: /^Changes/ }).first()
+    await changesRow.waitFor({ timeout: 5000 })
+
+    const badge = changesRow.locator('span').last()
+    const initialCount = Number(await badge.textContent())
+
+    // Select and trash a note
+    const firstNote = page.locator(NOTE_ITEM).first()
+    await firstNote.click()
+    await page.waitForTimeout(300)
+
+    await openCommandPalette(page)
+    await executeCommand(page, 'Trash Note')
+
+    // Badge count should increase
+    await expect(async () => {
+      const text = await badge.textContent()
+      expect(Number(text)).toBeGreaterThan(initialCount)
+    }).toPass({ timeout: 5000 })
+  })
+})

tests/smoke/trashed-archived-not-saved.spec.ts

@@ -10,8 +10,9 @@ test.describe('Trash/archive notes appear in Changes', () => {
   test('trashing a note increments the Changes badge', async ({ page }) => {
     const sidebar = page.locator('.app__sidebar')
 
-    // Wait for Changes nav item (mock starts with 3 modified files)
-    const changesRow = sidebar.locator('div', { hasText: /^Changes/ }).first()
+    // Wait for Changes nav item in the secondary bottom area (mock starts with 3 modified files)
+    const secondaryArea = sidebar.locator('[data-testid="sidebar-secondary"]')
+    const changesRow = secondaryArea.locator('div', { hasText: /^Changes/ }).first()
     await changesRow.waitFor({ timeout: 5000 })
 
     // Read the initial badge count from the Changes row