fix: note path below title — show only on focus, remove duplicate filename

Two bugs fixed in TitleField:

1. Vault-relative path was always visible for subdirectory notes. Now
   only appears when the title input is focused, hidden on blur.

2. Both bare filename and vault-relative path rendered simultaneously.
   Now the filename hint is suppressed when the path is visible, so
   only one line shows (e.g. `docs/adr/0001-tauri-stack`). Also
   strips the .md extension from the displayed path.

Root-level notes continue to show no path (unchanged).

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

.claude/commands/laputa-done.md

@@ -1,6 +1,6 @@
 # /laputa-done <task_id>
 
-Mark a Laputa task as done: add completion comment, move to In Review, notify Brian, then self-dispatch the next task.
+Mark a Laputa task as done: add completion comment, move to In Review, then self-dispatch the next task.
 
 Run this after Phase 1 (Playwright) and Phase 2 (native app QA) both pass **and `git push origin main` has succeeded**.
 
@@ -35,16 +35,8 @@ curl -s -X POST "https://api.todoist.com/api/v1/tasks/$ARGUMENTS/move" \
   -d '{"section_id": "6g3XjX33FF4Vj86M"}'
 ```
 
-**3. Notify Luca (informational only — no action needed from him)**
-
-```bash
-openclaw system event --text "laputa-task-done:$ARGUMENTS" --mode now
-```
-
-This is a passive notification. Luca reviews tasks in his own time. Do NOT wait for approval — proceed immediately to step 4.
-
-**4. Pick the next task**
+**3. Pick the next task**
 
 Run `/laputa-next-task` to get the next task and start working on it immediately.
 
-If `/laputa-next-task` returns `NO_TASKS` → exit cleanly. The hourly watchdog will restart you when new tasks arrive.
+If there are no tasks, `/laputa-next-task` will wait 10 minutes and retry automatically. Do NOT exit — stay alive and let it loop.

.claude/commands/laputa-next-task.md

@@ -40,4 +40,17 @@ curl -s "https://api.todoist.com/api/v1/comments?task_id=<task_id>" \
 6. For To Rework tasks: read the ❌ QA failed comment — it tells you exactly what to fix
 7. Output: task ID, title, and full description so you can start working immediately
 
-If no tasks are available in either section → output `NO_TASKS` and exit cleanly.
+If no tasks are available in either section → wait 10 minutes and try again (loop forever):
+
+```bash
+while true; do
+  # ... check tasks ...
+  if no_tasks; then
+    sleep 600  # 10 minutes
+  else
+    break  # got a task, proceed
+  fi
+done
+```
+
+Do NOT exit when there are no tasks. Keep looping until a task appears. This keeps Claude Code alive permanently — the watchdog is a safety net only, not the primary dispatcher.

.codescene-thresholds

@@ -1,2 +1,2 @@
-HOTSPOT_THRESHOLD=9.6
-AVERAGE_THRESHOLD=9.37
+HOTSPOT_THRESHOLD=9.72
+AVERAGE_THRESHOLD=9.34

.env.example

@@ -0,0 +1,9 @@
+# Copy to .env.local and fill in real values
+# These are never committed — .env.local is gitignored
+
+# Sentry DSN (https://sentry.io → Project → Settings → Client Keys)
+VITE_SENTRY_DSN=
+
+# PostHog (https://posthog.com → Project → Settings → Project API Key)
+VITE_POSTHOG_KEY=
+VITE_POSTHOG_HOST=https://eu.i.posthog.com

.gitignore

@@ -67,3 +67,7 @@ CODE-HEALTH-REPORT.md
 # Tauri signing keys (never commit private keys)
 *.key
 *.key.pub
+
+# Local environment variables (never commit)
+.env.local
+.env.*.local

docs/adr/0008-underscore-system-properties.md

@@ -27,3 +27,16 @@ As Laputa added more features that store configuration in note frontmatter (pinn
 - Power users can still access and edit system properties via the raw editor.
 - Type documents use `_icon`, `_color`, `_order`, `_sidebar_label`, `_pinned_properties`.
 - Re-evaluation trigger: if the number of system properties grows large enough to warrant a structured sub-object.
+
+## Normalized system properties
+
+| Canonical key | Old keys (read with fallback) | Written by |
+|---|---|---|
+| `_archived` | `Archived`, `archived` | Archive action |
+| `_trashed` | `Trashed`, `trashed` | Trash action |
+| `_trashed_at` | `Trashed at`, `trashed_at` | Trash action |
+| `_favorite` | — | Favorite toggle |
+| `_favorite_index` | — | Favorite reorder |
+
+**Write rule**: always use the canonical `_`-prefixed key.
+**Read rule**: accept both canonical and legacy keys (case-insensitive). Do NOT rewrite on read — migration is a separate concern.

docs/adr/0038-frontmatter-backed-favorites.md

@@ -0,0 +1,32 @@
+---
+type: ADR
+id: "0038"
+title: "Frontmatter-backed favorites with _favorite and _favorite_index"
+status: active
+date: 2026-04-02
+---
+
+## Context
+
+Users want to pin frequently-accessed notes to a dedicated FAVORITES section in the sidebar for quick navigation. The app needs a persistence mechanism for which notes are favorited and their display order.
+
+## Decision
+
+**Favorites are stored as two system properties in each note's YAML frontmatter: `_favorite: true` and `_favorite_index: <integer>`.**
+
+- `_favorite`: boolean. Present and `true` = favorited. Absent = not favorited. Toggling off deletes the key entirely (no `_favorite: false`).
+- `_favorite_index`: integer. Controls display order in the FAVORITES sidebar section (lower = higher). Assigned automatically on favorite, updated on drag-to-reorder.
+- Both use the `_` prefix convention (ADR 0008) — they are system-owned and hidden from the Properties panel.
+
+## Options considered
+
+- **Frontmatter per-note (chosen)**: Each note carries its own favorite state. Portable across devices (synced via git). No separate metadata file. Cons: two extra frontmatter writes on reorder.
+- **Separate `.laputa/favorites.json` file**: Central list of favorite paths. Simpler reorder (one file write). Cons: not portable if `.laputa/` is gitignored; path references break on rename.
+- **SQLite/app-level metadata**: Fast queries. Cons: not synced via git; diverges from frontmatter-first data model established in ADR 0008.
+
+## Consequences
+
+- Favorites survive vault sync via git — any client that reads frontmatter sees them.
+- Reorder writes `_favorite_index` to N files (one per affected note). Acceptable for typical favorites lists (< 20 items).
+- If `_favorite: true` exists but `_favorite_index` is absent, the note is appended to the end of the list.
+- Re-evaluate if favorites list exceeds ~50 items and reorder writes become a performance concern.

docs/adr/0039-git-history-for-note-dates.md

@@ -0,0 +1,40 @@
+---
+type: ADR
+id: "0039"
+title: "Use git history for note creation and modification dates"
+status: active
+date: 2026-04-02
+---
+
+## Context
+
+Filesystem metadata (`ctime`/`mtime`) is unreliable for a git-backed vault. After `git clone`, `git pull`, or iCloud sync, files appear "newly created" even when they have years of history. This causes incorrect sort ordering in the note list and wrong dates in the inspector panel.
+
+## Decision
+
+**Use `git log` to determine the true creation and modification dates for notes.** A single batch `git log --format="COMMIT %aI" --name-only` command walks the full commit history and extracts:
+
+- **modified_at** = author date of the most recent commit that touched the file
+- **created_at** = author date of the oldest commit that touched the file
+
+The batch approach runs once per vault scan (not per-file), parsing the log output in a single linear pass. Results are stored in a `HashMap<String, GitDates>` keyed by vault-relative path and threaded through the existing `parse_md_file` / `scan_vault` / `scan_vault_cached` pipeline.
+
+### Fallback to filesystem dates
+
+- **Non-git vaults** (no `.git` directory): all notes use filesystem `mtime`/`ctime`.
+- **Uncommitted new files**: not in git log output, so filesystem dates are used automatically.
+- **Single-file reloads** (`reload_entry`): use filesystem dates since the file was just saved and the most accurate timestamp is the filesystem one.
+
+## Options considered
+
+- **Per-file `git log`**: Correct but O(n) subprocesses. Too slow for vaults with 500+ notes.
+- **Frontmatter dates** (e.g., `created: 2025-01-15`): Requires user discipline. Not automatic. Breaks when users forget to set them.
+- **Filesystem metadata** (current): Unreliable across clones, pulls, and cloud sync.
+- **Single batch `git log`** (chosen): One subprocess, O(n) parsing, correct dates for all committed files.
+
+## Consequences
+
+- Note sort-by-created and sort-by-modified now reflect true git history, stable across clones and machines.
+- First vault scan runs one `git log` over the full history. For a vault with 1000 files and 500 commits, output is ~100KB and parses in <100ms.
+- Renamed files get `created_at` set to the rename commit date (not the original creation). Acceptable trade-off vs. the complexity of rename tracking.
+- `CACHE_VERSION` bumped from 9 to 10 to force a full rescan with git dates on upgrade.

docs/adr/0040-custom-views-yml-filter-engine.md

@@ -0,0 +1,59 @@
+---
+type: ADR
+id: "0040"
+title: "Custom views as .yml files with client-side filter engine"
+status: active
+date: 2026-04-02
+---
+
+## Context
+
+Users want to save reusable filtered note lists (e.g., "Active Projects", "This Week's Events") as named sidebar items. These views need to persist across sessions, sync via git, and support arbitrary frontmatter conditions.
+
+## Decision
+
+**Custom views are stored as `.yml` files in `.laputa/views/` within the vault root.** Each file defines a named view with filter conditions, optional icon/color, and sort preferences.
+
+### File format
+
+```yaml
+name: Active Projects
+icon: rocket
+color: blue
+sort: "modified:desc"
+filters:
+  all:
+    - field: type
+      op: equals
+      value: Project
+    - field: status
+      op: not_equals
+      value: done
+```
+
+### Filter engine
+
+Filters use a tree of AND/OR groups (`all`/`any`) containing conditions. Each condition specifies a `field`, `op` (operator), and optional `value`. Supported operators: `equals`, `not_equals`, `contains`, `not_contains`, `any_of`, `none_of`, `is_empty`, `is_not_empty`, `before`, `after`.
+
+Field resolution: built-in fields (`type`, `status`, `title`, `archived`, `trashed`, `favorite`) map to VaultEntry struct fields. Unknown fields fall back to `entry.properties`, then `entry.relationships`.
+
+Wikilink values like `[[target|Alias]]` are matched by stem (stripping brackets and pipe+alias).
+
+### Architecture
+
+- **Rust backend** (`vault/views.rs`): YAML parsing via `serde_yaml`, filter evaluation, file CRUD. Three Tauri commands: `list_views`, `save_view_cmd`, `delete_view_cmd`.
+- **Frontend**: Client-side filter evaluation against the already-loaded `VaultEntry[]` array. The Rust `evaluate_view` exists for MCP/CLI access but is not the primary UI path.
+- **Sidebar**: VIEWS section between Favorites and Types, hidden when no views exist.
+
+## Options considered
+
+- **SQLite views table**: Fast queries, but not portable via git and diverges from the file-first data model.
+- **Frontmatter on a special `.md` file**: Overloads the note format for a non-note concept.
+- **Standalone `.yml` files (chosen)**: Portable (synced via git), editable by hand or UI, naturally separated from note content.
+
+## Consequences
+
+- New dependency: `serde_yaml` crate for YAML parsing.
+- `.laputa/views/` directory auto-created on first view save. Already excluded from vault scanning via `HIDDEN_DIRS`.
+- Views sync across devices via git. Conflicts resolved by standard git merge (YAML is line-based, merges well).
+- Sort persistence: changing sort while a view is selected writes `sort` back to the `.yml` file.

docs/adr/0041-filekind-all-files-in-vault-scanner.md

@@ -0,0 +1,39 @@
+---
+type: ADR
+id: "0041"
+title: "fileKind field — scan all vault files, not just markdown"
+status: active
+date: 2026-04-02
+---
+
+## Context
+
+Laputa vaults often contain non-markdown files alongside notes: images, PDFs, YAML configs, JSON exports, scripts, etc. Previously the vault scanner only indexed `.md` files — all other files were invisible to the app. This made the Folder view incomplete: navigating a folder containing a `config.yml` or `photo.png` showed nothing, even though the file was physically there.
+
+The need arose when adding a Folder tree view that is meant to mirror the actual filesystem structure. Users expect to see all files in a folder, as any file manager would show.
+
+## Decision
+
+**The vault scanner now indexes all files (not just `.md`). Every `VaultEntry` carries a `fileKind` field (`"markdown"`, `"text"`, or `"binary"`) that controls how the frontend renders and opens it.**
+
+- **`"markdown"`**: full Laputa behavior — frontmatter parsing, BlockNote editor, title sync, type system.
+- **`"text"`**: filename as title, no frontmatter, opens in raw CodeMirror editor. Covers `.yml`, `.json`, `.ts`, `.py`, `.sh`, etc.
+- **`"binary"`**: filename as title, grayed out, non-clickable. Covers images, PDFs, binaries.
+- **Hidden files** (starting with `.`) are skipped regardless of extension.
+- **Non-folder views** (All Notes, type sections, Custom Views) still show only `"markdown"` entries.
+- **Folder view** shows all file kinds.
+
+## Options considered
+
+- **Option A** (chosen): Single `VaultEntry` model with a `fileKind` discriminator. All files go through the same pipeline; rendering is gated by `fileKind`. Simple, incremental — existing code paths untouched for markdown files.
+- **Option B**: Separate data model for non-markdown files (e.g. `AssetEntry`). Cleaner type hierarchy, but requires duplicating list/filter/sort logic for two types across the codebase.
+- **Option C**: Only scan `.md` + explicitly listed extensions (e.g. `.yml`, `.json`). Simpler initial implementation, but requires ongoing maintenance of an allowlist and still misses user files. Abandoned in favor of a deny-list approach (only `.`-prefixed hidden files are excluded).
+
+## Consequences
+
+- Non-markdown files are visible in Folder view — the app now behaves like a file manager in that context.
+- All views except Folder view continue to show only markdown files (the `isMarkdown` guard in `filterEntries`).
+- `countByFilter` / `countAllByFilter` exclude non-markdown entries to keep sidebar counters accurate.
+- The vault cache version was bumped to `11` to force a full rescan after this change.
+- Binary files have no click action — clicking does nothing (no editor opened).
+- Re-evaluation trigger: if users need to preview or edit binary files (e.g. images), a dedicated preview pane would need a separate ADR.

docs/adr/README.md

@@ -93,3 +93,7 @@ proposed → active → superseded
 | [0035](0035-path-suffix-wikilink-resolution.md) | Path-suffix wikilink resolution for subfolder vaults | active |
 | [0036](0036-external-rename-detection-via-git-diff.md) | External rename detection via git diff on focus regain | active |
 | [0037](0037-codemirror-language-markdown-highlighting.md) | Language-based markdown syntax highlighting in raw editor | active |
+| [0038](0038-frontmatter-backed-favorites.md) | Frontmatter-backed favorites (_favorite, _favorite_index) | active |
+| [0039](0039-git-history-for-note-dates.md) | Git history as source of truth for note creation/modification dates | active |
+| [0040](0040-custom-views-yml-filter-engine.md) | Custom Views — .laputa/views/*.yml with YAML filter engine | active |
+| [0041](0041-filekind-all-files-in-vault-scanner.md) | fileKind field — scan all vault files, not just markdown | active |

src-tauri/Cargo.lock

@@ -2272,6 +2272,7 @@ dependencies = [
  "sentry",
  "serde",
  "serde_json",
+ "serde_yaml",
  "tauri",
  "tauri-build",
  "tauri-plugin-dialog",
@@ -4294,6 +4295,19 @@ dependencies = [
  "syn 2.0.115",
 ]
 
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.13.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "serialize-to-javascript"
 version = "0.1.2"
@@ -5509,6 +5523,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"

src-tauri/Cargo.toml

@@ -18,6 +18,7 @@ tauri-build = { version = "2.5.4", features = [] }
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
+serde_yaml = "0.9"
 log = "0.4"
 tauri = { version = "2.10.0", features = ["protocol-asset", "devtools"] }
 tauri-plugin-log = "2"

src-tauri/src/commands/vault.rs

@@ -1,6 +1,8 @@
 use crate::frontmatter::FrontmatterValue;
 use crate::search::SearchResponse;
-use crate::vault::{DetectedRename, FolderNode, RenameResult, VaultEntry};
+use crate::vault::{
+    DetectedRename, FolderNode, RenameResult, VaultEntry, ViewDefinition, ViewFile,
+};
 use crate::{frontmatter, git, search, vault};
 
 use super::expand_tilde;
@@ -158,6 +160,30 @@ pub fn copy_image_to_vault(vault_path: String, source_path: String) -> Result<St
     vault::copy_image_to_vault(&vault_path, &source_path)
 }
 
+// ── View commands ──────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn list_views(vault_path: String) -> Vec<ViewFile> {
+    let path = expand_tilde(&vault_path);
+    vault::scan_views(std::path::Path::new(path.as_ref()))
+}
+
+#[tauri::command]
+pub fn save_view_cmd(
+    vault_path: String,
+    filename: String,
+    definition: ViewDefinition,
+) -> Result<(), String> {
+    let path = expand_tilde(&vault_path);
+    vault::save_view(std::path::Path::new(path.as_ref()), &filename, &definition)
+}
+
+#[tauri::command]
+pub fn delete_view_cmd(vault_path: String, filename: String) -> Result<(), String> {
+    let path = expand_tilde(&vault_path);
+    vault::delete_view(std::path::Path::new(path.as_ref()), &filename)
+}
+
 // ── Frontmatter commands ────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -181,7 +207,7 @@ pub fn batch_archive_notes(paths: Vec<String>) -> Result<usize, String> {
     let mut count = 0;
     for path in &paths {
         let path = expand_tilde(path);
-        frontmatter::update_frontmatter(&path, "Archived", FrontmatterValue::Bool(true))?;
+        frontmatter::update_frontmatter(&path, "_archived", FrontmatterValue::Bool(true))?;
         count += 1;
     }
     Ok(count)
@@ -193,10 +219,10 @@ pub fn batch_trash_notes(paths: Vec<String>) -> Result<usize, String> {
     let mut count = 0;
     for path in &paths {
         let path = expand_tilde(path);
-        frontmatter::update_frontmatter(&path, "Trashed", FrontmatterValue::Bool(true))?;
+        frontmatter::update_frontmatter(&path, "_trashed", FrontmatterValue::Bool(true))?;
         frontmatter::update_frontmatter(
             &path,
-            "Trashed at",
+            "_trashed_at",
             FrontmatterValue::String(now.clone()),
         )?;
         count += 1;
@@ -250,7 +276,7 @@ mod tests {
             1
         );
         let content = std::fs::read_to_string(&note).unwrap();
-        assert!(content.contains("Archived: true"));
+        assert!(content.contains("_archived: true"));
         assert!(content.contains("Status: Active"));
     }
 
@@ -262,8 +288,8 @@ mod tests {
             1
         );
         let content = std::fs::read_to_string(&note).unwrap();
-        assert!(content.contains("Trashed: true"));
-        assert!(content.contains("Trashed at"));
+        assert!(content.contains("_trashed: true"));
+        assert!(content.contains("_trashed_at"));
     }
 
     #[test]

src-tauri/src/git/dates.rs

@@ -0,0 +1,230 @@
+use chrono::DateTime;
+use std::collections::HashMap;
+use std::path::Path;
+use std::process::Command;
+
+/// Git-derived creation and modification timestamps for a file.
+#[derive(Debug, Clone)]
+pub struct GitDates {
+    pub created_at: u64,
+    pub modified_at: u64,
+}
+
+/// Run a single `git log` to collect creation and modification dates for all
+/// tracked files in the repository. Returns a map from relative path to dates.
+///
+/// - **modified_at** = author date of the most recent commit touching the file
+/// - **created_at** = author date of the oldest commit touching the file
+///
+/// Files not yet committed (untracked / only staged) will not appear in the map;
+/// callers should fall back to filesystem metadata for those.
+pub fn get_all_file_dates(vault_path: &Path) -> HashMap<String, GitDates> {
+    let output = match Command::new("git")
+        .args(["log", "--format=COMMIT %aI", "--name-only"])
+        .current_dir(vault_path)
+        .output()
+    {
+        Ok(o) if o.status.success() => o,
+        _ => return HashMap::new(),
+    };
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    parse_git_log_output(&stdout)
+}
+
+/// Parse the output of `git log --format="COMMIT %aI" --name-only`.
+///
+/// Output looks like:
+/// ```text
+/// COMMIT 2026-03-15T10:00:00+02:00
+///
+/// file-a.md
+/// file-b.md
+///
+/// COMMIT 2026-03-10T08:00:00+02:00
+///
+/// file-a.md
+/// ```
+///
+/// Commits are ordered newest-first. For each file:
+/// - First occurrence → sets `modified_at`
+/// - Every subsequent occurrence overwrites `created_at` (last one = oldest commit wins)
+fn parse_git_log_output(stdout: &str) -> HashMap<String, GitDates> {
+    let mut map: HashMap<String, GitDates> = HashMap::new();
+    let mut current_ts: Option<u64> = None;
+
+    for line in stdout.lines() {
+        if let Some(date_str) = line.strip_prefix("COMMIT ") {
+            current_ts = parse_author_date(date_str);
+            continue;
+        }
+
+        let path = line.trim();
+        if path.is_empty() || current_ts.is_none() {
+            continue;
+        }
+        // Only process .md files
+        if !path.ends_with(".md") {
+            continue;
+        }
+
+        let ts = current_ts.unwrap();
+        map.entry(path.to_string())
+            .and_modify(|d| d.created_at = ts)
+            .or_insert(GitDates {
+                created_at: ts,
+                modified_at: ts,
+            });
+    }
+
+    map
+}
+
+fn parse_author_date(s: &str) -> Option<u64> {
+    DateTime::parse_from_rfc3339(s.trim())
+        .ok()
+        .map(|dt| dt.timestamp() as u64)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_git_log_single_commit() {
+        let output = "\
+COMMIT 2026-03-15T10:00:00+00:00
+
+file-a.md
+file-b.md
+";
+        let map = parse_git_log_output(output);
+        assert_eq!(map.len(), 2);
+        assert_eq!(map["file-a.md"].created_at, 1773568800);
+        assert_eq!(map["file-a.md"].modified_at, 1773568800);
+    }
+
+    #[test]
+    fn test_parse_git_log_multiple_commits() {
+        let output = "\
+COMMIT 2026-03-15T10:00:00+00:00
+
+file-a.md
+
+COMMIT 2026-03-10T08:00:00+00:00
+
+file-a.md
+file-b.md
+";
+        let map = parse_git_log_output(output);
+        assert_eq!(map.len(), 2);
+        // file-a: modified = newest (2026-03-15), created = oldest (2026-03-10)
+        assert_eq!(map["file-a.md"].modified_at, 1773568800);
+        assert_eq!(map["file-a.md"].created_at, 1773129600);
+        // file-b: only in second commit
+        assert_eq!(map["file-b.md"].modified_at, 1773129600);
+        assert_eq!(map["file-b.md"].created_at, 1773129600);
+    }
+
+    #[test]
+    fn test_non_md_files_filtered_out() {
+        let output = "\
+COMMIT 2026-03-15T10:00:00+00:00
+
+README.txt
+note.md
+image.png
+";
+        let map = parse_git_log_output(output);
+        assert_eq!(map.len(), 1);
+        assert!(map.contains_key("note.md"));
+    }
+
+    #[test]
+    fn test_empty_output() {
+        let map = parse_git_log_output("");
+        assert!(map.is_empty());
+    }
+
+    #[test]
+    fn test_subdirectory_paths() {
+        let output = "\
+COMMIT 2026-03-15T10:00:00+00:00
+
+docs/adr/0001-stack.md
+notes/daily.md
+";
+        let map = parse_git_log_output(output);
+        assert_eq!(map.len(), 2);
+        assert!(map.contains_key("docs/adr/0001-stack.md"));
+        assert!(map.contains_key("notes/daily.md"));
+    }
+
+    #[test]
+    fn test_get_all_file_dates_in_real_repo() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let vault = dir.path();
+
+        // Init repo
+        std::process::Command::new("git")
+            .args(["init"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.email", "test@test.com"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["config", "user.name", "Test"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // First commit with one file
+        std::fs::write(vault.join("first.md"), "# First\n").unwrap();
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "first"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        // Second commit with another file + modify first
+        std::fs::write(vault.join("first.md"), "# First\nUpdated.\n").unwrap();
+        std::fs::write(vault.join("second.md"), "# Second\n").unwrap();
+        std::process::Command::new("git")
+            .args(["add", "."])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+        std::process::Command::new("git")
+            .args(["commit", "-m", "second"])
+            .current_dir(vault)
+            .output()
+            .unwrap();
+
+        let map = get_all_file_dates(vault);
+        assert_eq!(map.len(), 2);
+        assert!(map.contains_key("first.md"));
+        assert!(map.contains_key("second.md"));
+
+        // first.md: created in commit 1, modified in commit 2
+        // So modified_at > created_at (or equal if commits are same second)
+        assert!(map["first.md"].modified_at >= map["first.md"].created_at);
+        // second.md: only in commit 2
+        assert_eq!(map["second.md"].modified_at, map["second.md"].created_at);
+    }
+
+    #[test]
+    fn test_get_all_file_dates_no_git_repo() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let map = get_all_file_dates(dir.path());
+        assert!(map.is_empty());
+    }
+}

src-tauri/src/git/mod.rs

@@ -1,5 +1,6 @@
 mod commit;
 mod conflict;
+mod dates;
 mod history;
 mod pulse;
 mod remote;
@@ -13,6 +14,7 @@ pub use conflict::{
     get_conflict_files, get_conflict_mode, git_commit_conflict_resolution, git_resolve_conflict,
     is_merge_in_progress, is_rebase_in_progress,
 };
+pub use dates::{get_all_file_dates, GitDates};
 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::{

src-tauri/src/lib.rs

@@ -176,7 +176,10 @@ pub fn run() {
             commands::register_mcp_tools,
             commands::check_mcp_status,
             commands::repair_vault,
-            commands::reinit_telemetry
+            commands::reinit_telemetry,
+            commands::list_views,
+            commands::save_view_cmd,
+            commands::delete_view_cmd
         ])
         .build(tauri::generate_context!())
         .expect("error while building tauri application")

src-tauri/src/vault/cache.rs

@@ -3,12 +3,15 @@ use std::fs;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 
-use super::{parse_md_file, scan_vault, VaultEntry};
+use crate::git::{get_all_file_dates, GitDates};
+use std::collections::HashMap;
+
+use super::{is_md_file, parse_md_file, parse_non_md_file, scan_vault, VaultEntry};
 
 // --- Vault Cache ---
 
 /// Bump this when VaultEntry fields change to force a full rescan.
-const CACHE_VERSION: u32 = 9;
+const CACHE_VERSION: u32 = 11;
 
 #[derive(Debug, Serialize, Deserialize)]
 struct VaultCache {
@@ -172,14 +175,26 @@ fn to_relative_path(abs_path: &str, vault: &Path) -> String {
         .to_string()
 }
 
-/// Parse .md files from a list of relative paths, skipping any that don't exist.
-fn parse_files_at(vault: &Path, rel_paths: &[String]) -> Vec<VaultEntry> {
+/// Parse files from a list of relative paths, skipping any that don't exist.
+/// Dispatches to the appropriate parser based on file extension.
+fn parse_files_at(
+    vault: &Path,
+    rel_paths: &[String],
+    git_dates: &HashMap<String, GitDates>,
+) -> Vec<VaultEntry> {
     rel_paths
         .iter()
         .filter_map(|rel| {
             let abs = vault.join(rel);
             if abs.is_file() {
-                parse_md_file(&abs).ok()
+                let dates = git_dates
+                    .get(rel.as_str())
+                    .map(|d| (d.modified_at, d.created_at));
+                if is_md_file(&abs) {
+                    parse_md_file(&abs, dates).ok()
+                } else {
+                    parse_non_md_file(&abs, dates).ok()
+                }
             } else {
                 None
             }
@@ -264,13 +279,17 @@ fn finalize_and_cache(vault: &Path, mut entries: Vec<VaultEntry>, hash: String)
 /// Handle same-commit cache hit: re-parse any uncommitted changes (new or modified files).
 /// Always prunes stale entries even when git reports no changes, so that files
 /// deleted outside git (e.g., via Finder) are removed from the cache on vault open.
-fn update_same_commit(vault: &Path, cache: VaultCache) -> Vec<VaultEntry> {
+fn update_same_commit(
+    vault: &Path,
+    cache: VaultCache,
+    git_dates: &HashMap<String, GitDates>,
+) -> Vec<VaultEntry> {
     let changed = git_uncommitted_files(vault);
     let mut entries = cache.entries;
     if !changed.is_empty() {
         let changed_set: std::collections::HashSet<String> = changed.iter().cloned().collect();
         entries.retain(|e| !changed_set.contains(&to_relative_path(&e.path, vault)));
-        entries.extend(parse_files_at(vault, &changed));
+        entries.extend(parse_files_at(vault, &changed, git_dates));
     }
     // Always finalize: prune_stale_entries inside finalize_and_cache removes
     // entries for files deleted outside git (e.g., via Finder or another app).
@@ -282,6 +301,7 @@ fn update_different_commit(
     vault: &Path,
     cache: VaultCache,
     current_hash: String,
+    git_dates: &HashMap<String, GitDates>,
 ) -> Vec<VaultEntry> {
     let changed_files = git_changed_files(vault, &cache.commit_hash, &current_hash);
     let changed_set: std::collections::HashSet<String> = changed_files.iter().cloned().collect();
@@ -291,7 +311,7 @@ fn update_different_commit(
         .into_iter()
         .filter(|e| !changed_set.contains(&to_relative_path(&e.path, vault)))
         .collect();
-    entries.extend(parse_files_at(vault, &changed_files));
+    entries.extend(parse_files_at(vault, &changed_files, git_dates));
 
     finalize_and_cache(vault, entries, current_hash)
 }
@@ -319,26 +339,34 @@ pub fn scan_vault_cached(vault_path: &Path) -> Result<Vec<VaultEntry>, String> {
 
     let current_hash = match git_head_hash(vault_path) {
         Some(h) => h,
-        None => return scan_vault(vault_path),
+        None => return scan_vault(vault_path, &HashMap::new()),
     };
 
+    // Build git dates map once — used by all code paths below
+    let git_dates = get_all_file_dates(vault_path);
+
     if let Some(cache) = load_cache(vault_path) {
         let current_vault_str = vault_path.to_string_lossy();
         let cache_stale = cache.version != CACHE_VERSION
             || (!cache.vault_path.is_empty() && cache.vault_path != current_vault_str.as_ref());
         if cache_stale {
-            let entries = scan_vault(vault_path)?;
+            let entries = scan_vault(vault_path, &git_dates)?;
             return Ok(finalize_and_cache(vault_path, entries, current_hash));
         }
         return if cache.commit_hash == current_hash {
-            Ok(update_same_commit(vault_path, cache))
+            Ok(update_same_commit(vault_path, cache, &git_dates))
         } else {
-            Ok(update_different_commit(vault_path, cache, current_hash))
+            Ok(update_different_commit(
+                vault_path,
+                cache,
+                current_hash,
+                &git_dates,
+            ))
         };
     }
 
     // No cache — full scan and write cache
-    let entries = scan_vault(vault_path)?;
+    let entries = scan_vault(vault_path, &git_dates)?;
     Ok(finalize_and_cache(vault_path, entries, current_hash))
 }
 
@@ -930,7 +958,7 @@ mod tests {
 
         // Simulate a stale cache written by old code that parsed Archived: Yes as false
         let stale_entry = {
-            let mut e = parse_md_file(&vault.join("note.md")).unwrap();
+            let mut e = parse_md_file(&vault.join("note.md"), None).unwrap();
             e.archived = false; // simulate old parser behavior
             e
         };

src-tauri/src/vault/entry.rs

@@ -59,6 +59,11 @@ pub struct VaultEntry {
     pub view: Option<String>,
     /// Whether this Type is visible in the sidebar. Defaults to true when absent.
     pub visible: Option<bool>,
+    /// Whether this note is a user favorite (shown in FAVORITES sidebar section).
+    pub favorite: bool,
+    /// Display order within the FAVORITES section (lower = higher).
+    #[serde(rename = "favoriteIndex")]
+    pub favorite_index: Option<i64>,
     /// Word count of the note body (excludes frontmatter and H1 title).
     #[serde(rename = "wordCount")]
     pub word_count: u32,
@@ -70,4 +75,12 @@ pub struct VaultEntry {
     /// Only includes strings, numbers, and booleans — arrays/objects are excluded.
     #[serde(default)]
     pub properties: HashMap<String, serde_json::Value>,
+    /// File kind: "markdown", "text", or "binary".
+    /// Determines how the frontend renders and opens the file.
+    #[serde(rename = "fileKind", default = "default_file_kind")]
+    pub file_kind: String,
+}
+
+fn default_file_kind() -> String {
+    "markdown".to_string()
 }

src-tauri/src/vault/frontmatter.rs

@@ -12,14 +12,16 @@ pub(crate) struct Frontmatter {
     #[serde(default)]
     pub aliases: Option<StringOrList>,
     #[serde(
-        rename = "Archived",
+        rename = "_archived",
+        alias = "Archived",
         alias = "archived",
         default,
         deserialize_with = "deserialize_bool_or_string"
     )]
     pub archived: Option<bool>,
     #[serde(
-        rename = "Trashed",
+        rename = "_trashed",
+        alias = "Trashed",
         alias = "trashed",
         default,
         deserialize_with = "deserialize_bool_or_string"
@@ -27,7 +29,7 @@ pub(crate) struct Frontmatter {
     pub trashed: Option<bool>,
     #[serde(rename = "Status", alias = "status", default)]
     pub status: Option<StringOrList>,
-    #[serde(rename = "Trashed at", alias = "trashed_at")]
+    #[serde(rename = "_trashed_at", alias = "Trashed at", alias = "trashed_at")]
     pub trashed_at: Option<StringOrList>,
     #[serde(default)]
     pub icon: Option<StringOrList>,
@@ -45,6 +47,14 @@ pub(crate) struct Frontmatter {
     pub view: Option<StringOrList>,
     #[serde(default)]
     pub visible: Option<bool>,
+    #[serde(
+        rename = "_favorite",
+        default,
+        deserialize_with = "deserialize_bool_or_string"
+    )]
+    pub favorite: Option<bool>,
+    #[serde(rename = "_favorite_index", default)]
+    pub favorite_index: Option<i64>,
 }
 
 /// Custom deserializer for boolean fields that may arrive as strings.
@@ -137,10 +147,13 @@ fn parse_frontmatter(data: &HashMap<String, serde_json::Value>) -> Frontmatter {
         "Is A",
         "is_a",
         "aliases",
+        "_archived",
         "Archived",
         "archived",
+        "_trashed",
         "Trashed",
         "trashed",
+        "_trashed_at",
         "Trashed at",
         "trashed_at",
         "icon",
@@ -154,6 +167,8 @@ fn parse_frontmatter(data: &HashMap<String, serde_json::Value>) -> Frontmatter {
         "notion_id",
         "Status",
         "status",
+        "_favorite",
+        "_favorite_index",
     ];
     let filtered: serde_json::Map<String, serde_json::Value> = data
         .iter()
@@ -172,9 +187,13 @@ const SKIP_KEYS: &[&str] = &[
     "is a",
     "type",
     "aliases",
+    "_archived",
     "archived",
+    "_trashed",
     "trashed",
+    "_trashed_at",
     "trashed at",
+    "trashed_at",
     "icon",
     "color",
     "order",
@@ -184,6 +203,8 @@ const SKIP_KEYS: &[&str] = &[
     "view",
     "visible",
     "status",
+    "_favorite",
+    "_favorite_index",
 ];
 
 /// Extract all wikilink-containing fields from raw YAML frontmatter.

src-tauri/src/vault/getting_started.rs

@@ -503,7 +503,8 @@ mod tests {
         let vault_path = dir.path().join("parse-vault");
         create_getting_started_vault(vault_path.to_str().unwrap()).unwrap();
 
-        let entries = crate::vault::scan_vault(&vault_path).unwrap();
+        let entries =
+            crate::vault::scan_vault(&vault_path, &std::collections::HashMap::new()).unwrap();
         // SAMPLE_FILES + AGENTS.md
         assert_eq!(entries.len(), SAMPLE_FILES.len() + 1);
     }
@@ -537,7 +538,7 @@ mod tests {
         let vault_path = dir.path().join("agents-parse-vault");
         create_getting_started_vault(vault_path.to_str().unwrap()).unwrap();
 
-        let entry = crate::vault::parse_md_file(&vault_path.join("AGENTS.md")).unwrap();
+        let entry = crate::vault::parse_md_file(&vault_path.join("AGENTS.md"), None).unwrap();
         // No frontmatter title → derived from filename slug (H1 is body content)
         assert_eq!(entry.title, "AGENTS");
         // Config files have no frontmatter type field — type is None

src-tauri/src/vault/mod.rs

@@ -10,6 +10,7 @@ mod parsing;
 mod rename;
 mod title_sync;
 mod trash;
+mod views;
 
 pub use cache::{invalidate_cache, scan_vault_cached};
 pub use config_seed::{migrate_agents_md, repair_config_files, seed_config_files};
@@ -23,6 +24,10 @@ pub use rename::{
 };
 pub use title_sync::{sync_title_on_open, SyncAction};
 pub use trash::{batch_delete_notes, delete_note, empty_trash, is_file_trashed, purge_trash};
+pub use views::{
+    delete_view, evaluate_view, save_view, scan_views, FilterCondition, FilterGroup, FilterNode,
+    FilterOp, ViewDefinition, ViewFile,
+};
 
 use file::read_file_metadata;
 use frontmatter::{extract_fm_and_rels, resolve_is_a};
@@ -35,7 +40,11 @@ use std::path::Path;
 use walkdir::WalkDir;
 
 /// Parse a single markdown file into a VaultEntry.
-pub fn parse_md_file(path: &Path) -> Result<VaultEntry, String> {
+///
+/// If `git_dates` is provided, those timestamps override filesystem metadata
+/// for `modified_at` and `created_at`. Pass `None` to use filesystem dates
+/// (appropriate for newly-saved files not yet committed, or non-git vaults).
+pub fn parse_md_file(path: &Path, git_dates: Option<(u64, u64)>) -> Result<VaultEntry, String> {
     let content = fs::read_to_string(path)
         .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;
     let filename = path
@@ -51,7 +60,11 @@ pub fn parse_md_file(path: &Path) -> Result<VaultEntry, String> {
     let snippet = extract_snippet(&content);
     let word_count = count_body_words(&content);
     let outgoing_links = extract_outgoing_links(&parsed.content);
-    let (modified_at, created_at, file_size) = read_file_metadata(path)?;
+    let (fs_modified, fs_created, file_size) = read_file_metadata(path)?;
+    let (modified_at, created_at) = match git_dates {
+        Some((git_mod, git_create)) => (Some(git_mod), Some(git_create)),
+        None => (fs_modified, fs_created),
+    };
     let is_a = resolve_is_a(frontmatter.is_a);
 
     // Add "Type" relationship: isA becomes a navigable link to the type document.
@@ -102,18 +115,55 @@ pub fn parse_md_file(path: &Path) -> Result<VaultEntry, String> {
         sort: frontmatter.sort.and_then(|v| v.into_scalar()),
         view: frontmatter.view.and_then(|v| v.into_scalar()),
         visible: frontmatter.visible,
+        favorite: frontmatter.favorite.unwrap_or(false),
+        favorite_index: frontmatter.favorite_index,
         word_count,
         outgoing_links,
         properties,
+        file_kind: "markdown".to_string(),
+    })
+}
+
+/// Parse a non-markdown file into a minimal VaultEntry.
+/// Uses filename as title, no frontmatter extraction.
+pub(crate) fn parse_non_md_file(
+    path: &Path,
+    git_dates: Option<(u64, u64)>,
+) -> Result<VaultEntry, String> {
+    let filename = path
+        .file_name()
+        .map(|f| f.to_string_lossy().to_string())
+        .unwrap_or_default();
+    let (fs_modified, fs_created, file_size) = read_file_metadata(path)?;
+    let (modified_at, created_at) = match git_dates {
+        Some((git_mod, git_create)) => (Some(git_mod), Some(git_create)),
+        None => (fs_modified, fs_created),
+    };
+    let file_kind = classify_file_kind(path).to_string();
+
+    Ok(VaultEntry {
+        path: path.to_string_lossy().to_string(),
+        filename: filename.clone(),
+        title: filename,
+        file_kind,
+        modified_at,
+        created_at,
+        file_size,
+        ..VaultEntry::default()
     })
 }
 
 /// Re-read a single file from disk and return a fresh VaultEntry.
+/// Uses filesystem dates (no git lookup) since the file was likely just saved.
 pub fn reload_entry(path: &Path) -> Result<VaultEntry, String> {
     if !path.exists() {
         return Err(format!("File does not exist: {}", path.display()));
     }
-    parse_md_file(path)
+    if is_md_file(path) {
+        parse_md_file(path, None)
+    } else {
+        parse_non_md_file(path, None)
+    }
 }
 
 /// Directories that are never shown in the folder tree or scanned for notes.
@@ -123,20 +173,159 @@ fn is_hidden_dir(name: &str) -> bool {
     name.starts_with('.') || HIDDEN_DIRS.contains(&name)
 }
 
-fn is_md_file(path: &Path) -> bool {
+pub(crate) fn is_md_file(path: &Path) -> bool {
     path.is_file() && path.extension().is_some_and(|ext| ext == "md")
 }
 
-fn try_parse_md(path: &Path, entries: &mut Vec<VaultEntry>) {
-    match parse_md_file(path) {
+/// Extensions recognized as editable text files (opened in raw editor).
+const TEXT_EXTENSIONS: &[&str] = &[
+    "yml",
+    "yaml",
+    "json",
+    "txt",
+    "toml",
+    "csv",
+    "xml",
+    "html",
+    "htm",
+    "css",
+    "scss",
+    "less",
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "py",
+    "rs",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "rb",
+    "go",
+    "java",
+    "kt",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "swift",
+    "lua",
+    "sql",
+    "graphql",
+    "env",
+    "ini",
+    "cfg",
+    "conf",
+    "properties",
+    "makefile",
+    "dockerfile",
+    "gitignore",
+    "editorconfig",
+    "mdx",
+    "svelte",
+    "vue",
+    "astro",
+    "tf",
+    "hcl",
+    "nix",
+    "zig",
+    "hs",
+    "ml",
+    "ex",
+    "exs",
+    "erl",
+    "clj",
+    "lisp",
+    "el",
+    "vim",
+    "r",
+    "jl",
+    "ps1",
+    "bat",
+    "cmd",
+];
+
+/// Classify a file extension into "markdown", "text", or "binary".
+pub(crate) fn classify_file_kind(path: &Path) -> &'static str {
+    let ext = match path.extension() {
+        Some(e) => e.to_string_lossy().to_lowercase(),
+        None => {
+            // Files without extension: check if name itself is a known text file
+            let name = path
+                .file_name()
+                .map(|n| n.to_string_lossy().to_lowercase())
+                .unwrap_or_default();
+            return if [
+                "makefile",
+                "dockerfile",
+                "rakefile",
+                "gemfile",
+                "procfile",
+                "brewfile",
+                ".gitignore",
+                ".gitattributes",
+                ".editorconfig",
+                ".env",
+            ]
+            .contains(&name.as_str())
+            {
+                "text"
+            } else {
+                "binary"
+            };
+        }
+    };
+    if ext == "md" || ext == "markdown" {
+        "markdown"
+    } else if TEXT_EXTENSIONS.contains(&ext.as_str()) {
+        "text"
+    } else {
+        "binary"
+    }
+}
+
+use crate::git::GitDates;
+use std::collections::HashMap;
+
+fn lookup_git_dates(
+    path: &Path,
+    vault_path: &Path,
+    git_dates: &HashMap<String, GitDates>,
+) -> Option<(u64, u64)> {
+    let rel = path
+        .strip_prefix(vault_path)
+        .ok()?
+        .to_string_lossy()
+        .to_string();
+    git_dates.get(&rel).map(|d| (d.modified_at, d.created_at))
+}
+
+fn try_parse_file(
+    path: &Path,
+    vault_path: &Path,
+    git_dates: &HashMap<String, GitDates>,
+    entries: &mut Vec<VaultEntry>,
+) {
+    let dates = lookup_git_dates(path, vault_path, git_dates);
+    let result = if is_md_file(path) {
+        parse_md_file(path, dates)
+    } else {
+        parse_non_md_file(path, dates)
+    };
+    match result {
         Ok(vault_entry) => entries.push(vault_entry),
         Err(e) => log::warn!("Skipping file: {}", e),
     }
 }
 
-/// Scan all .md files in the vault, including subdirectories.
+/// Scan all files in the vault, including subdirectories.
 /// Hidden directories (starting with `.`) are excluded.
-fn scan_all_md_files(vault_path: &Path, entries: &mut Vec<VaultEntry>) {
+fn scan_all_files(
+    vault_path: &Path,
+    git_dates: &HashMap<String, GitDates>,
+    entries: &mut Vec<VaultEntry>,
+) {
     let walker = WalkDir::new(vault_path)
         .follow_links(true)
         .into_iter()
@@ -152,14 +341,23 @@ fn scan_all_md_files(vault_path: &Path, entries: &mut Vec<VaultEntry>) {
             true
         });
     for entry in walker.filter_map(|e| e.ok()) {
-        if is_md_file(entry.path()) {
-            try_parse_md(entry.path(), entries);
+        if entry.path().is_file() {
+            // Skip hidden files (starting with '.') — e.g. .gitignore, .DS_Store
+            let fname = entry.file_name().to_string_lossy();
+            if fname.starts_with('.') {
+                continue;
+            }
+            try_parse_file(entry.path(), vault_path, git_dates, entries);
         }
     }
 }
 
-/// Scan a directory recursively for .md files and return VaultEntry for each.
-pub fn scan_vault(vault_path: &Path) -> Result<Vec<VaultEntry>, String> {
+/// Scan a directory recursively for all files and return VaultEntry for each.
+/// Pass an empty map for `git_dates` to use filesystem dates only.
+pub fn scan_vault(
+    vault_path: &Path,
+    git_dates: &HashMap<String, GitDates>,
+) -> Result<Vec<VaultEntry>, String> {
     if !vault_path.exists() {
         return Err(format!(
             "Vault path does not exist: {}",
@@ -174,7 +372,7 @@ pub fn scan_vault(vault_path: &Path) -> Result<Vec<VaultEntry>, String> {
     }
 
     let mut entries = Vec::new();
-    scan_all_md_files(vault_path, &mut entries);
+    scan_all_files(vault_path, git_dates, &mut entries);
 
     entries.sort_by(|a, b| b.modified_at.cmp(&a.modified_at));
     Ok(entries)

src-tauri/src/vault/mod_tests.rs

@@ -15,7 +15,7 @@ fn create_test_file(dir: &Path, name: &str, content: &str) {
 
 fn parse_test_entry(dir: &TempDir, name: &str, content: &str) -> VaultEntry {
     create_test_file(dir.path(), name, content);
-    parse_md_file(&dir.path().join(name)).unwrap()
+    parse_md_file(&dir.path().join(name), None).unwrap()
 }
 
 #[test]
@@ -108,7 +108,7 @@ fn test_parse_no_frontmatter() {
     let content = "# A Note Without Frontmatter\n\nJust markdown.";
     create_test_file(dir.path(), "a-note-without-frontmatter.md", content);
 
-    let entry = parse_md_file(&dir.path().join("a-note-without-frontmatter.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("a-note-without-frontmatter.md"), None).unwrap();
     // No title in frontmatter → derived from filename
     assert_eq!(entry.title, "A Note Without Frontmatter");
 }
@@ -119,7 +119,7 @@ fn test_parse_single_string_aliases() {
     let content = "---\naliases: SingleAlias\n---\n# Test\n";
     create_test_file(dir.path(), "single-alias.md", content);
 
-    let entry = parse_md_file(&dir.path().join("single-alias.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("single-alias.md"), None).unwrap();
     assert_eq!(entry.aliases, vec!["SingleAlias"]);
 }
 
@@ -133,15 +133,27 @@ fn test_scan_vault_root_and_protected_folders() {
         "---\ntype: Type\n---\n# Project\n",
     );
     create_test_file(dir.path(), "attachments/notes.md", "# Attachment note\n");
-    create_test_file(dir.path(), "not-markdown.txt", "This should be ignored");
+    create_test_file(
+        dir.path(),
+        "not-markdown.txt",
+        "This should be included as text",
+    );
 
-    let entries = scan_vault(dir.path()).unwrap();
-    assert_eq!(entries.len(), 3);
+    let entries = scan_vault(dir.path(), &HashMap::new()).unwrap();
+    assert_eq!(entries.len(), 4);
 
     let filenames: Vec<&str> = entries.iter().map(|e| e.filename.as_str()).collect();
     assert!(filenames.contains(&"root.md"));
     assert!(filenames.contains(&"project.md"));
     assert!(filenames.contains(&"notes.md"));
+    assert!(filenames.contains(&"not-markdown.txt"));
+
+    let txt_entry = entries
+        .iter()
+        .find(|e| e.filename == "not-markdown.txt")
+        .unwrap();
+    assert_eq!(txt_entry.file_kind, "text");
+    assert_eq!(txt_entry.title, "not-markdown.txt");
 }
 
 #[test]
@@ -159,7 +171,7 @@ fn test_scan_vault_includes_subdirectory_notes() {
         "---\ntype: Project\n---\n# Old\n",
     );
 
-    let entries = scan_vault(dir.path()).unwrap();
+    let entries = scan_vault(dir.path(), &HashMap::new()).unwrap();
     assert_eq!(
         entries.len(),
         3,
@@ -178,7 +190,7 @@ fn test_scan_vault_includes_all_protected_folders() {
     create_test_file(dir.path(), "attachments/notes.md", "# Attachment note\n");
     create_test_file(dir.path(), "assets/image.md", "# Asset\n");
 
-    let entries = scan_vault(dir.path()).unwrap();
+    let entries = scan_vault(dir.path(), &HashMap::new()).unwrap();
     assert_eq!(entries.len(), 3);
 }
 
@@ -189,14 +201,17 @@ fn test_scan_vault_skips_hidden_folders() {
     create_test_file(dir.path(), ".laputa/cache.md", "# Cache\n");
     create_test_file(dir.path(), ".git/objects.md", "# Git\n");
 
-    let entries = scan_vault(dir.path()).unwrap();
+    let entries = scan_vault(dir.path(), &HashMap::new()).unwrap();
     assert_eq!(entries.len(), 1);
     assert_eq!(entries[0].filename, "root.md");
 }
 
 #[test]
 fn test_scan_vault_nonexistent_path() {
-    let result = scan_vault(Path::new("/nonexistent/path/that/does/not/exist"));
+    let result = scan_vault(
+        Path::new("/nonexistent/path/that/does/not/exist"),
+        &HashMap::new(),
+    );
     assert!(result.is_err());
 }
 
@@ -207,7 +222,7 @@ fn test_parse_malformed_yaml() {
     let content = "---\nIs A: [unclosed bracket\n---\n# Malformed\n";
     create_test_file(dir.path(), "malformed.md", content);
 
-    let entry = parse_md_file(&dir.path().join("malformed.md"));
+    let entry = parse_md_file(&dir.path().join("malformed.md"), None);
     // Should still succeed — gray_matter may parse partially or skip
     assert!(entry.is_ok());
 }
@@ -236,7 +251,7 @@ fn test_parse_md_file_has_snippet() {
     let content = "---\nIs A: Note\n---\n# Test Note\n\nHello, world! This is a snippet.";
     create_test_file(dir.path(), "test.md", content);
 
-    let entry = parse_md_file(&dir.path().join("test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("test.md"), None).unwrap();
     assert_eq!(entry.snippet, "Hello, world! This is a snippet.");
 }
 
@@ -247,7 +262,7 @@ fn test_parse_md_file_has_word_count() {
         "---\nIs A: Note\n---\n# Test Note\n\nHello world. This is a test with seven words.";
     create_test_file(dir.path(), "test.md", content);
 
-    let entry = parse_md_file(&dir.path().join("test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("test.md"), None).unwrap();
     assert_eq!(entry.word_count, 9);
 }
 
@@ -257,7 +272,7 @@ fn test_parse_md_file_word_count_empty_body() {
     let content = "---\nIs A: Note\n---\n# Empty Note\n";
     create_test_file(dir.path(), "test.md", content);
 
-    let entry = parse_md_file(&dir.path().join("test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("test.md"), None).unwrap();
     assert_eq!(entry.word_count, 0);
 }
 
@@ -278,7 +293,7 @@ Status: Active
 "#;
     create_test_file(dir.path(), "publish-essays.md", content);
 
-    let entry = parse_md_file(&dir.path().join("publish-essays.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("publish-essays.md"), None).unwrap();
     assert_eq!(entry.relationships.len(), 3); // Has, Topics, Type
     assert_eq!(
         entry.relationships.get("Has").unwrap(),
@@ -310,7 +325,7 @@ Belongs to:
 "#;
     create_test_file(dir.path(), "some-project.md", content);
 
-    let entry = parse_md_file(&dir.path().join("some-project.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("some-project.md"), None).unwrap();
 
     // Owner with wikilink should appear in relationships
     assert!(entry.relationships.get("Owner").is_some());
@@ -342,7 +357,7 @@ Custom Field: just a plain string
 "#;
     create_test_file(dir.path(), "plain-note.md", content);
 
-    let entry = parse_md_file(&dir.path().join("plain-note.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("plain-note.md"), None).unwrap();
     // Tags and Custom Field don't contain wikilinks — only the auto-generated "Type" relationship
     assert_eq!(entry.relationships.len(), 1);
     assert_eq!(
@@ -404,7 +419,7 @@ Context: "[[area/research]]"
 "#;
     create_test_file(dir.path(), "single-vs-array.md", content);
 
-    let entry = parse_md_file(&dir.path().join("single-vs-array.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("single-vs-array.md"), None).unwrap();
 
     // Single string → Vec with one element
     assert_eq!(
@@ -481,7 +496,7 @@ References:
 "#;
     create_test_file(dir.path(), "mixed-array.md", content);
 
-    let entry = parse_md_file(&dir.path().join("mixed-array.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("mixed-array.md"), None).unwrap();
 
     // Only the wikilink entries should be captured
     assert_eq!(
@@ -545,7 +560,7 @@ 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 entry = parse_md_file(&dir.path().join("no-code.md"), None).unwrap();
 
     let notes = entry
         .relationships
@@ -572,7 +587,7 @@ title: No Code
 fn test_type_from_frontmatter_only() {
     let dir = TempDir::new().unwrap();
     create_test_file(dir.path(), "test.md", "---\ntype: Custom\n---\n# Test\n");
-    let entry = parse_md_file(&dir.path().join("test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("test.md"), None).unwrap();
     assert_eq!(entry.is_a, Some("Custom".to_string()));
 }
 
@@ -580,7 +595,7 @@ fn test_type_from_frontmatter_only() {
 fn test_no_type_when_frontmatter_missing() {
     let dir = TempDir::new().unwrap();
     create_test_file(dir.path(), "note/test.md", "# Test\n");
-    let entry = parse_md_file(&dir.path().join("note/test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("note/test.md"), None).unwrap();
     assert_eq!(entry.is_a, None, "type should not be inferred from folder");
 }
 
@@ -592,7 +607,7 @@ fn test_created_at_from_filesystem() {
     let content = "---\nIs A: Note\n---\n# Test\n";
     create_test_file(dir.path(), "test.md", content);
 
-    let entry = parse_md_file(&dir.path().join("test.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("test.md"), None).unwrap();
     // created_at should be set from filesystem metadata (not None)
     assert!(
         entry.created_at.is_some(),
@@ -1077,6 +1092,54 @@ fn test_parse_trashed_no() {
     assert!(!entry.trashed, "'Trashed: No' must be parsed as false");
 }
 
+// --- new canonical underscore-prefixed keys ---
+
+#[test]
+fn test_parse_underscore_trashed_canonical() {
+    let dir = TempDir::new().unwrap();
+    let content = "---\n_trashed: true\n_trashed_at: \"2026-03-15\"\n---\n# Gone\n";
+    let entry = parse_test_entry(&dir, "gone-new.md", content);
+    assert!(entry.trashed, "'_trashed: true' must be parsed as trashed");
+    assert!(
+        entry.trashed_at.is_some(),
+        "'_trashed_at' must be parsed as trashed_at"
+    );
+}
+
+#[test]
+fn test_parse_underscore_archived_canonical() {
+    let dir = TempDir::new().unwrap();
+    let content = "---\n_archived: true\n---\n# Old\n";
+    let entry = parse_test_entry(&dir, "old-new.md", content);
+    assert!(
+        entry.archived,
+        "'_archived: true' must be parsed as archived"
+    );
+}
+
+// --- favorite field tests ---
+
+#[test]
+fn test_parse_favorite_true() {
+    let dir = TempDir::new().unwrap();
+    let content = "---\n_favorite: true\n_favorite_index: 3\n---\n# Fav\n";
+    let entry = parse_test_entry(&dir, "fav.md", content);
+    assert!(
+        entry.favorite,
+        "'_favorite: true' must be parsed as favorite"
+    );
+    assert_eq!(entry.favorite_index, Some(3));
+}
+
+#[test]
+fn test_parse_favorite_absent_defaults_false() {
+    let dir = TempDir::new().unwrap();
+    let content = "---\ntype: Note\n---\n# Not Fav\n";
+    let entry = parse_test_entry(&dir, "not-fav.md", content);
+    assert!(!entry.favorite, "absent _favorite must default to false");
+    assert_eq!(entry.favorite_index, None);
+}
+
 // --- visible field tests ---
 
 #[test]
@@ -1168,7 +1231,7 @@ fn test_parse_real_engineering_management_file() {
     if !path.exists() {
         return; // Skip when the Laputa vault is not available
     }
-    let entry = parse_md_file(path).unwrap();
+    let entry = parse_md_file(path, None).unwrap();
     assert!(
         entry.trashed,
         "engineering-management.md must be trashed (has Trashed: true in frontmatter)"
@@ -1204,7 +1267,7 @@ fn test_fallback_parser_extracts_trashed_from_malformed_yaml() {
     ];
     let content = fm.join("\n");
     create_test_file(dir.path(), "eng-mgmt.md", &content);
-    let entry = parse_md_file(&dir.path().join("eng-mgmt.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("eng-mgmt.md"), None).unwrap();
     assert!(
         entry.trashed,
         "Trashed must be true even when YAML is malformed (fallback parser)"
@@ -1231,7 +1294,7 @@ fn test_fallback_parser_extracts_archived_from_malformed_yaml() {
     ];
     let content = fm.join("\n");
     create_test_file(dir.path(), "archived-essay.md", &content);
-    let entry = parse_md_file(&dir.path().join("archived-essay.md")).unwrap();
+    let entry = parse_md_file(&dir.path().join("archived-essay.md"), None).unwrap();
     assert!(
         entry.archived,
         "Archived must be true even when YAML is malformed"

src-tauri/src/vault/trash.rs

@@ -14,7 +14,10 @@ fn extract_trashed_at_string(data: &Option<gray_matter::Pod>) -> Option<String>
     let gray_matter::Pod::Hash(ref map) = data.as_ref()? else {
         return None;
     };
-    let pod = map.get("Trashed at").or_else(|| map.get("trashed_at"))?;
+    let pod = map
+        .get("_trashed_at")
+        .or_else(|| map.get("Trashed at"))
+        .or_else(|| map.get("trashed_at"))?;
     match pod {
         gray_matter::Pod::String(s) => Some(s.clone()),
         _ => None,
@@ -74,7 +77,11 @@ pub fn is_file_trashed(path: &Path) -> bool {
 
     // Check for "Trashed: true"
     if let Some(gray_matter::Pod::Hash(ref map)) = parsed.data {
-        if let Some(pod) = map.get("Trashed").or_else(|| map.get("trashed")) {
+        if let Some(pod) = map
+            .get("_trashed")
+            .or_else(|| map.get("Trashed"))
+            .or_else(|| map.get("trashed"))
+        {
             return match pod {
                 gray_matter::Pod::Boolean(b) => *b,
                 gray_matter::Pod::String(s) => {
@@ -373,6 +380,28 @@ mod tests {
         assert!(!is_file_trashed(Path::new("/nonexistent/path.md")));
     }
 
+    #[test]
+    fn test_is_file_trashed_with_underscore_trashed() {
+        let dir = TempDir::new().unwrap();
+        create_test_file(
+            dir.path(),
+            "trashed.md",
+            "---\n_trashed: true\n---\n# Gone\n",
+        );
+        assert!(is_file_trashed(&dir.path().join("trashed.md")));
+    }
+
+    #[test]
+    fn test_is_file_trashed_with_underscore_trashed_at() {
+        let dir = TempDir::new().unwrap();
+        create_test_file(
+            dir.path(),
+            "trashed.md",
+            "---\n_trashed_at: \"2026-03-15\"\n---\n# Gone\n",
+        );
+        assert!(is_file_trashed(&dir.path().join("trashed.md")));
+    }
+
     #[test]
     fn test_is_file_trashed_with_trashed_false() {
         let dir = TempDir::new().unwrap();

src-tauri/src/vault/views.rs

@@ -0,0 +1,674 @@
+use serde::de::{self, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::fmt;
+use std::fs;
+use std::path::Path;
+
+use super::VaultEntry;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ViewDefinition {
+    pub name: String,
+    #[serde(default)]
+    pub icon: Option<String>,
+    #[serde(default)]
+    pub color: Option<String>,
+    #[serde(default)]
+    pub sort: Option<String>,
+    pub filters: FilterGroup,
+}
+
+#[derive(Debug, Clone)]
+pub enum FilterGroup {
+    All(Vec<FilterNode>),
+    Any(Vec<FilterNode>),
+}
+
+impl Serialize for FilterGroup {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(Some(1))?;
+        match self {
+            FilterGroup::All(nodes) => map.serialize_entry("all", nodes)?,
+            FilterGroup::Any(nodes) => map.serialize_entry("any", nodes)?,
+        }
+        map.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for FilterGroup {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        struct FilterGroupVisitor;
+
+        impl<'de> Visitor<'de> for FilterGroupVisitor {
+            type Value = FilterGroup;
+
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("a map with key 'all' or 'any'")
+            }
+
+            fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<FilterGroup, M::Error> {
+                let key: String = map
+                    .next_key()?
+                    .ok_or_else(|| de::Error::custom("expected 'all' or 'any' key"))?;
+                match key.as_str() {
+                    "all" => {
+                        let nodes: Vec<FilterNode> = map.next_value()?;
+                        Ok(FilterGroup::All(nodes))
+                    }
+                    "any" => {
+                        let nodes: Vec<FilterNode> = map.next_value()?;
+                        Ok(FilterGroup::Any(nodes))
+                    }
+                    other => Err(de::Error::unknown_field(other, &["all", "any"])),
+                }
+            }
+        }
+
+        deserializer.deserialize_map(FilterGroupVisitor)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum FilterNode {
+    Condition(FilterCondition),
+    Group(FilterGroup),
+}
+
+impl Serialize for FilterNode {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            FilterNode::Condition(c) => c.serialize(serializer),
+            FilterNode::Group(g) => g.serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FilterNode {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        // Deserialize into a generic YAML value, then try group first, then condition
+        let value = serde_yaml::Value::deserialize(deserializer)?;
+        if let serde_yaml::Value::Mapping(ref m) = value {
+            // If the map has an "all" or "any" key, it's a group
+            let all_key = serde_yaml::Value::String("all".to_string());
+            let any_key = serde_yaml::Value::String("any".to_string());
+            if m.contains_key(&all_key) || m.contains_key(&any_key) {
+                let group: FilterGroup =
+                    serde_yaml::from_value(value).map_err(de::Error::custom)?;
+                return Ok(FilterNode::Group(group));
+            }
+        }
+        let cond: FilterCondition = serde_yaml::from_value(value).map_err(de::Error::custom)?;
+        Ok(FilterNode::Condition(cond))
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct FilterCondition {
+    pub field: String,
+    pub op: FilterOp,
+    #[serde(default)]
+    pub value: Option<serde_yaml::Value>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub enum FilterOp {
+    #[serde(rename = "equals")]
+    Equals,
+    #[serde(rename = "not_equals")]
+    NotEquals,
+    #[serde(rename = "contains")]
+    Contains,
+    #[serde(rename = "not_contains")]
+    NotContains,
+    #[serde(rename = "any_of")]
+    AnyOf,
+    #[serde(rename = "none_of")]
+    NoneOf,
+    #[serde(rename = "is_empty")]
+    IsEmpty,
+    #[serde(rename = "is_not_empty")]
+    IsNotEmpty,
+    #[serde(rename = "before")]
+    Before,
+    #[serde(rename = "after")]
+    After,
+}
+
+/// A view file on disk: filename + parsed definition.
+#[derive(Debug, Serialize, Clone)]
+pub struct ViewFile {
+    pub filename: String,
+    pub definition: ViewDefinition,
+}
+
+/// Scan all `.yml` files from `vault_path/.laputa/views/` and return parsed views.
+pub fn scan_views(vault_path: &Path) -> Vec<ViewFile> {
+    let views_dir = vault_path.join(".laputa").join("views");
+    if !views_dir.is_dir() {
+        return Vec::new();
+    }
+
+    let mut views = Vec::new();
+    let entries = match fs::read_dir(&views_dir) {
+        Ok(e) => e,
+        Err(e) => {
+            log::warn!("Failed to read views directory: {}", e);
+            return Vec::new();
+        }
+    };
+
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("yml") {
+            continue;
+        }
+        let filename = entry.file_name().to_string_lossy().to_string();
+        match fs::read_to_string(&path) {
+            Ok(content) => match serde_yaml::from_str::<ViewDefinition>(&content) {
+                Ok(definition) => views.push(ViewFile {
+                    filename,
+                    definition,
+                }),
+                Err(e) => log::warn!("Failed to parse view {}: {}", filename, e),
+            },
+            Err(e) => log::warn!("Failed to read view file {}: {}", filename, e),
+        }
+    }
+
+    views.sort_by(|a, b| a.filename.cmp(&b.filename));
+    views
+}
+
+/// Save a view definition as YAML to `vault_path/.laputa/views/{filename}`.
+pub fn save_view(
+    vault_path: &Path,
+    filename: &str,
+    definition: &ViewDefinition,
+) -> Result<(), String> {
+    if !filename.ends_with(".yml") {
+        return Err("Filename must end with .yml".to_string());
+    }
+    let views_dir = vault_path.join(".laputa").join("views");
+    fs::create_dir_all(&views_dir)
+        .map_err(|e| format!("Failed to create views directory: {}", e))?;
+    let yaml = serde_yaml::to_string(definition)
+        .map_err(|e| format!("Failed to serialize view: {}", e))?;
+    fs::write(views_dir.join(filename), yaml)
+        .map_err(|e| format!("Failed to write view file: {}", e))
+}
+
+/// Delete a view file at `vault_path/.laputa/views/{filename}`.
+pub fn delete_view(vault_path: &Path, filename: &str) -> Result<(), String> {
+    let path = vault_path.join(".laputa").join("views").join(filename);
+    fs::remove_file(&path).map_err(|e| format!("Failed to delete view: {}", e))
+}
+
+/// Evaluate a view definition against vault entries, returning indices of matching entries.
+pub fn evaluate_view(definition: &ViewDefinition, entries: &[VaultEntry]) -> Vec<usize> {
+    entries
+        .iter()
+        .enumerate()
+        .filter(|(_, entry)| evaluate_group(&definition.filters, entry))
+        .map(|(i, _)| i)
+        .collect()
+}
+
+fn evaluate_group(group: &FilterGroup, entry: &VaultEntry) -> bool {
+    match group {
+        FilterGroup::All(nodes) => nodes.iter().all(|n| evaluate_node(n, entry)),
+        FilterGroup::Any(nodes) => nodes.iter().any(|n| evaluate_node(n, entry)),
+    }
+}
+
+fn evaluate_node(node: &FilterNode, entry: &VaultEntry) -> bool {
+    match node {
+        FilterNode::Condition(cond) => evaluate_condition(cond, entry),
+        FilterNode::Group(group) => evaluate_group(group, entry),
+    }
+}
+
+/// Extract the stem from a wikilink: `[[target|Alias]]` -> `target`, `[[target]]` -> `target`.
+fn wikilink_stem(link: &str) -> &str {
+    let s = link
+        .strip_prefix("[[")
+        .unwrap_or(link)
+        .strip_suffix("]]")
+        .unwrap_or(link);
+    match s.split_once('|') {
+        Some((stem, _)) => stem,
+        None => s,
+    }
+}
+
+fn evaluate_condition(cond: &FilterCondition, entry: &VaultEntry) -> bool {
+    let field = cond.field.as_str();
+
+    // Boolean fields
+    match field {
+        "archived" => return evaluate_bool_field(entry.archived, &cond.op, &cond.value),
+        "trashed" => return evaluate_bool_field(entry.trashed, &cond.op, &cond.value),
+        "favorite" => return evaluate_bool_field(entry.favorite, &cond.op, &cond.value),
+        _ => {}
+    }
+
+    // String/option fields
+    let field_value: Option<String> = match field {
+        "type" | "isA" => entry.is_a.clone(),
+        "status" => entry.status.clone(),
+        "title" => Some(entry.title.clone()),
+        _ => {
+            // Check properties first, then relationships
+            if let Some(prop) = entry.properties.get(field) {
+                match prop {
+                    serde_json::Value::String(s) => Some(s.clone()),
+                    serde_json::Value::Number(n) => Some(n.to_string()),
+                    serde_json::Value::Bool(b) => Some(b.to_string()),
+                    _ => None,
+                }
+            } else if let Some(rels) = entry.relationships.get(field) {
+                // For relationship fields, handle specially in contains/any_of etc.
+                return evaluate_relationship_op(&cond.op, rels, &cond.value);
+            } else {
+                None
+            }
+        }
+    };
+
+    let cond_value = cond.value.as_ref().and_then(yaml_value_to_string);
+
+    match cond.op {
+        FilterOp::Equals => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => f.eq_ignore_ascii_case(v),
+            (None, None) => true,
+            _ => false,
+        },
+        FilterOp::NotEquals => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => !f.eq_ignore_ascii_case(v),
+            (None, None) => false,
+            _ => true,
+        },
+        FilterOp::Contains => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => f.to_lowercase().contains(&v.to_lowercase()),
+            _ => false,
+        },
+        FilterOp::NotContains => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => !f.to_lowercase().contains(&v.to_lowercase()),
+            (None, _) => true,
+            _ => true,
+        },
+        FilterOp::AnyOf => {
+            let values = cond
+                .value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            match &field_value {
+                Some(f) => values.iter().any(|v| f.eq_ignore_ascii_case(v)),
+                None => false,
+            }
+        }
+        FilterOp::NoneOf => {
+            let values = cond
+                .value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            match &field_value {
+                Some(f) => !values.iter().any(|v| f.eq_ignore_ascii_case(v)),
+                None => true,
+            }
+        }
+        FilterOp::IsEmpty => field_value.as_deref().map_or(true, |s| s.is_empty()),
+        FilterOp::IsNotEmpty => field_value.as_deref().is_some_and(|s| !s.is_empty()),
+        FilterOp::Before => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => f < v,
+            _ => false,
+        },
+        FilterOp::After => match (&field_value, &cond_value) {
+            (Some(f), Some(v)) => f > v,
+            _ => false,
+        },
+    }
+}
+
+fn evaluate_bool_field(field_val: bool, op: &FilterOp, value: &Option<serde_yaml::Value>) -> bool {
+    match op {
+        FilterOp::Equals => {
+            let expected = value.as_ref().and_then(|v| v.as_bool()).unwrap_or(true);
+            field_val == expected
+        }
+        FilterOp::NotEquals => {
+            let expected = value.as_ref().and_then(|v| v.as_bool()).unwrap_or(true);
+            field_val != expected
+        }
+        FilterOp::IsEmpty => !field_val,
+        FilterOp::IsNotEmpty => field_val,
+        _ => false,
+    }
+}
+
+fn evaluate_relationship_op(
+    op: &FilterOp,
+    rels: &[String],
+    value: &Option<serde_yaml::Value>,
+) -> bool {
+    match op {
+        FilterOp::Contains => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    let t_stem = wikilink_stem(&t).to_lowercase();
+                    rels.iter()
+                        .any(|r| wikilink_stem(r).to_lowercase() == t_stem)
+                }
+                None => false,
+            }
+        }
+        FilterOp::NotContains => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    let t_stem = wikilink_stem(&t).to_lowercase();
+                    !rels
+                        .iter()
+                        .any(|r| wikilink_stem(r).to_lowercase() == t_stem)
+                }
+                None => true,
+            }
+        }
+        FilterOp::AnyOf => {
+            let values = value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            rels.iter().any(|r| {
+                let r_stem = wikilink_stem(r).to_lowercase();
+                values
+                    .iter()
+                    .any(|v| wikilink_stem(v).to_lowercase() == r_stem)
+            })
+        }
+        FilterOp::NoneOf => {
+            let values = value
+                .as_ref()
+                .and_then(yaml_value_to_string_vec)
+                .unwrap_or_default();
+            !rels.iter().any(|r| {
+                let r_stem = wikilink_stem(r).to_lowercase();
+                values
+                    .iter()
+                    .any(|v| wikilink_stem(v).to_lowercase() == r_stem)
+            })
+        }
+        FilterOp::IsEmpty => rels.is_empty(),
+        FilterOp::IsNotEmpty => !rels.is_empty(),
+        FilterOp::Equals => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    rels.len() == 1
+                        && wikilink_stem(&rels[0]).to_lowercase()
+                            == wikilink_stem(&t).to_lowercase()
+                }
+                None => rels.is_empty(),
+            }
+        }
+        FilterOp::NotEquals => {
+            let target = value.as_ref().and_then(yaml_value_to_string);
+            match target {
+                Some(t) => {
+                    rels.len() != 1
+                        || wikilink_stem(&rels[0]).to_lowercase()
+                            != wikilink_stem(&t).to_lowercase()
+                }
+                None => !rels.is_empty(),
+            }
+        }
+        _ => false,
+    }
+}
+
+fn yaml_value_to_string(v: &serde_yaml::Value) -> Option<String> {
+    match v {
+        serde_yaml::Value::String(s) => Some(s.clone()),
+        serde_yaml::Value::Number(n) => Some(n.to_string()),
+        serde_yaml::Value::Bool(b) => Some(b.to_string()),
+        _ => None,
+    }
+}
+
+fn yaml_value_to_string_vec(v: &serde_yaml::Value) -> Option<Vec<String>> {
+    v.as_sequence()
+        .map(|seq| seq.iter().filter_map(yaml_value_to_string).collect())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    fn make_entry(overrides: impl FnOnce(&mut VaultEntry)) -> VaultEntry {
+        let mut entry = VaultEntry::default();
+        overrides(&mut entry);
+        entry
+    }
+
+    #[test]
+    fn test_parse_simple_view() {
+        let yaml = r#"
+name: Active Projects
+icon: rocket
+filters:
+  all:
+    - field: type
+      op: equals
+      value: Project
+"#;
+        let def: ViewDefinition = serde_yaml::from_str(yaml).unwrap();
+        assert_eq!(def.name, "Active Projects");
+        assert_eq!(def.icon.as_deref(), Some("rocket"));
+        match &def.filters {
+            FilterGroup::All(nodes) => {
+                assert_eq!(nodes.len(), 1);
+                match &nodes[0] {
+                    FilterNode::Condition(c) => {
+                        assert_eq!(c.field, "type");
+                    }
+                    _ => panic!("Expected condition"),
+                }
+            }
+            _ => panic!("Expected All group"),
+        }
+    }
+
+    #[test]
+    fn test_evaluate_equals() {
+        let yaml = r#"
+name: Projects
+filters:
+  all:
+    - field: type
+      op: equals
+      value: Project
+"#;
+        let def: ViewDefinition = serde_yaml::from_str(yaml).unwrap();
+
+        let matching = make_entry(|e| e.is_a = Some("Project".to_string()));
+        let non_matching = make_entry(|e| e.is_a = Some("Note".to_string()));
+        let entries = vec![matching, non_matching];
+
+        let result = evaluate_view(&def, &entries);
+        assert_eq!(result, vec![0]);
+    }
+
+    #[test]
+    fn test_evaluate_contains_relationship() {
+        let yaml = r#"
+name: Related to Target
+filters:
+  all:
+    - field: Related to
+      op: contains
+      value: "[[target]]"
+"#;
+        let def: ViewDefinition = serde_yaml::from_str(yaml).unwrap();
+
+        let mut rels = HashMap::new();
+        rels.insert(
+            "Related to".to_string(),
+            vec!["[[target]]".to_string(), "[[other]]".to_string()],
+        );
+        let matching = make_entry(|e| e.relationships = rels);
+
+        let non_matching = make_entry(|_| {});
+        let entries = vec![matching, non_matching];
+
+        let result = evaluate_view(&def, &entries);
+        assert_eq!(result, vec![0]);
+    }
+
+    #[test]
+    fn test_evaluate_nested_and_or() {
+        let yaml = r#"
+name: Complex
+filters:
+  all:
+    - field: type
+      op: equals
+      value: Project
+    - any:
+        - field: status
+          op: equals
+          value: Active
+        - field: status
+          op: equals
+          value: Planning
+"#;
+        let def: ViewDefinition = serde_yaml::from_str(yaml).unwrap();
+
+        let active_project = make_entry(|e| {
+            e.is_a = Some("Project".to_string());
+            e.status = Some("Active".to_string());
+        });
+        let planning_project = make_entry(|e| {
+            e.is_a = Some("Project".to_string());
+            e.status = Some("Planning".to_string());
+        });
+        let done_project = make_entry(|e| {
+            e.is_a = Some("Project".to_string());
+            e.status = Some("Done".to_string());
+        });
+        let active_note = make_entry(|e| {
+            e.is_a = Some("Note".to_string());
+            e.status = Some("Active".to_string());
+        });
+
+        let entries = vec![active_project, planning_project, done_project, active_note];
+        let result = evaluate_view(&def, &entries);
+        assert_eq!(result, vec![0, 1]);
+    }
+
+    #[test]
+    fn test_evaluate_is_empty() {
+        let yaml_empty = r#"
+name: No Status
+filters:
+  all:
+    - field: status
+      op: is_empty
+"#;
+        let yaml_not_empty = r#"
+name: Has Status
+filters:
+  all:
+    - field: status
+      op: is_not_empty
+"#;
+        let def_empty: ViewDefinition = serde_yaml::from_str(yaml_empty).unwrap();
+        let def_not_empty: ViewDefinition = serde_yaml::from_str(yaml_not_empty).unwrap();
+
+        let with_status = make_entry(|e| e.status = Some("Active".to_string()));
+        let without_status = make_entry(|_| {});
+        let entries = vec![with_status, without_status];
+
+        assert_eq!(evaluate_view(&def_empty, &entries), vec![1]);
+        assert_eq!(evaluate_view(&def_not_empty, &entries), vec![0]);
+    }
+
+    #[test]
+    fn test_scan_views_reads_yml_files() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let views_dir = dir.path().join(".laputa").join("views");
+        fs::create_dir_all(&views_dir).unwrap();
+
+        let yaml_a = "name: Alpha\nfilters:\n  all:\n    - field: type\n      op: equals\n      value: Note\n";
+        let yaml_b = "name: Beta\nfilters:\n  any:\n    - field: status\n      op: equals\n      value: Active\n";
+        fs::write(views_dir.join("a-view.yml"), yaml_a).unwrap();
+        fs::write(views_dir.join("b-view.yml"), yaml_b).unwrap();
+        // Non-yml file should be ignored
+        fs::write(views_dir.join("readme.txt"), "ignore me").unwrap();
+
+        let views = scan_views(dir.path());
+        assert_eq!(views.len(), 2);
+        assert_eq!(views[0].filename, "a-view.yml");
+        assert_eq!(views[0].definition.name, "Alpha");
+        assert_eq!(views[1].filename, "b-view.yml");
+        assert_eq!(views[1].definition.name, "Beta");
+    }
+
+    #[test]
+    fn test_save_and_read_view() {
+        let dir = tempfile::TempDir::new().unwrap();
+
+        let def = ViewDefinition {
+            name: "Test View".to_string(),
+            icon: Some("star".to_string()),
+            color: None,
+            sort: Some("modified:desc".to_string()),
+            filters: FilterGroup::All(vec![FilterNode::Condition(FilterCondition {
+                field: "type".to_string(),
+                op: FilterOp::Equals,
+                value: Some(serde_yaml::Value::String("Project".to_string())),
+            })]),
+        };
+
+        save_view(dir.path(), "test.yml", &def).unwrap();
+
+        let views = scan_views(dir.path());
+        assert_eq!(views.len(), 1);
+        assert_eq!(views[0].definition.name, "Test View");
+        assert_eq!(views[0].definition.icon.as_deref(), Some("star"));
+
+        delete_view(dir.path(), "test.yml").unwrap();
+        let views = scan_views(dir.path());
+        assert_eq!(views.len(), 0);
+    }
+
+    #[test]
+    fn test_wikilink_stem_matching() {
+        let yaml = r#"
+name: Linked
+filters:
+  all:
+    - field: Topics
+      op: contains
+      value: "[[target]]"
+"#;
+        let def: ViewDefinition = serde_yaml::from_str(yaml).unwrap();
+
+        // Entry with aliased wikilink
+        let mut rels = HashMap::new();
+        rels.insert("Topics".to_string(), vec!["[[target|Alias]]".to_string()]);
+        let matching = make_entry(|e| e.relationships = rels);
+
+        // Entry with different target
+        let mut rels2 = HashMap::new();
+        rels2.insert("Topics".to_string(), vec!["[[other|Alias]]".to_string()]);
+        let non_matching = make_entry(|e| e.relationships = rels2);
+
+        let entries = vec![matching, non_matching];
+        let result = evaluate_view(&def, &entries);
+        assert_eq!(result, vec![0]);
+    }
+}

src/App.test.tsx

@@ -64,6 +64,7 @@ const mockAllContent: Record<string, string> = {
 const mockCommandResults: Record<string, unknown> = {
   list_vault: mockEntries,
   list_vault_folders: [],
+  list_views: [],
   get_all_content: mockAllContent,
   get_modified_files: [],
   get_note_content: mockAllContent['/vault/project/test.md'] || '',

src/App.tsx

@@ -4,6 +4,7 @@ import { NoteList } from './components/NoteList'
 import { Editor } from './components/Editor'
 import { ResizeHandle } from './components/ResizeHandle'
 import { CreateTypeDialog } from './components/CreateTypeDialog'
+import { CreateViewDialog } from './components/CreateViewDialog'
 import { QuickOpenPalette } from './components/QuickOpenPalette'
 import { CommandPalette } from './components/CommandPalette'
 import { SearchPanel } from './components/SearchPanel'
@@ -279,7 +280,7 @@ function App() {
       } else {
         await mockInvoke('create_vault_folder', { vaultPath: resolvedPath, folderName: name })
       }
-      await vault.reloadVault()
+      await vault.reloadFolders()
       setToastMessage(`Created folder "${name}"`)
     } catch (e) {
       setToastMessage(`Failed to create folder: ${e}`)
@@ -326,6 +327,51 @@ function App() {
     setToastMessage(`Type "${name}" created`)
   }, [notes])
 
+  const handleCreateView = useCallback(async (definition: import('./types').ViewDefinition) => {
+    const filename = definition.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '') + '.yml'
+    const target = isTauri() ? invoke : mockInvoke
+    await target('save_view_cmd', { vaultPath: resolvedPath, filename, definition })
+    await vault.reloadViews()
+    setToastMessage(`View "${definition.name}" created`)
+    handleSetSelection({ kind: 'view', filename })
+  }, [resolvedPath, vault, handleSetSelection])
+
+  const handleDeleteView = useCallback(async (filename: string) => {
+    const target = isTauri() ? invoke : mockInvoke
+    await target('delete_view_cmd', { vaultPath: resolvedPath, filename })
+    await vault.reloadViews()
+    if (selection.kind === 'view' && selection.filename === filename) {
+      handleSetSelection({ kind: 'filter', filter: 'all' })
+    }
+    setToastMessage('View deleted')
+  }, [resolvedPath, vault, selection, handleSetSelection])
+
+  const availableFields = useMemo(() => {
+    const builtIn = ['type', 'status', 'title', 'favorite']
+    if (!vault.entries?.length) return builtIn
+    const customFields = new Set<string>()
+    for (const e of vault.entries) {
+      if (e.properties) {
+        for (const key of Object.keys(e.properties)) customFields.add(key)
+      }
+      if (e.relationships) {
+        for (const key of Object.keys(e.relationships)) customFields.add(key)
+      }
+    }
+    return [...builtIn, ...Array.from(customFields).sort()]
+  }, [vault.entries])
+
+  const valueSuggestionsForField = useCallback((field: string): string[] => {
+    if (!vault.entries?.length) return []
+    const values = new Set<string>()
+    for (const e of vault.entries) {
+      if (field === 'type' && e.isA) values.add(e.isA)
+      else if (field === 'status' && e.status) values.add(e.status)
+      else if (e.properties?.[field] != null) values.add(String(e.properties[field]))
+    }
+    return Array.from(values).sort()
+  }, [vault.entries])
+
   const bulkActions = useBulkActions(entryActions, setToastMessage)
 
   // Raw-toggle ref: Editor registers its handleToggleRaw here so the command palette can call it
@@ -420,6 +466,7 @@ function App() {
     noteListFilter,
     onSetNoteListFilter: setNoteListFilter,
     onOpenInNewWindow: handleOpenInNewWindow,
+    onToggleFavorite: entryActions.handleToggleFavorite,
   })
 
   const activeTab = notes.tabs.find((t) => t.entry.path === notes.activeTabPath) ?? null
@@ -428,7 +475,7 @@ function App() {
 
   const aiNoteList = useMemo<NoteListItem[]>(() => {
     const isInbox = selection.kind === 'filter' && selection.filter === 'inbox'
-    const filtered = isInbox ? filterInboxEntries(vault.entries, inboxPeriod) : filterEntries(vault.entries, selection)
+    const filtered = isInbox ? filterInboxEntries(vault.entries, inboxPeriod) : filterEntries(vault.entries, selection, undefined, vault.views)
     return filtered.map(e => ({
       path: e.path, title: e.title, type: e.isA ?? 'Note',
     }))
@@ -488,7 +535,7 @@ function App() {
         {sidebarVisible && (
           <>
             <div className="app__sidebar" style={{ width: layout.sidebarWidth }}>
-              <Sidebar entries={vault.entries} folders={vault.folders} 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} onCreateFolder={handleCreateFolder} inboxCount={inboxCount} />
+              <Sidebar entries={vault.entries} folders={vault.folders} views={vault.views} selection={selection} onSelect={handleSetSelection} onSelectNote={notes.handleSelectNote} onSelectFavorite={notes.handleSelectNote} onReorderFavorites={entryActions.handleReorderFavorites} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} onRenameSection={entryActions.handleRenameSection} onToggleTypeVisibility={entryActions.handleToggleTypeVisibility} onCreateFolder={handleCreateFolder} onCreateView={dialogs.openCreateView} onDeleteView={handleDeleteView} inboxCount={inboxCount} />
             </div>
             <ResizeHandle onResize={layout.handleSidebarResize} />
           </>
@@ -499,7 +546,7 @@ function App() {
               {selection.kind === 'filter' && selection.filter === 'pulse' ? (
                 <PulseView vaultPath={resolvedPath} onOpenNote={vaultBridge.handlePulseOpenNote} sidebarCollapsed={!sidebarVisible} onExpandSidebar={() => setViewMode('all')} />
               ) : (
-                <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} />
+                <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} views={vault.views} />
               )}
             </div>
             <ResizeHandle onResize={layout.handleNoteListResize} />
@@ -532,6 +579,7 @@ function App() {
             vaultPath={resolvedPath}
             noteList={aiNoteList}
             noteListFilter={aiNoteListFilter}
+            onToggleFavorite={entryActions.handleToggleFavorite}
             onTrashNote={entryActions.handleTrashNote}
             onRestoreNote={entryActions.handleRestoreNote}
             onDeleteNote={deleteActions.handleDeleteNote}
@@ -566,6 +614,7 @@ function App() {
       <CommandPalette open={dialogs.showCommandPalette} commands={commands} onClose={dialogs.closeCommandPalette} />
       <SearchPanel open={dialogs.showSearch} vaultPath={resolvedPath} entries={vault.entries} onSelectNote={notes.handleSelectNote} onClose={dialogs.closeSearch} />
       <CreateTypeDialog open={dialogs.showCreateTypeDialog} onClose={dialogs.closeCreateType} onCreate={handleCreateType} />
+      <CreateViewDialog open={dialogs.showCreateViewDialog} onClose={dialogs.closeCreateView} onCreate={handleCreateView} availableFields={availableFields} valueSuggestions={valueSuggestionsForField} />
       <CommitDialog open={commitFlow.showCommitDialog} modifiedCount={vault.modifiedFiles.length} suggestedMessage={suggestedCommitMessage} onCommit={commitFlow.handleCommitPush} onClose={commitFlow.closeCommitDialog} />
       <ConflictResolverModal
         open={dialogs.showConflictResolver}

src/components/BreadcrumbBar.test.tsx

@@ -146,6 +146,15 @@ describe('BreadcrumbBar — title in breadcrumb (always rendered, CSS-toggled)',
   })
 })
 
+describe('BreadcrumbBar — action buttons always right-aligned', () => {
+  it('actions container has ml-auto so buttons are always right-aligned', () => {
+    const { container } = render(<BreadcrumbBar entry={baseEntry} {...defaultProps} />)
+    const actions = container.querySelector('.breadcrumb-bar__actions')
+    expect(actions).toBeInTheDocument()
+    expect(actions).toHaveClass('ml-auto')
+  })
+})
+
 describe('BreadcrumbBar — raw editor toggle', () => {
   it('shows Raw editor button with tooltip "Raw editor" when rawMode is off', () => {
     const onToggleRaw = vi.fn()

src/components/BreadcrumbBar.tsx

@@ -13,6 +13,7 @@ import {
   ArrowCounterClockwise,
   Archive,
   ArrowUUpLeft,
+  Star,
 } from '@phosphor-icons/react'
 
 interface BreadcrumbBarProps {
@@ -28,6 +29,7 @@ interface BreadcrumbBarProps {
   onToggleAIChat?: () => void
   inspectorCollapsed?: boolean
   onToggleInspector?: () => void
+  onToggleFavorite?: () => void
   onTrash?: () => void
   onRestore?: () => void
   onArchive?: () => void
@@ -56,10 +58,20 @@ function RawToggleButton({ rawMode, onToggleRaw }: { rawMode?: boolean; onToggle
 function BreadcrumbActions({ entry, showDiffToggle, diffMode, diffLoading, onToggleDiff,
   rawMode, onToggleRaw,
   showAIChat, onToggleAIChat, inspectorCollapsed, onToggleInspector,
-  onTrash, onRestore, onArchive, onUnarchive,
+  onToggleFavorite, onTrash, onRestore, onArchive, onUnarchive,
 }: Omit<BreadcrumbBarProps, 'wordCount'>) {
   return (
-    <div className="flex items-center" style={{ gap: 12 }}>
+    <div className="breadcrumb-bar__actions ml-auto flex items-center" style={{ gap: 12 }}>
+      <button
+        className={cn(
+          "flex items-center justify-center border-none bg-transparent p-0 cursor-pointer transition-colors",
+          entry.favorite ? "text-yellow-500" : "text-muted-foreground hover:text-foreground"
+        )}
+        onClick={onToggleFavorite}
+        title={entry.favorite ? 'Remove from favorites' : 'Add to favorites'}
+      >
+        <Star size={16} weight={entry.favorite ? 'fill' : 'regular'} />
+      </button>
       <button
         className="flex items-center justify-center border-none bg-transparent p-0 text-muted-foreground cursor-pointer hover:text-foreground transition-colors"
         title="Search in file"

src/components/CreateViewDialog.tsx

@@ -0,0 +1,110 @@
+import { useState, useRef, useEffect, useCallback } from 'react'
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { FilterBuilder } from './FilterBuilder'
+import { EmojiPicker } from './EmojiPicker'
+import type { FilterGroup, ViewDefinition } from '../types'
+
+interface CreateViewDialogProps {
+  open: boolean
+  onClose: () => void
+  onCreate: (definition: ViewDefinition) => void
+  availableFields: string[]
+  /** Returns known values for a given field (for autocomplete). */
+  valueSuggestions?: (field: string) => string[]
+}
+
+export function CreateViewDialog({ open, onClose, onCreate, availableFields, valueSuggestions }: CreateViewDialogProps) {
+  const [name, setName] = useState('')
+  const [icon, setIcon] = useState('')
+  const [showEmojiPicker, setShowEmojiPicker] = useState(false)
+  const [filters, setFilters] = useState<FilterGroup>({
+    all: [{ field: 'type', op: 'equals', value: '' }],
+  })
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  useEffect(() => {
+    if (open) {
+      setName('') // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
+      setIcon('') // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
+      setShowEmojiPicker(false) // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
+      setFilters({ all: [{ field: availableFields[0] ?? 'type', op: 'equals', value: '' }] }) // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
+      setTimeout(() => inputRef.current?.focus(), 50)
+    }
+  }, [open, availableFields])
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+    const trimmed = name.trim()
+    if (!trimmed) return
+    const definition: ViewDefinition = {
+      name: trimmed,
+      icon: icon || null,
+      color: null,
+      sort: null,
+      filters,
+    }
+    onCreate(definition)
+    onClose()
+  }
+
+  const handleSelectEmoji = useCallback((emoji: string) => {
+    setIcon(emoji)
+    setShowEmojiPicker(false)
+  }, [])
+
+  const handleCloseEmojiPicker = useCallback(() => {
+    setShowEmojiPicker(false)
+  }, [])
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => { if (!isOpen) onClose() }}>
+      <DialogContent showCloseButton={false} className="sm:max-w-[520px]">
+        <DialogHeader>
+          <DialogTitle>Create View</DialogTitle>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="flex gap-2">
+            <div className="w-16 space-y-1.5 relative">
+              <label className="text-xs font-medium text-muted-foreground">Icon</label>
+              <button
+                type="button"
+                className="flex h-9 w-full items-center justify-center rounded-md border border-input bg-background text-xl cursor-pointer hover:bg-accent transition-colors"
+                onClick={() => setShowEmojiPicker(!showEmojiPicker)}
+                title="Pick icon"
+              >
+                {icon || <span className="text-sm text-muted-foreground">📋</span>}
+              </button>
+              {showEmojiPicker && (
+                <EmojiPicker onSelect={handleSelectEmoji} onClose={handleCloseEmojiPicker} />
+              )}
+            </div>
+            <div className="flex-1 space-y-1.5">
+              <label className="text-xs font-medium text-muted-foreground">Name</label>
+              <Input
+                ref={inputRef}
+                placeholder="e.g. Active Projects, Reading List..."
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+              />
+            </div>
+          </div>
+          <div className="space-y-1.5">
+            <label className="text-xs font-medium text-muted-foreground">Filters</label>
+            <FilterBuilder
+              group={filters}
+              onChange={setFilters}
+              availableFields={availableFields}
+              valueSuggestions={valueSuggestions}
+            />
+          </div>
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={onClose}>Cancel</Button>
+            <Button type="submit" disabled={!name.trim()}>Create</Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}

src/components/Editor.tsx

@@ -47,6 +47,7 @@ interface EditorProps {
   vaultPath?: string
   noteList?: NoteListItem[]
   noteListFilter?: { type: string | null; query: string }
+  onToggleFavorite?: (path: string) => void
   onTrashNote?: (path: string) => void
   onRestoreNote?: (path: string) => void
   onDeleteNote?: (path: string) => void
@@ -206,7 +207,7 @@ export const Editor = memo(function Editor(props: EditorProps) {
     onUpdateFrontmatter, onDeleteProperty, onAddProperty, onCreateAndOpenNote, onInitializeProperties,
     showAIChat, onToggleAIChat,
     vaultPath, noteList, noteListFilter,
-    onTrashNote, onRestoreNote, onDeleteNote, onArchiveNote, onUnarchiveNote,
+    onToggleFavorite, onTrashNote, onRestoreNote, onDeleteNote, onArchiveNote, onUnarchiveNote,
     onContentChange, onSave, onTitleSync,
     onFileCreated, onFileModified, onVaultChanged,
     onSetNoteIcon, onRemoveNoteIcon,
@@ -252,6 +253,7 @@ export const Editor = memo(function Editor(props: EditorProps) {
               onToggleInspector={onToggleInspector}
               onNavigateWikilink={onNavigateWikilink}
               onEditorChange={handleEditorChange}
+              onToggleFavorite={onToggleFavorite}
               onTrashNote={onTrashNote}
               onRestoreNote={onRestoreNote}
               onDeleteNote={onDeleteNote}

src/components/EditorContent.tsx

@@ -41,6 +41,7 @@ interface EditorContentProps {
   onToggleInspector: () => void
   onNavigateWikilink: (target: string) => void
   onEditorChange?: () => void
+  onToggleFavorite?: (path: string) => void
   onTrashNote?: (path: string) => void
   onRestoreNote?: (path: string) => void
   onDeleteNote?: (path: string) => void
@@ -144,6 +145,7 @@ function ActiveTabBreadcrumb({ activeTab, barRef, props }: {
       onToggleAIChat={props.onToggleAIChat}
       inspectorCollapsed={props.inspectorCollapsed}
       onToggleInspector={props.onToggleInspector}
+      onToggleFavorite={bindPath(props.onToggleFavorite, path)}
       onTrash={bindPath(props.onTrashNote, path)}
       onRestore={bindPath(props.onRestoreNote, path)}
       onArchive={bindPath(props.onArchiveNote, path)}
@@ -168,7 +170,10 @@ export function EditorContent({
   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
+  // Non-markdown text files always use the raw editor (no BlockNote)
+  const isNonMarkdownText = activeTab?.entry.fileKind === 'text'
+  const effectiveRawMode = rawMode || isNonMarkdownText
+  const showEditor = !diffMode && !effectiveRawMode
   const entryIcon = activeTab?.entry.icon ?? null
   const emojiIcon = entryIcon && isEmoji(entryIcon) ? entryIcon : null
 
@@ -204,7 +209,7 @@ export function EditorContent({
         <ActiveTabBreadcrumb
           activeTab={activeTab}
           barRef={breadcrumbBarRef}
-          props={{ diffMode, diffContent, onToggleDiff, rawMode, onToggleRaw, ...breadcrumbProps }}
+          props={{ diffMode, diffContent, onToggleDiff, rawMode: effectiveRawMode, onToggleRaw, ...breadcrumbProps }}
         />
       )}
       {activeTab && isTrashed && (
@@ -223,7 +228,7 @@ export function EditorContent({
         />
       )}
       {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
-      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} latestContentRef={rawLatestContentRef} vaultPath={vaultPath} />
+      <RawModeEditorSection rawMode={effectiveRawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} latestContentRef={rawLatestContentRef} vaultPath={vaultPath} />
       {showEditor && activeTab && (
         <div className="editor-scroll-area" style={cssVars as React.CSSProperties}>
           <div ref={titleSectionRef} className="title-section">
@@ -250,6 +255,8 @@ export function EditorContent({
                 title={activeTab.entry.title}
                 filename={activeTab.entry.filename}
                 editable={!isTrashed}
+                notePath={activeTab.entry.path}
+                vaultPath={vaultPath}
                 onTitleChange={(newTitle) => onTitleChange?.(activeTab.entry.path, newTitle)}
               />
             </div>

src/components/FilterBuilder.tsx

@@ -0,0 +1,241 @@
+import { useId } from 'react'
+import { Plus, X } from '@phosphor-icons/react'
+import { Button } from '@/components/ui/button'
+import type { FilterCondition, FilterOp, FilterGroup, FilterNode } from '../types'
+
+const OPERATORS: { value: FilterOp; label: string }[] = [
+  { value: 'equals', label: 'equals' },
+  { value: 'not_equals', label: 'does not equal' },
+  { value: 'contains', label: 'contains' },
+  { value: 'not_contains', label: 'does not contain' },
+  { value: 'is_empty', label: 'is empty' },
+  { value: 'is_not_empty', label: 'is not empty' },
+  { value: 'before', label: 'before' },
+  { value: 'after', label: 'after' },
+]
+
+const NO_VALUE_OPS = new Set<FilterOp>(['is_empty', 'is_not_empty'])
+
+function isFilterGroup(node: FilterNode): node is FilterGroup {
+  return 'all' in node || 'any' in node
+}
+
+function getGroupChildren(group: FilterGroup): FilterNode[] {
+  return 'all' in group ? group.all : group.any
+}
+
+function getGroupMode(group: FilterGroup): 'all' | 'any' {
+  return 'all' in group ? 'all' : 'any'
+}
+
+function setGroupChildren(mode: 'all' | 'any', children: FilterNode[]): FilterGroup {
+  return mode === 'all' ? { all: children } : { any: children }
+}
+
+/** Combobox-style field input with datalist autocomplete. */
+function FieldInput({ value, fields, onChange }: {
+  value: string
+  fields: string[]
+  onChange: (v: string) => void
+}) {
+  const id = useId()
+  return (
+    <>
+      <input
+        list={id}
+        className="h-8 rounded-md border border-input bg-background px-2 text-sm flex-1 min-w-0"
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        placeholder="field"
+      />
+      <datalist id={id}>
+        {fields.map((f) => <option key={f} value={f} />)}
+      </datalist>
+    </>
+  )
+}
+
+/** Combobox-style value input with autocomplete for known values. */
+function ValueInput({ value, suggestions, onChange }: {
+  value: string
+  suggestions: string[]
+  onChange: (v: string) => void
+}) {
+  const id = useId()
+  return (
+    <>
+      <input
+        list={id}
+        className="h-8 rounded-md border border-input bg-background px-2 text-sm flex-1 min-w-0"
+        placeholder="value"
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+      />
+      <datalist id={id}>
+        {suggestions.map((s) => <option key={s} value={s} />)}
+      </datalist>
+    </>
+  )
+}
+
+function FilterRow({ condition, fields, valueSuggestions, onUpdate, onRemove }: {
+  condition: FilterCondition
+  fields: string[]
+  valueSuggestions: (field: string) => string[]
+  onUpdate: (c: FilterCondition) => void
+  onRemove: () => void
+}) {
+  const suggestions = valueSuggestions(condition.field)
+  return (
+    <div className="flex items-center gap-1.5">
+      <FieldInput
+        value={condition.field}
+        fields={fields}
+        onChange={(v) => onUpdate({ ...condition, field: v })}
+      />
+      <select
+        className="h-8 rounded-md border border-input bg-background px-2 text-sm shrink-0"
+        value={condition.op}
+        onChange={(e) => onUpdate({ ...condition, op: e.target.value as FilterOp })}
+      >
+        {OPERATORS.map((o) => (
+          <option key={o.value} value={o.value}>{o.label}</option>
+        ))}
+      </select>
+      {!NO_VALUE_OPS.has(condition.op) && (
+        <ValueInput
+          value={String(condition.value ?? '')}
+          suggestions={suggestions}
+          onChange={(v) => onUpdate({ ...condition, value: v })}
+        />
+      )}
+      <button
+        type="button"
+        className="flex-shrink-0 rounded p-1 text-muted-foreground hover:text-foreground"
+        onClick={onRemove}
+        title="Remove filter"
+      >
+        <X size={14} />
+      </button>
+    </div>
+  )
+}
+
+function FilterGroupView({ group, fields, valueSuggestions, depth, onChange, onRemove }: {
+  group: FilterGroup
+  fields: string[]
+  valueSuggestions: (field: string) => string[]
+  depth: number
+  onChange: (g: FilterGroup) => void
+  onRemove?: () => void
+}) {
+  const mode = getGroupMode(group)
+  const children = getGroupChildren(group)
+
+  const toggleMode = () => {
+    onChange(setGroupChildren(mode === 'all' ? 'any' : 'all', children))
+  }
+
+  const updateChild = (index: number, node: FilterNode) => {
+    const next = [...children]
+    next[index] = node
+    onChange(setGroupChildren(mode, next))
+  }
+
+  const removeChild = (index: number) => {
+    const next = children.filter((_, i) => i !== index)
+    onChange(setGroupChildren(mode, next))
+  }
+
+  const addCondition = () => {
+    onChange(setGroupChildren(mode, [...children, { field: fields[0] ?? 'type', op: 'equals' as FilterOp, value: '' }]))
+  }
+
+  const addGroup = () => {
+    const nested: FilterGroup = { all: [{ field: fields[0] ?? 'type', op: 'equals' as FilterOp, value: '' }] }
+    onChange(setGroupChildren(mode, [...children, nested]))
+  }
+
+  return (
+    <div className={depth > 0 ? 'ml-3 border-l-2 border-border pl-3 py-1' : ''}>
+      <div className="flex items-center gap-2 mb-2">
+        <button
+          type="button"
+          className="rounded-full border border-input bg-muted px-2.5 py-0.5 text-[11px] font-medium text-foreground cursor-pointer hover:bg-accent transition-colors"
+          onClick={toggleMode}
+          title={`Switch to ${mode === 'all' ? 'OR' : 'AND'}`}
+        >
+          {mode === 'all' ? 'AND' : 'OR'}
+        </button>
+        <span className="text-[11px] text-muted-foreground">
+          {mode === 'all' ? 'Match all conditions' : 'Match any condition'}
+        </span>
+        {onRemove && (
+          <button
+            type="button"
+            className="ml-auto rounded p-0.5 text-muted-foreground hover:text-foreground"
+            onClick={onRemove}
+            title="Remove group"
+          >
+            <X size={12} />
+          </button>
+        )}
+      </div>
+      <div className="space-y-2">
+        {children.map((child, i) =>
+          isFilterGroup(child) ? (
+            <FilterGroupView
+              key={i}
+              group={child}
+              fields={fields}
+              valueSuggestions={valueSuggestions}
+              depth={depth + 1}
+              onChange={(g) => updateChild(i, g)}
+              onRemove={() => removeChild(i)}
+            />
+          ) : (
+            <FilterRow
+              key={i}
+              condition={child}
+              fields={fields}
+              valueSuggestions={valueSuggestions}
+              onUpdate={(c) => updateChild(i, c)}
+              onRemove={() => removeChild(i)}
+            />
+          )
+        )}
+      </div>
+      <div className="flex gap-2 mt-2">
+        <Button type="button" variant="ghost" size="sm" className="h-7 text-xs" onClick={addCondition}>
+          <Plus size={12} className="mr-1" /> Add filter
+        </Button>
+        <Button type="button" variant="ghost" size="sm" className="h-7 text-xs" onClick={addGroup}>
+          <Plus size={12} className="mr-1" /> Add group
+        </Button>
+      </div>
+    </div>
+  )
+}
+
+export interface FilterBuilderProps {
+  group: FilterGroup
+  onChange: (group: FilterGroup) => void
+  availableFields: string[]
+  /** Returns known values for a given field (for autocomplete). */
+  valueSuggestions?: (field: string) => string[]
+}
+
+const defaultSuggestions = () => [] as string[]
+
+export function FilterBuilder({ group, onChange, availableFields, valueSuggestions }: FilterBuilderProps) {
+  const fields = availableFields.length > 0 ? availableFields : ['type']
+  return (
+    <FilterGroupView
+      group={group}
+      fields={fields}
+      valueSuggestions={valueSuggestions ?? defaultSuggestions}
+      depth={0}
+      onChange={onChange}
+    />
+  )
+}

src/components/NoteItem.tsx

@@ -4,6 +4,7 @@ import { cn } from '@/lib/utils'
 import {
   Wrench, Flask, Target, ArrowsClockwise,
   Users, CalendarBlank, Tag, FileText, StackSimple,
+  File, FileDashed,
 } from '@phosphor-icons/react'
 import { getTypeColor, getTypeLightColor } from '../utils/typeColors'
 import { resolveIcon } from '../utils/iconRegistry'
@@ -91,6 +92,12 @@ function noteItemStyle(isSelected: boolean, isMultiSelected: boolean, typeColor:
   return base
 }
 
+function getFileKindIcon(fileKind: string | undefined): ComponentType<SVGAttributes<SVGSVGElement>> {
+  if (fileKind === 'text') return File
+  if (fileKind === 'binary') return FileDashed
+  return FileText
+}
+
 export function NoteItem({ entry, isSelected, isMultiSelected = false, isHighlighted = false, noteStatus = 'clean', typeEntryMap, onClickNote, onPrefetch }: {
   entry: VaultEntry
   isSelected: boolean
@@ -101,47 +108,55 @@ export function NoteItem({ entry, isSelected, isMultiSelected = false, isHighlig
   onClickNote: (entry: VaultEntry, e: React.MouseEvent) => void
   onPrefetch?: (path: string) => void
 }) {
+  const isBinary = entry.fileKind === 'binary'
+  const isNonMarkdown = !!entry.fileKind && entry.fileKind !== 'markdown'
   const te = typeEntryMap[entry.isA ?? '']
-  const typeColor = getTypeColor(entry.isA ?? 'Note', te?.color)
+  const typeColor = isBinary ? 'var(--muted-foreground)' : getTypeColor(entry.isA ?? 'Note', te?.color)
   const typeLightColor = getTypeLightColor(entry.isA ?? 'Note', te?.color)
-  const TypeIcon = useMemo(() => getTypeIcon(entry.isA, te?.icon), [entry.isA, te?.icon])
+  const TypeIcon = useMemo(() => {
+    if (isNonMarkdown) return getFileKindIcon(entry.fileKind)
+    return getTypeIcon(entry.isA, te?.icon)
+  }, [entry.isA, te?.icon, entry.fileKind, isNonMarkdown])
+
+  const handleClick = isBinary
+    ? (e: React.MouseEvent) => { e.preventDefault(); e.stopPropagation() }
+    : (e: React.MouseEvent) => onClickNote(entry, e)
 
   return (
     <div
       className={cn(
-        "relative cursor-pointer border-b border-[var(--border)] transition-colors",
-        isSelected && !isMultiSelected && "border-l-[3px]",
-        !isSelected && !isMultiSelected && "hover:bg-muted",
-        isHighlighted && !isSelected && !isMultiSelected && "bg-muted"
+        "relative border-b border-[var(--border)] transition-colors",
+        isBinary ? "cursor-default opacity-50" : "cursor-pointer",
+        isSelected && !isMultiSelected && !isBinary && "border-l-[3px]",
+        !isSelected && !isMultiSelected && !isBinary && "hover:bg-muted",
+        isHighlighted && !isSelected && !isMultiSelected && !isBinary && "bg-muted"
       )}
-      style={noteItemStyle(isSelected, isMultiSelected, typeColor, typeLightColor)}
-      onClick={(e: React.MouseEvent) => onClickNote(entry, e)}
-      onMouseEnter={onPrefetch ? () => onPrefetch(entry.path) : undefined}
-      data-testid={isMultiSelected ? 'multi-selected-item' : undefined}
+      style={isBinary ? { padding: '14px 16px' } : noteItemStyle(isSelected, isMultiSelected, typeColor, typeLightColor)}
+      onClick={handleClick}
+      onMouseEnter={!isBinary && onPrefetch ? () => onPrefetch(entry.path) : undefined}
+      data-testid={isMultiSelected ? 'multi-selected-item' : isBinary ? 'binary-file-item' : undefined}
       data-highlighted={isHighlighted || undefined}
+      title={isBinary ? 'Cannot open this file type' : undefined}
     >
       {/* eslint-disable-next-line react-hooks/static-components -- icon lookup from static map, no internal state */}
       <TypeIcon width={14} height={14} className="absolute right-3 top-2.5" style={{ color: typeColor }} data-testid="type-icon" />
       <div className="pr-5">
-        <div className={cn("truncate text-[13px] text-foreground", isSelected ? "font-semibold" : "font-medium")}>
-          {noteStatus !== 'clean' && <StatusDot noteStatus={noteStatus} />}
+        <div className={cn("truncate text-[13px]", isBinary ? "text-muted-foreground" : "text-foreground", isSelected && !isBinary ? "font-semibold" : "font-medium")}>
+          {noteStatus !== 'clean' && !isBinary && <StatusDot noteStatus={noteStatus} />}
           {entry.icon && isEmoji(entry.icon) && <span className="mr-1">{entry.icon}</span>}
           {entry.title}
-          <StateBadge archived={entry.archived} trashed={entry.trashed} />
+          {!isBinary && <StateBadge archived={entry.archived} trashed={entry.trashed} />}
         </div>
-        {entry.path.includes('/') && (
-          <div className="truncate text-[10px] text-muted-foreground" data-testid="note-path">{entry.path}</div>
-        )}
       </div>
-      {entry.snippet && (
+      {entry.snippet && !isBinary && (
         <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>
       )}
-      {entry.trashed && entry.trashedAt
+      {!isBinary && (entry.trashed && entry.trashedAt
         ? <TrashDateLine entry={entry} />
         : <div className="mt-0.5 text-[10px] text-muted-foreground">{relativeDate(getDisplayDate(entry))}</div>
-      }
+      )}
     </div>
   )
 }

src/components/NoteList.test.tsx

@@ -1,6 +1,7 @@
 import { render, screen, fireEvent } from '@testing-library/react'
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { NoteList } from './NoteList'
+import { NoteItem } from './NoteItem'
 import { getSortComparator, filterEntries, countByFilter, countAllByFilter } from '../utils/noteListHelpers'
 import type { NoteListFilter } from '../utils/noteListHelpers'
 import type { VaultEntry, SidebarSelection } from '../types'
@@ -1453,4 +1454,44 @@ describe('countAllByFilter', () => {
     const counts = countAllByFilter(entries)
     expect(counts).toEqual({ open: 2, archived: 1, trashed: 2 })
   })
+
+  it('excludes non-markdown files from counts', () => {
+    const entries = [
+      makeEntry({ path: '/1.md', isA: 'Note', fileKind: 'markdown' }),
+      makeEntry({ path: '/2.yml', isA: undefined, fileKind: 'text' }),
+      makeEntry({ path: '/3.png', isA: undefined, fileKind: 'binary' }),
+    ]
+    const counts = countAllByFilter(entries)
+    expect(counts).toEqual({ open: 1, archived: 0, trashed: 0 })
+  })
+})
+
+describe('NoteItem — binary file rendering', () => {
+  it('renders binary files as non-clickable with muted style', () => {
+    const binaryEntry = makeEntry({
+      path: '/vault/photo.png', filename: 'photo.png', title: 'photo.png', fileKind: 'binary',
+    })
+    const onClick = vi.fn()
+    render(<NoteItem entry={binaryEntry} isSelected={false} typeEntryMap={{}} onClickNote={onClick} />)
+
+    const item = screen.getByTestId('binary-file-item')
+    expect(item).toBeTruthy()
+    expect(item.className).toContain('opacity-50')
+    expect(item).toHaveAttribute('title', 'Cannot open this file type')
+
+    fireEvent.click(item)
+    expect(onClick).not.toHaveBeenCalled()
+  })
+
+  it('renders text files as clickable', () => {
+    const textEntry = makeEntry({
+      path: '/vault/config.yml', filename: 'config.yml', title: 'config.yml', fileKind: 'text',
+    })
+    const onClick = vi.fn()
+    render(<NoteItem entry={textEntry} isSelected={false} typeEntryMap={{}} onClickNote={onClick} />)
+
+    const item = screen.getByText('config.yml').closest('div')!
+    fireEvent.click(item)
+    expect(onClick).toHaveBeenCalled()
+  })
 })

src/components/NoteList.tsx

@@ -1,5 +1,5 @@
 import { useState, useMemo, useCallback, useEffect, memo } from 'react'
-import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus, InboxPeriod } from '../types'
+import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus, InboxPeriod, ViewFile } from '../types'
 import type { NoteListFilter } from '../utils/noteListHelpers'
 import { countByFilter, countAllByFilter, countInboxByPeriod } from '../utils/noteListHelpers'
 import { NoteItem } from './NoteItem'
@@ -41,9 +41,10 @@ interface NoteListProps {
   onUpdateTypeSort?: (path: string, key: string, value: string | number | boolean | string[] | null) => void
   updateEntry?: (path: string, patch: Partial<VaultEntry>) => void
   onOpenInNewWindow?: (entry: VaultEntry) => void
+  views?: ViewFile[]
 }
 
-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) {
+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, views }: NoteListProps) {
   const { modifiedPathSet, modifiedSuffixes, resolvedGetNoteStatus } = useModifiedFilesState(modifiedFiles, getNoteStatus)
 
   const isSectionGroup = selection.kind === 'sectionGroup'
@@ -68,7 +69,7 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
   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, inboxPeriod: isInboxView ? inboxPeriod : undefined })
+  const { isEntityView, isTrashView, isArchivedView, searched, searchedGroups, expiredTrashCount } = useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod: isInboxView ? inboxPeriod : undefined, views })
   const isChangesView = selection.kind === 'filter' && selection.filter === 'changes'
   const deletedCount = useMemo(
     () => isChangesView ? (modifiedFiles ?? []).filter((f) => f.status === 'deleted').length : 0,
@@ -101,7 +102,7 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
     onCreateNote(selection.kind === 'sectionGroup' ? selection.type : undefined)
   }, [onCreateNote, selection])
   const toggleGroup = useCallback((label: string) => { setCollapsedGroups((prev) => toggleSetMember(prev, label)) }, [])
-  const title = resolveHeaderTitle(selection, typeDocument)
+  const title = resolveHeaderTitle(selection, typeDocument, views)
 
   return (
     <div className="flex flex-col select-none overflow-hidden border-r border-border bg-card text-foreground" style={{ height: '100%' }}>

src/components/SearchPanel.test.tsx

@@ -154,6 +154,28 @@ describe('SearchPanel', () => {
     })
   })
 
+  it('shows note title from VaultEntry instead of filename from search result', async () => {
+    mockInvokeFn.mockResolvedValue({
+      results: [
+        { title: 'ai-apis', path: '/vault/essay/ai-apis.md', snippet: '...designing APIs...', score: 0.87, note_type: null },
+      ],
+      elapsed_ms: 12,
+    })
+
+    render(
+      <SearchPanel open={true} vaultPath="/vault" entries={MOCK_ENTRIES} onSelectNote={vi.fn()} onClose={vi.fn()} />,
+    )
+
+    const input = screen.getByPlaceholderText('Search in all notes...')
+    fireEvent.change(input, { target: { value: 'api' } })
+
+    await waitFor(() => {
+      // Should show VaultEntry title, not filename-based search result title
+      expect(screen.getByText('How to Design AI-first APIs')).toBeInTheDocument()
+      expect(screen.queryByText('ai-apis')).not.toBeInTheDocument()
+    })
+  })
+
   it('shows no results message when search returns empty', async () => {
     mockInvokeFn.mockResolvedValue({ results: [], elapsed_ms: 10 })
 
@@ -186,13 +208,13 @@ describe('SearchPanel', () => {
     fireEvent.change(input, { target: { value: 'test' } })
 
     await waitFor(() => {
-      expect(screen.getByText('Result One')).toBeInTheDocument()
+      expect(screen.getByText('How to Design AI-first APIs')).toBeInTheDocument()
     })
 
     fireEvent.keyDown(input, { key: 'ArrowDown' })
 
     await waitFor(() => {
-      const resultTwo = screen.getByText('Result Two').closest('[class*="cursor-pointer"]')!
+      const resultTwo = screen.getByText('Refactoring Retreat').closest('[class*="cursor-pointer"]')!
       expect(resultTwo.className).toContain('bg-accent')
     })
   })
@@ -330,9 +352,9 @@ describe('SearchPanel', () => {
       elapsed_ms: 30,
     })
 
-    // Spinner disappears after search completes
+    // Spinner disappears after search completes — VaultEntry title shown instead of search result title
     await waitFor(() => {
-      expect(screen.getByText('Result')).toBeInTheDocument()
+      expect(screen.getByText('How to Design AI-first APIs')).toBeInTheDocument()
       expect(screen.queryByTestId('search-spinner')).not.toBeInTheDocument()
     })
   })
@@ -358,9 +380,9 @@ describe('SearchPanel', () => {
     fireEvent.change(input, { target: { value: 'first' } })
     fireEvent.change(input, { target: { value: 'second' } })
 
-    // Only second query results should appear
+    // Only second query results should appear — VaultEntry title shown
     await waitFor(() => {
-      expect(screen.getByText('Second Result')).toBeInTheDocument()
+      expect(screen.getByText('Refactoring Retreat')).toBeInTheDocument()
     })
   })
 

src/components/SearchPanel.tsx

@@ -213,7 +213,7 @@ function SearchContent({
                     <TypeIcon width={14} height={14} className="shrink-0" style={{ color: typeColor ?? 'var(--muted-foreground)' }} />
                     <span className="min-w-0 flex-1 truncate text-[13px] font-medium text-foreground">
                       {entry?.icon && isEmoji(entry.icon) && <span className="mr-1">{entry.icon}</span>}
-                      {result.title}
+                      {entry?.title ?? result.title}
                     </span>
                     {noteType && (
                       <span className="shrink-0 text-[11px] text-muted-foreground/70">{noteType}</span>

src/components/Sidebar.test.tsx

@@ -252,50 +252,18 @@ describe('Sidebar', () => {
     expect(screen.queryByText('Types')).not.toBeInTheDocument()
   })
 
-  it('shows entity names under their section groups after expanding', () => {
+  it('does not show inline entity names — sections are flat rows', () => {
     render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
-    // Sections start collapsed by default — expand them first
-    fireEvent.click(screen.getByLabelText('Expand Projects'))
-    fireEvent.click(screen.getByLabelText('Expand Responsibilities'))
-    fireEvent.click(screen.getByLabelText('Expand Experiments'))
-    fireEvent.click(screen.getByLabelText('Expand Procedures'))
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-    expect(screen.getByText('Grow Newsletter')).toBeInTheDocument()
-    expect(screen.getByText('Stock Screener')).toBeInTheDocument()
-    expect(screen.getByText('Write Weekly Essays')).toBeInTheDocument()
-  })
-
-  it('shows People and Events items after expanding', () => {
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
-    fireEvent.click(screen.getByLabelText('Expand People'))
-    fireEvent.click(screen.getByLabelText('Expand Events'))
-    expect(screen.getByText('Alice')).toBeInTheDocument()
-    expect(screen.getByText('Kickoff Meeting')).toBeInTheDocument()
-  })
-
-  it('collapses and expands sections', () => {
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
-    // Start collapsed — items hidden
-    expect(screen.queryByText('Build Laputa App')).not.toBeInTheDocument()
-
-    // Expand
-    fireEvent.click(screen.getByLabelText('Expand Projects'))
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-
-    // Collapse
-    fireEvent.click(screen.getByLabelText('Collapse Projects'))
+    // Individual entries should NOT appear inline in the sidebar
     expect(screen.queryByText('Build Laputa App')).not.toBeInTheDocument()
+    expect(screen.queryByText('Grow Newsletter')).not.toBeInTheDocument()
   })
 
-  it('calls onSelect when clicking an entity', () => {
-    const onSelect = vi.fn()
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={onSelect} />)
-    fireEvent.click(screen.getByLabelText('Expand Projects'))
-    fireEvent.click(screen.getByText('Build Laputa App'))
-    expect(onSelect).toHaveBeenCalledWith({
-      kind: 'entity',
-      entry: mockEntries[0],
-    })
+  it('shows note count chip on type sections', () => {
+    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+    // Projects section has 1 entry — count chip should be a sibling of the label
+    const projectsHeader = screen.getByText('Projects').closest('[class*="group/section"]')!
+    expect(projectsHeader.textContent).toContain('1')
   })
 
   it('calls onSelect when clicking a section header', () => {
@@ -308,37 +276,12 @@ describe('Sidebar', () => {
     })
   })
 
-  it('expands a collapsed section when clicking its header', () => {
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
-    // Sections start collapsed — items hidden
-    expect(screen.queryByText('Build Laputa App')).not.toBeInTheDocument()
-    // Click the section header text (not the chevron)
-    fireEvent.click(screen.getByText('Projects'))
-    // Section should now be expanded
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-  })
-
-  it('collapses an expanded+selected section when clicking its header again', () => {
-    const projectSelection: SidebarSelection = { kind: 'sectionGroup', type: 'Project' }
-    render(<Sidebar entries={mockEntries} selection={projectSelection} onSelect={() => {}} />)
-    // First click expands (starts collapsed) and selects
-    fireEvent.click(screen.getByText('Projects'))
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-    // Second click: section is expanded + selected → should collapse
-    fireEvent.click(screen.getByText('Projects'))
-    expect(screen.queryByText('Build Laputa App')).not.toBeInTheDocument()
-  })
-
-  it('selects but keeps expanded an unselected expanded section when clicking its header', () => {
+  it('selects on every click — no expand/collapse toggle', () => {
     const onSelect = vi.fn()
     render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={onSelect} />)
-    // Expand via chevron first
-    fireEvent.click(screen.getByLabelText('Expand Projects'))
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
-    // Click the header — section is expanded but not selected → should select and stay expanded
     fireEvent.click(screen.getByText('Projects'))
-    expect(onSelect).toHaveBeenCalledWith({ kind: 'sectionGroup', type: 'Project' })
-    expect(screen.getByText('Build Laputa App')).toBeInTheDocument()
+    fireEvent.click(screen.getByText('Projects'))
+    expect(onSelect).toHaveBeenCalledTimes(2)
   })
 
   it('calls onSelect with sectionGroup for People', () => {
@@ -351,41 +294,15 @@ describe('Sidebar', () => {
     })
   })
 
-  it('renders Topics section with topic entries after expanding', () => {
+  it('renders Topics section header', () => {
     render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
     expect(screen.getByText('Topics')).toBeInTheDocument()
-    fireEvent.click(screen.getByLabelText('Expand Topics'))
-    expect(screen.getByText('Software Development')).toBeInTheDocument()
-    expect(screen.getByText('Trading')).toBeInTheDocument()
+    // Topic entries are NOT shown inline
+    expect(screen.queryByText('Software Development')).not.toBeInTheDocument()
   })
 
-  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: 'entity',
-      entry: mockEntries[4],
-    })
-  })
-
-  it('renders + buttons for each section group when onCreateType is provided', () => {
-    const onCreateType = vi.fn()
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} onCreateType={onCreateType} />)
-    const createButtons = screen.getAllByTitle(/^New /)
-    expect(createButtons.length).toBe(7) // Projects, Experiments, Responsibilities, Procedures, People, Events, Topics (no Type entries → no Types section)
-  })
-
-  it('calls onCreateType with correct type when + button is clicked', () => {
-    const onCreateType = vi.fn()
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} onCreateType={onCreateType} />)
-    fireEvent.click(screen.getByTitle('New Project'))
-    expect(onCreateType).toHaveBeenCalledWith('Project')
-  })
-
-  it('does not render + buttons when onCreateType is not provided', () => {
-    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+  it('does not render + buttons on type sections', () => {
+    render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} onCreateType={() => {}} />)
     expect(screen.queryByTitle('New Project')).not.toBeInTheDocument()
   })
 
@@ -517,24 +434,9 @@ describe('Sidebar', () => {
       expect(screen.getByText('Recipes')).toBeInTheDocument()
     })
 
-    it('shows instances of custom types under their section after expanding', () => {
+    it('does not show inline instances — sections are flat rows', () => {
       render(<Sidebar entries={entriesWithCustomTypes} selection={defaultSelection} onSelect={() => {}} onCreateType={() => {}} />)
-      fireEvent.click(screen.getByLabelText('Expand Recipes'))
-      expect(screen.getByText('Pasta Carbonara')).toBeInTheDocument()
-    })
-
-    it('renders + button on custom type sections for creating instances', () => {
-      const onCreateType = vi.fn()
-      render(<Sidebar entries={entriesWithCustomTypes} selection={defaultSelection} onSelect={() => {}} onCreateType={onCreateType} />)
-      fireEvent.click(screen.getByTitle('New Recipe'))
-      expect(onCreateType).toHaveBeenCalledWith('Recipe')
-    })
-
-    it('calls onCreateNewType when + is clicked on Types section', () => {
-      const onCreateNewType = vi.fn()
-      render(<Sidebar entries={entriesWithCustomTypes} selection={defaultSelection} onSelect={() => {}} onCreateNewType={onCreateNewType} />)
-      fireEvent.click(screen.getByTitle('New Type'))
-      expect(onCreateNewType).toHaveBeenCalled()
+      expect(screen.queryByText('Pasta Carbonara')).not.toBeInTheDocument()
     })
 
     it('does not show section for type with zero active entries', () => {
@@ -926,11 +828,10 @@ describe('Sidebar', () => {
       expect(screen.getByText('Notes')).toBeInTheDocument()
     })
 
-    it('includes both explicit and untyped notes under Notes section', () => {
+    it('counts both explicit and untyped notes in Notes section chip', () => {
       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()
+      const notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
+      expect(notesHeader.textContent).toContain('2')
     })
 
     it('shows Notes section for untyped entries even without explicit Note entries', () => {
@@ -1007,16 +908,8 @@ describe('Sidebar', () => {
     expect(onSelect).toHaveBeenCalledWith({ kind: 'filter', filter: 'inbox' })
   })
 
-  describe('emoji icon in sidebar section children', () => {
+  it('does not show inline entries — no child items in type sections', () => {
     const entriesWithEmoji: VaultEntry[] = [
-      {
-        path: '/vault/project.md', filename: 'project.md', title: 'Project', 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: 'rocket-launch', color: 'purple', order: null, sidebarLabel: null, template: null,
-        sort: null, view: null, visible: null, outgoingLinks: [], properties: {},
-      },
       {
         path: '/vault/project/build-app.md', filename: 'build-app.md', title: 'Build App',
         isA: 'Project', aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null,
@@ -1025,30 +918,44 @@ describe('Sidebar', () => {
         icon: '🚀', color: null, order: null, sidebarLabel: null, template: null,
         sort: null, view: null, visible: null, outgoingLinks: [], properties: {},
       },
-      {
-        path: '/vault/project/no-icon.md', filename: 'no-icon.md', title: 'No Icon Project',
-        isA: 'Project', 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, view: null, visible: null, outgoingLinks: [], properties: {},
-      },
     ]
+    render(<Sidebar entries={entriesWithEmoji} selection={defaultSelection} onSelect={() => {}} />)
+    expect(screen.queryByText('Build App')).not.toBeInTheDocument()
+  })
 
-    it('shows emoji icon before title in expanded section child', () => {
-      render(<Sidebar entries={entriesWithEmoji} selection={defaultSelection} onSelect={() => {}} />)
-      fireEvent.click(screen.getByLabelText('Expand Projects'))
-      const buildApp = screen.getByText('Build App')
-      const parent = buildApp.closest('div')!
-      expect(parent.textContent).toBe('🚀Build App')
+  describe('FAVORITES section', () => {
+    const favEntry: VaultEntry = {
+      path: '/vault/project/fav.md', filename: 'fav.md', title: 'My Favorite Note',
+      isA: 'Project', 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, view: null, visible: null, outgoingLinks: [], properties: {},
+      favorite: true, favoriteIndex: 0,
+    }
+
+    it('shows FAVORITES section when there are favorites', () => {
+      render(<Sidebar entries={[...mockEntries, favEntry]} selection={defaultSelection} onSelect={() => {}} />)
+      expect(screen.getByText('FAVORITES')).toBeInTheDocument()
+      expect(screen.getByText('My Favorite Note')).toBeInTheDocument()
     })
 
-    it('does not show emoji for notes without icon', () => {
-      render(<Sidebar entries={entriesWithEmoji} selection={defaultSelection} onSelect={() => {}} />)
-      fireEvent.click(screen.getByLabelText('Expand Projects'))
-      const noIcon = screen.getByText('No Icon Project')
-      const parent = noIcon.closest('div')!
-      expect(parent.textContent).toBe('No Icon Project')
+    it('hides FAVORITES section when no favorites', () => {
+      render(<Sidebar entries={mockEntries} selection={defaultSelection} onSelect={() => {}} />)
+      expect(screen.queryByText('FAVORITES')).not.toBeInTheDocument()
+    })
+
+    it('hides trashed favorites from the section', () => {
+      const trashedFav = { ...favEntry, trashed: true }
+      render(<Sidebar entries={[...mockEntries, trashedFav]} selection={defaultSelection} onSelect={() => {}} />)
+      expect(screen.queryByText('FAVORITES')).not.toBeInTheDocument()
+    })
+
+    it('calls onSelect with favorites filter when clicking a favorite', () => {
+      const onSelect = vi.fn()
+      render(<Sidebar entries={[...mockEntries, favEntry]} selection={defaultSelection} onSelect={onSelect} />)
+      fireEvent.click(screen.getByText('My Favorite Note'))
+      expect(onSelect).toHaveBeenCalledWith({ kind: 'filter', filter: 'favorites' })
     })
   })
 })

src/components/Sidebar.tsx

@@ -1,5 +1,5 @@
 import { useState, useMemo, useRef, useEffect, useCallback, memo } from 'react'
-import type { VaultEntry, FolderNode, SidebarSelection } from '../types'
+import type { VaultEntry, FolderNode, SidebarSelection, ViewFile } from '../types'
 import { buildTypeEntryMap } from '../utils/typeColors'
 import { buildDynamicSections, sortSections } from '../utils/sidebarSections'
 import { TypeCustomizePopover } from './TypeCustomizePopover'
@@ -12,8 +12,10 @@ import {
 } from '@dnd-kit/sortable'
 import { CSS } from '@dnd-kit/utilities'
 import {
-  FileText, Trash, Archive, CaretLeft, Tray,
+  FileText, Trash, Archive, CaretLeft, Tray, CaretRight, CaretDown, Plus, Funnel,
 } from '@phosphor-icons/react'
+import { isEmoji } from '../utils/emoji'
+import { arrayMove } from '@dnd-kit/sortable'
 import { SlidersHorizontal } from 'lucide-react'
 import {
   type SectionGroup, isSelectionActive,
@@ -34,6 +36,11 @@ interface SidebarProps {
   onReorderSections?: (orderedTypes: { typeName: string; order: number }[]) => void
   onRenameSection?: (typeName: string, label: string) => void
   onToggleTypeVisibility?: (typeName: string) => void
+  onSelectFavorite?: (entry: VaultEntry) => void
+  onReorderFavorites?: (orderedPaths: string[]) => void
+  views?: ViewFile[]
+  onCreateView?: () => void
+  onDeleteView?: (filename: string) => void
   folders?: FolderNode[]
   onCreateFolder?: (name: string) => void
   inboxCount?: number
@@ -112,24 +119,21 @@ function applyCustomization(
 
 function SortableSection({ group, sectionProps }: {
   group: SectionGroup
-  sectionProps: Omit<SectionContentProps, 'group' | 'items' | 'isCollapsed' | 'onToggle' | 'isRenaming' | 'renameInitialValue'>
-    & { entries: VaultEntry[]; collapsed: Record<string, boolean>; onToggle: (type: string) => void; renamingType: string | null; renameInitialValue: string }
+  sectionProps: Omit<SectionContentProps, 'group' | 'itemCount' | 'isRenaming' | 'renameInitialValue'>
+    & { entries: VaultEntry[]; renamingType: string | null; renameInitialValue: string }
 }) {
   const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: group.type })
-  const items = sectionProps.entries.filter((e) =>
+  const itemCount = 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
+  ).length
   const isRenaming = sectionProps.renamingType === group.type
 
   return (
-    <div ref={setNodeRef} style={{ transform: CSS.Transform.toString(transform), transition, opacity: isDragging ? 0.5 : 1, padding: isCollapsed ? '0 6px' : '4px 6px' }} {...attributes}>
+    <div ref={setNodeRef} style={{ transform: CSS.Transform.toString(transform), transition, opacity: isDragging ? 0.5 : 1, padding: '0 6px' }} {...attributes}>
       <SectionContent
-        group={group} items={items} isCollapsed={isCollapsed}
+        group={group} itemCount={itemCount}
         selection={sectionProps.selection} onSelect={sectionProps.onSelect}
-        onSelectNote={sectionProps.onSelectNote} onCreateType={sectionProps.onCreateType}
-        onCreateNewType={sectionProps.onCreateNewType} onContextMenu={sectionProps.onContextMenu}
-        onToggle={() => sectionProps.onToggle(group.type)}
+        onContextMenu={sectionProps.onContextMenu}
         dragHandleProps={listeners}
         isRenaming={isRenaming}
         renameInitialValue={isRenaming ? sectionProps.renameInitialValue : undefined}
@@ -140,6 +144,98 @@ function SortableSection({ group, sectionProps }: {
   )
 }
 
+function SortableFavoriteItem({ entry, isActive, onSelect }: {
+  entry: VaultEntry; isActive: boolean; onSelect: () => void
+}) {
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: entry.path })
+  const icon = entry.icon && isEmoji(entry.icon) ? entry.icon : null
+  return (
+    <div ref={setNodeRef} style={{ transform: CSS.Transform.toString(transform), transition, opacity: isDragging ? 0.5 : 1 }} {...attributes} {...listeners}>
+      <div
+        className={`flex cursor-pointer select-none items-center gap-1.5 rounded text-[13px] font-normal transition-colors ${isActive ? 'bg-secondary text-foreground' : 'text-muted-foreground hover:bg-accent'}`}
+        style={{ padding: '4px 16px 4px 28px' }}
+        onClick={onSelect}
+      >
+        {icon && <span className="shrink-0">{icon}</span>}
+        <span className="truncate">{entry.title}</span>
+      </div>
+    </div>
+  )
+}
+
+function FavoritesSection({ entries, selection, onSelect, onSelectNote, onReorder }: {
+  entries: VaultEntry[]
+  selection: SidebarSelection
+  onSelect: (sel: SidebarSelection) => void
+  onSelectNote?: (entry: VaultEntry) => void
+  onReorder?: (orderedPaths: string[]) => void
+}) {
+  const [collapsed, setCollapsed] = useState(false)
+  const favorites = useMemo(
+    () => entries
+      .filter((e) => e.favorite && !e.archived && !e.trashed)
+      .sort((a, b) => (a.favoriteIndex ?? Infinity) - (b.favoriteIndex ?? Infinity)),
+    [entries],
+  )
+  const favIds = useMemo(() => favorites.map((f) => f.path), [favorites])
+
+  const sensors = useSensors(
+    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+  )
+
+  const handleDragEnd = useCallback((event: DragEndEvent) => {
+    const { active, over } = event
+    if (!over || active.id === over.id) return
+    const oldIndex = favIds.indexOf(active.id as string)
+    const newIndex = favIds.indexOf(over.id as string)
+    if (oldIndex === -1 || newIndex === -1) return
+    const reordered = arrayMove(favIds, oldIndex, newIndex)
+    onReorder?.(reordered)
+  }, [favIds, onReorder])
+
+  if (favorites.length === 0) return null
+
+  return (
+    <div style={{ padding: '4px 6px 0' }}>
+      <button
+        className="flex w-full cursor-pointer select-none items-center justify-between border-none bg-transparent text-muted-foreground"
+        style={{ padding: '6px 14px 6px 16px' }}
+        onClick={() => setCollapsed((v) => !v)}
+      >
+        <div className="flex items-center gap-1">
+          {collapsed ? <CaretRight size={12} /> : <CaretDown size={12} />}
+          <span className="text-[10px] font-semibold" style={{ letterSpacing: 0.5 }}>FAVORITES</span>
+        </div>
+        <span className="flex items-center justify-center text-muted-foreground" style={{ height: 18, borderRadius: 9999, padding: '0 5px', fontSize: 10, background: 'var(--muted)' }}>
+          {favorites.length}
+        </span>
+      </button>
+      {!collapsed && (
+        <DndContext sensors={sensors} collisionDetection={closestCenter} onDragEnd={handleDragEnd}>
+          <SortableContext items={favIds} strategy={verticalListSortingStrategy}>
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+              {favorites.map((entry) => {
+                const isActive = isSelectionActive(selection, { kind: 'entity', entry })
+                return (
+                  <SortableFavoriteItem
+                    key={entry.path}
+                    entry={entry}
+                    isActive={isActive}
+                    onSelect={() => {
+                      onSelect({ kind: 'filter', filter: 'favorites' })
+                      onSelectNote?.(entry)
+                    }}
+                  />
+                )
+              })}
+            </div>
+          </SortableContext>
+        </DndContext>
+      )}
+    </div>
+  )
+}
+
 function SidebarTitleBar({ onCollapse }: { onCollapse?: () => void }) {
   const { onMouseDown } = useDragRegion()
   return (
@@ -205,12 +301,12 @@ function CustomizeOverlay({ target, typeEntryMap, innerRef, onCustomize, onChang
 // --- Main Sidebar ---
 
 export const Sidebar = memo(function Sidebar({
-  entries, selection, onSelect, onSelectNote, onCreateType, onCreateNewType,
+  entries, selection, onSelect,
   onCustomizeType, onUpdateTypeTemplate, onReorderSections, onRenameSection,
-  onToggleTypeVisibility,
+  onToggleTypeVisibility, onSelectFavorite, onReorderFavorites,
+  views = [], onCreateView, onDeleteView,
   folders = [], onCreateFolder, inboxCount = 0, onCollapse,
 }: SidebarProps) {
-  const [collapsed, setCollapsed] = useState<Record<string, boolean>>({})
   const [customizeTarget, setCustomizeTarget] = useState<string | null>(null)
   const [contextMenuPos, setContextMenuPos] = useState<{ x: number; y: number } | null>(null)
   const [renamingType, setRenamingType] = useState<string | null>(null)
@@ -236,10 +332,6 @@ export const Sidebar = memo(function Sidebar({
   useOutsideClick(contextMenuRef, !!contextMenuPos, closeContextMenu)
   useOutsideClick(popoverRef, !!customizeTarget, closeCustomizeTarget)
 
-  const toggleSection = useCallback((type: string) => {
-    setCollapsed((prev) => ({ ...prev, [type]: !(prev[type] ?? true) }))
-  }, [])
-
   const sensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
     useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
@@ -280,8 +372,8 @@ export const Sidebar = memo(function Sidebar({
   }, [customizeTarget, onUpdateTypeTemplate])
 
   const sectionProps = {
-    entries, collapsed, selection, onSelect, onSelectNote, onCreateType, onCreateNewType,
-    onContextMenu: handleContextMenu, onToggle: toggleSection,
+    entries, selection, onSelect,
+    onContextMenu: handleContextMenu,
     renamingType, renameInitialValue, onRenameSubmit: handleRenameSubmit, onRenameCancel: cancelRename,
   }
 
@@ -297,6 +389,43 @@ export const Sidebar = memo(function Sidebar({
           <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)' }} activeBadgeClassName="bg-destructive text-destructive-foreground" onClick={() => onSelect({ kind: 'filter', filter: 'trash' })} />
         </div>
 
+        {/* Favorites */}
+        <FavoritesSection entries={entries} selection={selection} onSelect={onSelect} onSelectNote={onSelectFavorite} onReorder={onReorderFavorites} />
+
+        {/* Views */}
+        {(views.length > 0 || onCreateView) && (
+          <div style={{ padding: '4px 6px' }}>
+            <div className="flex w-full select-none items-center justify-between" style={{ padding: '4px 16px' }}>
+              <span className="text-[11px] font-medium text-muted-foreground">Views</span>
+              {onCreateView && (
+                <button className="flex shrink-0 cursor-pointer items-center justify-center rounded border-none bg-transparent p-0 text-muted-foreground transition-colors hover:text-foreground" style={{ width: 20, height: 20 }} onClick={onCreateView} aria-label="Create view" title="Create view">
+                  <Plus size={14} />
+                </button>
+              )}
+            </div>
+            {views.map((v) => (
+              <div key={v.filename} className="group relative">
+                <NavItem
+                  icon={Funnel}
+                  label={v.definition.name}
+                  isActive={isSelectionActive(selection, { kind: 'view', filename: v.filename })}
+                  onClick={() => onSelect({ kind: 'view', filename: v.filename })}
+                  compact
+                />
+                {onDeleteView && (
+                  <button
+                    className="absolute right-2 top-1/2 -translate-y-1/2 rounded p-0.5 text-muted-foreground opacity-0 transition-opacity hover:text-destructive group-hover:opacity-100"
+                    onClick={(e) => { e.stopPropagation(); onDeleteView(v.filename) }}
+                    title="Delete view"
+                  >
+                    <Trash size={12} />
+                  </button>
+                )}
+              </div>
+            ))}
+          </div>
+        )}
+
         {/* Sections header + visibility popover */}
         <div ref={customizeRef} style={{ position: 'relative', padding: '4px 6px 0' }}>
           <div className="flex w-full select-none items-center justify-between" style={{ padding: '4px 16px' }}>

src/components/SidebarParts.tsx

@@ -1,8 +1,6 @@
 import { type ComponentType, useState, useEffect, useRef } from 'react'
-import type { VaultEntry, SidebarSelection } from '../types'
+import type { 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'
 
@@ -21,6 +19,7 @@ export function isSelectionActive(current: SidebarSelection, check: SidebarSelec
     case 'sectionGroup': return (current as typeof check).type === check.type
     case 'folder': return (current as typeof check).path === check.path
     case 'entity': return (current as typeof check).entry.path === check.entry.path
+    case 'view': return (current as typeof check).filename === check.filename
     default: return false
   }
 }
@@ -77,15 +76,10 @@ export function NavItem({ icon: Icon, label, count, isActive, activeClassName =
 
 export interface SectionContentProps {
   group: SectionGroup
-  items: VaultEntry[]
-  isCollapsed: boolean
+  itemCount: number
   selection: SidebarSelection
   onSelect: (sel: SidebarSelection) => void
-  onSelectNote?: (entry: VaultEntry) => void
-  onCreateType?: (type: string) => void
-  onCreateNewType?: () => void
   onContextMenu: (e: React.MouseEvent, type: string) => void
-  onToggle: () => void
   dragHandleProps?: Record<string, unknown>
   isRenaming?: boolean
   renameInitialValue?: string
@@ -93,75 +87,30 @@ export interface SectionContentProps {
   onRenameCancel?: () => void
 }
 
-function childSelection(entry: VaultEntry): SidebarSelection {
-  return { kind: 'entity', entry }
-}
-
-function resolveCreateHandler(type: string, onCreateType?: (type: string) => void, onCreateNewType?: () => void): (() => void) | undefined {
-  const isType = type === 'Type'
-  if (!onCreateType && !(isType && onCreateNewType)) return undefined
-  return isType ? () => onCreateNewType?.() : () => onCreateType?.(type)
-}
-
 export function SectionContent({
-  group, items, isCollapsed, selection, onSelect, onSelectNote,
-  onCreateType, onCreateNewType, onContextMenu, onToggle, dragHandleProps,
+  group, itemCount, selection, onSelect,
+  onContextMenu, dragHandleProps,
   isRenaming, renameInitialValue, onRenameSubmit, onRenameCancel,
 }: SectionContentProps) {
   const { label, type, Icon, customColor } = group
   const sectionColor = getTypeColor(type, customColor)
   const sectionLightColor = getTypeLightColor(type, customColor)
-  const onCreate = resolveCreateHandler(type, onCreateType, onCreateNewType)
 
   return (
-    <>
-      <SectionHeader
-        label={label} type={type} Icon={Icon}
-        sectionColor={sectionColor}
-        isCollapsed={isCollapsed}
-        isActive={isSelectionActive(selection, { kind: 'sectionGroup', type })}
-        showCreate={!!onCreate}
-        onSelect={() => onSelect({ kind: 'sectionGroup', type })}
-        onContextMenu={(e) => onContextMenu(e, type)}
-        onToggle={onToggle}
-        onCreate={(e) => { e.stopPropagation(); onCreate?.() }}
-        dragHandleProps={dragHandleProps}
-        isRenaming={isRenaming}
-        renameInitialValue={renameInitialValue}
-        onRenameSubmit={onRenameSubmit}
-        onRenameCancel={onRenameCancel}
-      />
-      {!isCollapsed && items.length > 0 && (
-        <SectionChildList
-          items={items} selection={selection}
-          sectionColor={sectionColor} sectionLightColor={sectionLightColor}
-          onSelect={onSelect} onSelectNote={onSelectNote}
-        />
-      )}
-    </>
-  )
-}
-
-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(entry)
-        const active = isSelectionActive(selection, sel)
-        return (
-          <SectionChildItem
-            key={entry.path} title={entry.title} icon={entry.icon} isActive={active}
-            sectionColor={active ? sectionColor : undefined}
-            sectionLightColor={active ? sectionLightColor : undefined}
-            onClick={() => { onSelect(sel); onSelectNote?.(entry) }}
-          />
-        )
-      })}
-    </div>
+    <SectionHeader
+      label={label} type={type} Icon={Icon}
+      sectionColor={sectionColor}
+      sectionLightColor={sectionLightColor}
+      itemCount={itemCount}
+      isActive={isSelectionActive(selection, { kind: 'sectionGroup', type })}
+      onSelect={() => onSelect({ kind: 'sectionGroup', type })}
+      onContextMenu={(e) => onContextMenu(e, type)}
+      dragHandleProps={dragHandleProps}
+      isRenaming={isRenaming}
+      renameInitialValue={renameInitialValue}
+      onRenameSubmit={onRenameSubmit}
+      onRenameCancel={onRenameCancel}
+    />
   )
 }
 
@@ -195,29 +144,24 @@ function InlineRenameInput({ initialValue, onSubmit, onCancel }: {
   )
 }
 
-function SectionHeader({ label, type, Icon, sectionColor, isCollapsed, isActive, showCreate, onSelect, onContextMenu, onToggle, onCreate, dragHandleProps, isRenaming, renameInitialValue, onRenameSubmit, onRenameCancel }: {
+function SectionHeader({ label, type, Icon, sectionColor, sectionLightColor, itemCount, isActive, onSelect, onContextMenu, dragHandleProps, isRenaming, renameInitialValue, onRenameSubmit, onRenameCancel }: {
   label: string; type: string; Icon: ComponentType<IconProps>
-  sectionColor: string; isCollapsed: boolean; isActive: boolean; showCreate: boolean
+  sectionColor: string; sectionLightColor: string; itemCount: number; isActive: boolean
   onSelect: () => void; onContextMenu: (e: React.MouseEvent) => void
-  onToggle: () => void; onCreate: (e: React.MouseEvent) => void
   dragHandleProps?: Record<string, unknown>
   isRenaming?: boolean; renameInitialValue?: string
   onRenameSubmit?: (value: string) => void; onRenameCancel?: () => void
 }) {
   return (
     <div
-      className={cn("group/section flex cursor-pointer select-none items-center justify-between rounded transition-colors", isActive ? "bg-secondary" : "hover:bg-accent")}
-      style={{ padding: '6px 8px 6px 16px', borderRadius: 4, gap: 4 }}
+      className={cn("group/section flex cursor-pointer select-none items-center justify-between rounded transition-colors", !isActive && "hover:bg-accent")}
+      style={{ padding: '6px 8px 6px 16px', borderRadius: 4, gap: 4, ...(isActive ? { background: sectionLightColor } : {}) }}
       {...dragHandleProps}
-      onClick={() => {
-        if (isRenaming) return
-        if (isCollapsed) { onToggle(); onSelect() }
-        else if (isActive) { onToggle() }
-        else { onSelect() }
-      }} onContextMenu={isRenaming ? undefined : onContextMenu}
+      onClick={() => { if (!isRenaming) onSelect() }}
+      onContextMenu={isRenaming ? undefined : onContextMenu}
     >
       <div className="flex min-w-0 flex-1 items-center" style={{ gap: 4 }}>
-        <Icon size={16} style={{ color: sectionColor, flexShrink: 0 }} />
+        <Icon size={16} weight={isActive ? 'fill' : 'regular'} style={{ color: sectionColor, flexShrink: 0 }} />
         {isRenaming && onRenameSubmit && onRenameCancel ? (
           <InlineRenameInput
             key={`rename-${type}`}
@@ -226,35 +170,17 @@ function SectionHeader({ label, type, Icon, sectionColor, isCollapsed, isActive,
             onCancel={onRenameCancel}
           />
         ) : (
-          <span className="text-[13px] font-medium text-foreground" style={{ marginLeft: 4 }}>{label}</span>
+          <span className="text-[13px] font-medium" style={{ marginLeft: 4, color: isActive ? sectionColor : undefined }}>{label}</span>
         )}
       </div>
-      <div className="flex items-center" style={{ gap: 2 }}>
-        {showCreate && (
-          <button className="flex shrink-0 items-center justify-center rounded border-none bg-transparent p-0 text-muted-foreground opacity-0 transition-opacity hover:text-foreground group-hover/section:opacity-100 cursor-pointer" style={{ width: 20, height: 20 }} onClick={onCreate} aria-label={type === 'Type' ? 'Create new Type' : `Create new ${type}`} title={type === 'Type' ? 'New Type' : `New ${type}`}>
-            <Plus size={14} />
-          </button>
-        )}
-        <button className="flex shrink-0 items-center border-none bg-transparent p-0 text-inherit cursor-pointer" onClick={(e) => { e.stopPropagation(); onToggle() }} aria-label={isCollapsed ? `Expand ${label}` : `Collapse ${label}`}>
-          {isCollapsed ? <ChevronRight size={12} /> : <ChevronDown size={12} />}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-function SectionChildItem({ title, icon, isActive, sectionColor, sectionLightColor, onClick }: {
-  title: string; icon?: string | null; isActive: boolean
-  sectionColor?: string; sectionLightColor?: string
-  onClick: () => void
-}) {
-  return (
-    <div
-      className={cn("cursor-pointer truncate rounded-md text-[13px] font-normal transition-colors", isActive ? "text-foreground" : "text-muted-foreground hover:bg-accent")}
-      style={{ padding: '4px 16px 4px 28px', ...(isActive && { backgroundColor: sectionLightColor, color: sectionColor }) }}
-      onClick={onClick}
-    >
-      {icon && isEmoji(icon) && <span className="mr-1">{icon}</span>}{title}
+      {itemCount > 0 && (
+        <span
+          className={cn("flex items-center justify-center", !isActive && "text-muted-foreground")}
+          style={{ height: 20, borderRadius: 9999, padding: '0 6px', fontSize: 10, ...(isActive ? { background: sectionColor, color: 'white' } : { background: 'var(--muted)' }) }}
+        >
+          {itemCount}
+        </span>
+      )}
     </div>
   )
 }

src/components/TitleField.test.tsx

@@ -101,4 +101,51 @@ describe('TitleField', () => {
     window.dispatchEvent(new CustomEvent('laputa:focus-editor', { detail: { selectTitle: true } }))
     expect(document.activeElement).toBe(input)
   })
+
+  it('resets stale localValue when title prop changes after focus', () => {
+    // Regression: creating a new note fires focus-editor before React re-renders,
+    // so handleFocus captures the OLD note's title into localValue.
+    // When React re-renders with the new title, localValue should be cleared.
+    const onChange = vi.fn()
+    const { rerender } = render(<TitleField title="Old Note" filename="old-note.md" onTitleChange={onChange} />)
+    const input = screen.getByTestId('title-field-input')
+    // Simulate: focus fires while title prop is still "Old Note"
+    fireEvent.focus(input)
+    expect(input).toHaveValue('Old Note')
+    // React re-renders with new note's title (tab switched)
+    rerender(<TitleField title="Untitled note" filename="untitled-note.md" onTitleChange={onChange} />)
+    expect(input).toHaveValue('Untitled note')
+  })
+
+  it('shows vault-relative path (without .md) only when title is focused', () => {
+    render(<TitleField title="ADR" filename="0001-tauri-stack.md" notePath="/Users/luca/Laputa/docs/adr/0001-tauri-stack.md" vaultPath="/Users/luca/Laputa" onTitleChange={() => {}} />)
+    // Path hidden by default
+    expect(screen.queryByTestId('title-field-path')).not.toBeInTheDocument()
+    // Focus title → path appears
+    fireEvent.focus(screen.getByTestId('title-field-input'))
+    expect(screen.getByTestId('title-field-path')).toHaveTextContent('docs/adr/0001-tauri-stack')
+    // No bare filename shown when path is visible
+    expect(screen.queryByTestId('title-field-filename')).not.toBeInTheDocument()
+  })
+
+  it('hides path on blur', () => {
+    render(<TitleField title="ADR" filename="0001-tauri-stack.md" notePath="/Users/luca/Laputa/docs/adr/0001-tauri-stack.md" vaultPath="/Users/luca/Laputa" onTitleChange={() => {}} />)
+    const input = screen.getByTestId('title-field-input')
+    fireEvent.focus(input)
+    expect(screen.getByTestId('title-field-path')).toBeInTheDocument()
+    fireEvent.blur(input)
+    expect(screen.queryByTestId('title-field-path')).not.toBeInTheDocument()
+  })
+
+  it('hides path for notes at vault root even when focused', () => {
+    render(<TitleField title="Root Note" filename="root-note.md" notePath="/Users/luca/Laputa/root-note.md" vaultPath="/Users/luca/Laputa" onTitleChange={() => {}} />)
+    fireEvent.focus(screen.getByTestId('title-field-input'))
+    expect(screen.queryByTestId('title-field-path')).not.toBeInTheDocument()
+  })
+
+  it('hides path when vaultPath is not provided', () => {
+    render(<TitleField title="Note" filename="note.md" onTitleChange={() => {}} />)
+    fireEvent.focus(screen.getByTestId('title-field-input'))
+    expect(screen.queryByTestId('title-field-path')).not.toBeInTheDocument()
+  })
 })

src/components/TitleField.tsx

@@ -5,6 +5,10 @@ interface TitleFieldProps {
   title: string
   filename: string
   editable?: boolean
+  /** Absolute path of the note file. */
+  notePath?: string
+  /** Absolute path of the vault root. */
+  vaultPath?: string
   /** Called when the user finishes editing the title (blur or Enter). */
   onTitleChange: (newTitle: string) => void
 }
@@ -15,6 +19,15 @@ function useOptimisticTitle(title: string, onTitleChange: (t: string) => void) {
   // [optimisticTitle, forPropTitle]: shown after commit until title prop catches up
   const [optimistic, setOptimistic] = useState<[string, string] | null>(null)
   const isFocusedRef = useRef(false)
+  const [prevTitle, setPrevTitle] = useState(title)
+
+  // Reset local edit when the title prop changes (e.g. note switch).
+  // This prevents a stale handleFocus closure from locking in the old note's title
+  // when focus-editor fires before React re-renders with the new tab.
+  if (prevTitle !== title) {
+    setPrevTitle(title)
+    if (localValue !== null) setLocalValue(null)
+  }
 
   // Clear optimistic once the prop changes (rename completed or tab switched)
   const optimisticValue = optimistic && optimistic[1] === title ? optimistic[0] : null
@@ -48,8 +61,9 @@ function useOptimisticTitle(title: string, onTitleChange: (t: string) => void) {
  * Dedicated title input field above the editor.
  * Displays the title as an editable field and shows the resulting filename below.
  */
-export function TitleField({ title, filename, editable = true, onTitleChange }: TitleFieldProps) {
+export function TitleField({ title, filename, editable = true, notePath, vaultPath, onTitleChange }: TitleFieldProps) {
   const inputRef = useRef<HTMLInputElement>(null)
+  const [isFocused, setIsFocused] = useState(false)
   const { value, isEditing, handleFocus, commitTitle, revert, setEdit } =
     useOptimisticTitle(title, onTitleChange)
 
@@ -78,7 +92,17 @@ export function TitleField({ title, filename, editable = true, onTitleChange }:
 
   const expectedSlug = slugify(value.trim() || title)
   const currentStem = filename.replace(/\.md$/, '')
-  const showFilename = isEditing || currentStem !== expectedSlug
+
+  // Compute vault-relative path (only for notes in subdirectories)
+  const relativePath = notePath && vaultPath
+    ? notePath.replace(vaultPath + '/', '').replace(/\.md$/, '')
+    : null
+  const isSubdirectory = relativePath != null && relativePath.includes('/')
+
+  // Show path only when title is focused and note is in a subdirectory
+  const showRelativePath = isFocused && isSubdirectory
+  // Show filename hint when slug differs, but suppress when path is already visible
+  const showFilename = !showRelativePath && (isEditing || currentStem !== expectedSlug)
 
   return (
     <div className="title-field" data-testid="title-field">
@@ -87,8 +111,8 @@ export function TitleField({ title, filename, editable = true, onTitleChange }:
         className="title-field__input"
         value={value}
         onChange={e => setEdit(e.target.value)}
-        onFocus={handleFocus}
-        onBlur={commitTitle}
+        onFocus={() => { setIsFocused(true); handleFocus() }}
+        onBlur={() => { setIsFocused(false); commitTitle() }}
         onKeyDown={handleKeyDown}
         disabled={!editable}
         placeholder="Untitled"
@@ -100,6 +124,11 @@ export function TitleField({ title, filename, editable = true, onTitleChange }:
           {expectedSlug}.md
         </span>
       )}
+      {showRelativePath && (
+        <span className="title-field__path" data-testid="title-field-path" style={{ display: 'block', fontSize: 11, color: 'var(--muted-foreground)', marginTop: 2 }}>
+          {relativePath}
+        </span>
+      )}
     </div>
   )
 }

src/components/note-list/noteListHooks.ts

@@ -1,5 +1,5 @@
 import { useState, useMemo, useCallback, useEffect, useRef } from 'react'
-import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus } from '../../types'
+import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus, ViewFile } from '../../types'
 import {
   type SortOption, type SortDirection, type SortConfig, type NoteListFilter,
   getSortComparator, extractSortableProperties,
@@ -20,7 +20,7 @@ export function useTypeEntryMap(entries: VaultEntry[]) {
 
 // --- useFilteredEntries ---
 
-export function useFilteredEntries(entries: VaultEntry[], selection: SidebarSelection, modifiedPathSet: Set<string>, modifiedSuffixes: string[], subFilter?: NoteListFilter, inboxPeriod?: InboxPeriod) {
+export function useFilteredEntries(entries: VaultEntry[], selection: SidebarSelection, modifiedPathSet: Set<string>, modifiedSuffixes: string[], subFilter?: NoteListFilter, inboxPeriod?: InboxPeriod, views?: ViewFile[]) {
   const isEntityView = selection.kind === 'entity'
   const isChangesView = selection.kind === 'filter' && selection.filter === 'changes'
   const isInboxView = selection.kind === 'filter' && selection.filter === 'inbox'
@@ -28,8 +28,8 @@ export function useFilteredEntries(entries: VaultEntry[], selection: SidebarSele
     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, isInboxView, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod])
+    return filterEntries(entries, selection, subFilter, views)
+  }, [entries, selection, isEntityView, isChangesView, isInboxView, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod, views])
 }
 
 // --- useNoteListData ---
@@ -40,14 +40,15 @@ interface NoteListDataParams {
   modifiedPathSet: Set<string>; modifiedSuffixes: string[]
   subFilter?: NoteListFilter
   inboxPeriod?: InboxPeriod
+  views?: ViewFile[]
 }
 
-export function useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod }: NoteListDataParams) {
+export function useNoteListData({ entries, selection, query, listSort, listDirection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod, views }: 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, inboxPeriod)
+  const filteredEntries = useFilteredEntries(entries, selection, modifiedPathSet, modifiedSuffixes, subFilter, inboxPeriod, views)
 
   const searched = useMemo(() => {
     const sorted = [...filteredEntries].sort(getSortComparator(listSort, listDirection))

src/components/note-list/noteListUtils.ts

@@ -1,7 +1,11 @@
-import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus } from '../../types'
+import type { VaultEntry, SidebarSelection, ModifiedFile, NoteStatus, ViewFile } from '../../types'
 import type { RelationshipGroup } from '../../utils/noteListHelpers'
 
-export function resolveHeaderTitle(selection: SidebarSelection, typeDocument: VaultEntry | null): string {
+export function resolveHeaderTitle(selection: SidebarSelection, typeDocument: VaultEntry | null, views?: ViewFile[]): string {
+  if (selection.kind === 'view') {
+    const view = views?.find((v) => v.filename === selection.filename)
+    return view?.definition.name ?? 'View'
+  }
   if (selection.kind === 'entity') return selection.entry.title
   if (typeDocument) return typeDocument.title
   if (selection.kind === 'filter' && selection.filter === 'archived') return 'Archive'

src/hooks/commands/noteCommands.ts

@@ -19,6 +19,8 @@ interface NoteCommandsConfig {
   onSetNoteIcon?: () => void
   onRemoveNoteIcon?: () => void
   onOpenInNewWindow?: () => void
+  onToggleFavorite?: (path: string) => void
+  isFavorite?: boolean
 }
 
 export function buildNoteCommands(config: NoteCommandsConfig): CommandAction[] {
@@ -28,7 +30,7 @@ export function buildNoteCommands(config: NoteCommandsConfig): CommandAction[] {
     onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
     onEmptyTrash, trashedCount,
     onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon,
-    onOpenInNewWindow,
+    onOpenInNewWindow, onToggleFavorite, isFavorite,
   } = config
 
   return [
@@ -47,6 +49,12 @@ export function buildNoteCommands(config: NoteCommandsConfig): CommandAction[] {
       keywords: ['archive'], enabled: hasActiveNote,
       execute: () => { if (activeTabPath) (isArchived ? onUnarchiveNote : onArchiveNote)(activeTabPath) },
     },
+    {
+      id: 'toggle-favorite', label: isFavorite ? 'Remove from Favorites' : 'Add to Favorites', group: 'Note', shortcut: '⌘D',
+      keywords: ['favorite', 'star', 'bookmark', 'pin'],
+      enabled: hasActiveNote && !!onToggleFavorite,
+      execute: () => { if (activeTabPath) onToggleFavorite?.(activeTabPath) },
+    },
     {
       id: 'set-note-icon', label: 'Set Note Icon', group: 'Note',
       keywords: ['icon', 'emoji', 'set', 'add', 'change', 'picker'],

src/hooks/frontmatterOps.ts

@@ -10,8 +10,11 @@ const ENTRY_DELETE_MAP: Record<string, Partial<VaultEntry>> = {
   type: { isA: null }, is_a: { isA: null }, status: { status: null }, color: { color: null },
   icon: { icon: null },
   aliases: { aliases: [] }, belongs_to: { belongsTo: [] }, related_to: { relatedTo: [] },
-  archived: { archived: false }, trashed: { trashed: false }, order: { order: null },
+  _archived: { archived: false }, archived: { archived: false },
+  _trashed: { trashed: false }, trashed: { trashed: false },
+  order: { order: null },
   template: { template: null }, sort: { sort: null }, visible: { visible: null },
+  _favorite: { favorite: false }, _favorite_index: { favoriteIndex: null },
 }
 
 /** Check if a string contains a wikilink pattern `[[...]]`. */
@@ -52,12 +55,15 @@ export function frontmatterToEntryPatch(
     type: { isA: str }, is_a: { isA: str }, status: { status: str }, color: { color: str },
     icon: { icon: str },
     aliases: { aliases: arr }, belongs_to: { belongsTo: arr }, related_to: { relatedTo: arr },
-    archived: { archived: Boolean(value) }, trashed: { trashed: Boolean(value) },
+    _archived: { archived: Boolean(value) }, archived: { archived: Boolean(value) },
+    _trashed: { trashed: Boolean(value) }, trashed: { trashed: Boolean(value) },
     order: { order: typeof value === 'number' ? value : null },
     template: { template: str },
     sort: { sort: str },
     view: { view: str },
     visible: { visible: value === false ? false : null },
+    _favorite: { favorite: Boolean(value) },
+    _favorite_index: { favoriteIndex: typeof value === 'number' ? value : null },
   }
   // Also update the relationships map for wikilink-containing values
   const wikilinks = value != null ? extractWikilinks(value) : []

src/hooks/useAppCommands.ts

@@ -65,6 +65,7 @@ interface AppCommandsConfig {
   noteListFilter?: NoteListFilter
   onSetNoteListFilter?: (filter: NoteListFilter) => void
   onOpenInNewWindow?: () => void
+  onToggleFavorite?: (path: string) => void
 }
 
 /** Sets up keyboard shortcuts, command registry, menu events, and keyboard navigation. */
@@ -112,6 +113,7 @@ export function useAppCommands(config: AppCommandsConfig): CommandAction[] {
     onToggleAIChat: config.onToggleAIChat,
     onToggleRawEditor: config.onToggleRawEditor,
     onToggleInspector: config.onToggleInspector,
+    onToggleFavorite: config.onToggleFavorite,
     onOpenInNewWindow: config.onOpenInNewWindow,
     activeTabPathRef: config.activeTabPathRef,
   })

src/hooks/useAppKeyboard.test.ts

@@ -79,6 +79,14 @@ describe('useAppKeyboard', () => {
     expect(actions.onCreateNote).toHaveBeenCalled()
   })
 
+  it('Cmd+D triggers toggle favorite on active note', () => {
+    const actions = makeActions()
+    actions.onToggleFavorite = vi.fn()
+    renderHook(() => useAppKeyboard(actions))
+    fireKey('d', { metaKey: true })
+    expect(actions.onToggleFavorite).toHaveBeenCalledWith('/vault/test.md')
+  })
+
   it('Cmd+J triggers open daily note', () => {
     const actions = makeActions()
     renderHook(() => useAppKeyboard(actions))

src/hooks/useAppKeyboard.ts

@@ -20,6 +20,7 @@ interface KeyboardActions {
   onToggleAIChat?: () => void
   onToggleRawEditor?: () => void
   onToggleInspector?: () => void
+  onToggleFavorite?: (path: string) => void
   onOpenInNewWindow?: () => void
   activeTabPathRef: React.MutableRefObject<string | null>
 }
@@ -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, onToggleInspector, onOpenInNewWindow, activeTabPathRef,
+  onSetViewMode, onZoomIn, onZoomOut, onZoomReset, onGoBack, onGoForward, onToggleAIChat, onToggleRawEditor, onToggleInspector, onToggleFavorite, onOpenInNewWindow, activeTabPathRef,
 }: KeyboardActions) {
   useEffect(() => {
     const withActiveTab = (fn: (path: string) => void): ShortcutHandler => () => {
@@ -80,6 +81,7 @@ export function useAppKeyboard({
       j: onOpenDailyNote,
       s: onSave,
       ',': onOpenSettings,
+      d: withActiveTab((path) => onToggleFavorite?.(path)),
       e: withActiveTab(onArchiveNote),
       Backspace: withActiveTab(onTrashNote),
       Delete: withActiveTab(onTrashNote),

src/hooks/useCommandRegistry.ts

@@ -30,6 +30,7 @@ interface CommandRegistryConfig {
   onSetNoteIcon?: () => void
   onRemoveNoteIcon?: () => void
   onOpenInNewWindow?: () => void
+  onToggleFavorite?: (path: string) => void
   onQuickOpen: () => void
   onCreateNote: () => void
   onCreateNoteOfType: (type: string) => void
@@ -85,7 +86,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): import('./com
     mcpStatus, onInstallMcp, onEmptyTrash, trashedCount,
     onReloadVault, onRepairVault,
     onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon,
-    onOpenInNewWindow,
+    onOpenInNewWindow, onToggleFavorite,
     selection, noteListFilter, onSetNoteListFilter,
   } = config
 
@@ -97,6 +98,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): import('./com
   )
   const isArchived = activeEntry?.archived ?? false
   const isTrashed = activeEntry?.trashed ?? false
+  const isFavorite = activeEntry?.favorite ?? false
   const isSectionGroup = selection?.kind === 'sectionGroup'
 
   const vaultTypes = useMemo(() => extractVaultTypes(entries), [entries])
@@ -107,7 +109,7 @@ export function useCommandRegistry(config: CommandRegistryConfig): import('./com
       hasActiveNote, activeTabPath, isArchived, isTrashed,
       onCreateNote, onCreateType, onOpenDailyNote, onSave,
       onTrashNote, onRestoreNote, onArchiveNote, onUnarchiveNote,
-      onEmptyTrash, trashedCount, onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon, onOpenInNewWindow,
+      onEmptyTrash, trashedCount, onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon, onOpenInNewWindow, onToggleFavorite, isFavorite,
     }),
     ...buildGitCommands({ modifiedCount, onCommitPush, onPull, onResolveConflicts, onSelect }),
     ...buildViewCommands({
@@ -136,6 +138,6 @@ export function useCommandRegistry(config: CommandRegistryConfig): import('./com
     onReloadVault, onRepairVault,
     onSetNoteIcon, onRemoveNoteIcon, activeNoteHasIcon,
     isSectionGroup, noteListFilter, onSetNoteListFilter,
-    onOpenInNewWindow,
+    onOpenInNewWindow, onToggleFavorite, isFavorite,
   ])
 }

src/hooks/useDialogs.ts

@@ -9,6 +9,7 @@ export function useDialogs() {
   const [showGitHubVault, setShowGitHubVault] = useState(false)
   const [showSearch, setShowSearch] = useState(false)
   const [showConflictResolver, setShowConflictResolver] = useState(false)
+  const [showCreateViewDialog, setShowCreateViewDialog] = useState(false)
 
   const openCreateType = useCallback(() => setShowCreateTypeDialog(true), [])
   const closeCreateType = useCallback(() => setShowCreateTypeDialog(false), [])
@@ -25,6 +26,8 @@ export function useDialogs() {
   const closeSearch = useCallback(() => setShowSearch(false), [])
   const openConflictResolver = useCallback(() => setShowConflictResolver(true), [])
   const closeConflictResolver = useCallback(() => setShowConflictResolver(false), [])
+  const openCreateView = useCallback(() => setShowCreateViewDialog(true), [])
+  const closeCreateView = useCallback(() => setShowCreateViewDialog(false), [])
 
   return {
     showCreateTypeDialog, openCreateType, closeCreateType,
@@ -35,5 +38,6 @@ export function useDialogs() {
     showGitHubVault, openGitHubVault, closeGitHubVault,
     showSearch, openSearch, closeSearch,
     showConflictResolver, openConflictResolver, closeConflictResolver,
+    showCreateViewDialog, openCreateView, closeCreateView,
   }
 }

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, { silent: true })
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at', expect.stringMatching(/^\d{4}-\d{2}-\d{2}$/), { silent: true })
+      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),
@@ -99,8 +99,8 @@ describe('useEntryActions', () => {
         await result.current.handleRestoreNote('/vault/note/test.md')
       })
 
-      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed', { silent: true })
-      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'Trashed at', { silent: true })
+      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,
@@ -119,7 +119,7 @@ describe('useEntryActions', () => {
         await result.current.handleArchiveNote('/vault/note/test.md')
       })
 
-      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', 'archived', true, { silent: 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)
@@ -146,7 +146,7 @@ describe('useEntryActions', () => {
         await result.current.handleUnarchiveNote('/vault/note/test.md')
       })
 
-      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', 'archived', { silent: true })
+      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')
@@ -521,6 +521,94 @@ describe('useEntryActions', () => {
     })
   })
 
+  describe('handleToggleFavorite', () => {
+    it('favorites a note: writes _favorite and _favorite_index', async () => {
+      const entry = makeEntry({ path: '/vault/note/test.md', favorite: false, favoriteIndex: null })
+      const { result } = setup([entry])
+
+      await act(async () => {
+        await result.current.handleToggleFavorite('/vault/note/test.md')
+      })
+
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', '_favorite', true, { silent: true })
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/note/test.md', '_favorite_index', 1, { silent: true })
+      expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', { favorite: true, favoriteIndex: 1 })
+      expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
+    })
+
+    it('unfavorites a note: deletes _favorite and _favorite_index', async () => {
+      const entry = makeEntry({ path: '/vault/note/test.md', favorite: true, favoriteIndex: 0 })
+      const { result } = setup([entry])
+
+      await act(async () => {
+        await result.current.handleToggleFavorite('/vault/note/test.md')
+      })
+
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', '_favorite', { silent: true })
+      expect(handleDeleteProperty).toHaveBeenCalledWith('/vault/note/test.md', '_favorite_index', { silent: true })
+      expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', { favorite: false, favoriteIndex: null })
+    })
+
+    it('assigns next available index when favoriting', async () => {
+      const entries = [
+        makeEntry({ path: '/vault/a.md', favorite: true, favoriteIndex: 3 }),
+        makeEntry({ path: '/vault/b.md', favorite: true, favoriteIndex: 5 }),
+        makeEntry({ path: '/vault/c.md', favorite: false, favoriteIndex: null }),
+      ]
+      const { result } = setup(entries)
+
+      await act(async () => {
+        await result.current.handleToggleFavorite('/vault/c.md')
+      })
+
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/c.md', '_favorite_index', 6, { silent: true })
+    })
+
+    it('rolls back on failure', async () => {
+      const entry = makeEntry({ path: '/vault/note/test.md', favorite: false, favoriteIndex: null })
+      handleUpdateFrontmatter.mockRejectedValueOnce(new Error('disk full'))
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+      const { result } = setup([entry])
+
+      await act(async () => {
+        await result.current.handleToggleFavorite('/vault/note/test.md')
+      })
+
+      expect(updateEntry).toHaveBeenCalledWith('/vault/note/test.md', { favorite: false, favoriteIndex: null })
+      expect(setToastMessage).toHaveBeenCalledWith('Failed to favorite — rolled back')
+      errorSpy.mockRestore()
+    })
+
+    it('does nothing if entry not found', async () => {
+      const { result } = setup([])
+
+      await act(async () => {
+        await result.current.handleToggleFavorite('/vault/nonexistent.md')
+      })
+
+      expect(handleUpdateFrontmatter).not.toHaveBeenCalled()
+      expect(handleDeleteProperty).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('handleReorderFavorites', () => {
+    it('updates _favorite_index for all reordered paths', async () => {
+      const { result } = setup()
+
+      await act(async () => {
+        await result.current.handleReorderFavorites(['/vault/a.md', '/vault/b.md', '/vault/c.md'])
+      })
+
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/a.md', '_favorite_index', 0, { silent: true })
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/b.md', '_favorite_index', 1, { silent: true })
+      expect(handleUpdateFrontmatter).toHaveBeenCalledWith('/vault/c.md', '_favorite_index', 2, { silent: true })
+      expect(updateEntry).toHaveBeenCalledWith('/vault/a.md', { favoriteIndex: 0 })
+      expect(updateEntry).toHaveBeenCalledWith('/vault/b.md', { favoriteIndex: 1 })
+      expect(updateEntry).toHaveBeenCalledWith('/vault/c.md', { favoriteIndex: 2 })
+      expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
+    })
+  })
+
   describe('onBeforeAction callback', () => {
     function setupWithBeforeAction(onBeforeAction: ReturnType<typeof vi.fn>) {
       return renderHook(() =>

src/hooks/useEntryActions.ts

@@ -35,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, { silent: true })
-      await handleUpdateFrontmatter(path, 'Trashed at', now, { silent: true })
+      await handleUpdateFrontmatter(path, '_trashed', true, { silent: true })
+      await handleUpdateFrontmatter(path, '_trashed_at', now, { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { trashed: false, trashedAt: null })
@@ -50,8 +50,8 @@ export function useEntryActions({
     updateEntry(path, { trashed: false, trashedAt: null })
     setToastMessage('Note restored from trash')
     try {
-      await handleDeleteProperty(path, 'Trashed', { silent: true })
-      await handleDeleteProperty(path, 'Trashed at', { silent: true })
+      await handleDeleteProperty(path, '_trashed', { silent: true })
+      await handleDeleteProperty(path, '_trashed_at', { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { trashed: true, trashedAt: Date.now() / 1000 })
@@ -66,7 +66,7 @@ export function useEntryActions({
     updateEntry(path, { archived: true })
     setToastMessage('Note archived')
     try {
-      await handleUpdateFrontmatter(path, 'archived', true, { silent: true })
+      await handleUpdateFrontmatter(path, '_archived', true, { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { archived: false })
@@ -80,7 +80,7 @@ export function useEntryActions({
     updateEntry(path, { archived: false })
     setToastMessage('Note unarchived')
     try {
-      await handleDeleteProperty(path, 'archived', { silent: true })
+      await handleDeleteProperty(path, '_archived', { silent: true })
       onFrontmatterPersisted?.()
     } catch (err) {
       updateEntry(path, { archived: true })
@@ -125,6 +125,42 @@ export function useEntryActions({
     onFrontmatterPersisted?.()
   }, [entries, handleUpdateFrontmatter, handleDeleteProperty, updateEntry, createTypeEntry, onFrontmatterPersisted])
 
+  const handleToggleFavorite = useCallback(async (path: string) => {
+    const entry = entries.find((e) => e.path === path)
+    if (!entry) return
+    if (entry.favorite) {
+      updateEntry(path, { favorite: false, favoriteIndex: null })
+      try {
+        await handleDeleteProperty(path, '_favorite', { silent: true })
+        await handleDeleteProperty(path, '_favorite_index', { silent: true })
+        onFrontmatterPersisted?.()
+      } catch {
+        updateEntry(path, { favorite: true, favoriteIndex: entry.favoriteIndex })
+        setToastMessage('Failed to unfavorite — rolled back')
+      }
+    } else {
+      const maxIndex = entries.filter((e) => e.favorite).reduce((max, e) => Math.max(max, e.favoriteIndex ?? 0), 0)
+      const newIndex = maxIndex + 1
+      updateEntry(path, { favorite: true, favoriteIndex: newIndex })
+      try {
+        await handleUpdateFrontmatter(path, '_favorite', true, { silent: true })
+        await handleUpdateFrontmatter(path, '_favorite_index', newIndex, { silent: true })
+        onFrontmatterPersisted?.()
+      } catch {
+        updateEntry(path, { favorite: false, favoriteIndex: null })
+        setToastMessage('Failed to favorite — rolled back')
+      }
+    }
+  }, [entries, updateEntry, handleUpdateFrontmatter, handleDeleteProperty, setToastMessage, onFrontmatterPersisted])
+
+  const handleReorderFavorites = useCallback(async (orderedPaths: string[]) => {
+    for (let i = 0; i < orderedPaths.length; i++) {
+      updateEntry(orderedPaths[i], { favoriteIndex: i })
+      await handleUpdateFrontmatter(orderedPaths[i], '_favorite_index', i, { silent: true })
+    }
+    onFrontmatterPersisted?.()
+  }, [updateEntry, handleUpdateFrontmatter, onFrontmatterPersisted])
+
   const handleToggleTypeVisibility = useCallback(async (typeName: string) => {
     const typeEntry = await findOrCreateType(entries, typeName, createTypeEntry)
     if (typeEntry.visible === false) {
@@ -137,5 +173,5 @@ export function useEntryActions({
     onFrontmatterPersisted?.()
   }, [entries, handleUpdateFrontmatter, handleDeleteProperty, updateEntry, createTypeEntry, onFrontmatterPersisted])
 
-  return { handleTrashNote, handleRestoreNote, handleArchiveNote, handleUnarchiveNote, handleCustomizeType, handleReorderSections, handleUpdateTypeTemplate, handleRenameSection, handleToggleTypeVisibility }
+  return { handleTrashNote, handleRestoreNote, handleArchiveNote, handleUnarchiveNote, handleCustomizeType, handleReorderSections, handleUpdateTypeTemplate, handleRenameSection, handleToggleTypeVisibility, handleToggleFavorite, handleReorderFavorites }
 }

src/hooks/useNoteActions.test.ts

@@ -217,24 +217,24 @@ describe('entryMatchesTarget', () => {
 describe('buildNoteContent', () => {
   it('generates frontmatter with status for regular types', () => {
     const content = buildNoteContent('My Note', 'Note', 'Active')
-    expect(content).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n\n# My Note\n\n')
+    expect(content).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n')
   })
 
   it('omits status when null', () => {
     const content = buildNoteContent('AI', 'Topic', null)
-    expect(content).toBe('---\ntitle: AI\ntype: Topic\n---\n\n# AI\n\n')
+    expect(content).toBe('---\ntitle: AI\ntype: Topic\n---\n')
   })
 
   it('includes template body when provided', () => {
     const content = buildNoteContent('My Project', 'Project', 'Active', '## Objective\n\n## Notes\n\n')
-    expect(content).toContain('# My Project')
+    expect(content).not.toContain('# My Project')
     expect(content).toContain('## Objective')
     expect(content).toContain('## Notes')
   })
 
   it('ignores null template', () => {
     const content = buildNoteContent('My Note', 'Note', 'Active', null)
-    expect(content).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n\n# My Note\n\n')
+    expect(content).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n')
   })
 })
 
@@ -319,7 +319,7 @@ describe('resolveNewType', () => {
     expect(entry.isA).toBe('Type')
     expect(entry.status).toBeNull()
     expect(content).toContain('type: Type')
-    expect(content).toContain('# Recipe')
+    expect(content).not.toContain('# Recipe')
   })
 
   it('uses provided vault path instead of hardcoded path', () => {
@@ -468,6 +468,24 @@ describe('contentToEntryPatch', () => {
     const content = '---\ntype: Note\ncustom: value\n---\n'
     expect(contentToEntryPatch(content)).toEqual({ isA: 'Note' })
   })
+
+  it('preserves _favorite_index as a number (not null)', () => {
+    const content = '---\n_favorite: true\n_favorite_index: 2\n---\nBody'
+    const patch = contentToEntryPatch(content)
+    expect(patch.favorite).toBe(true)
+    expect(patch.favoriteIndex).toBe(2)
+  })
+
+  it('preserves _favorite_index: 0 as number 0', () => {
+    const content = '---\n_favorite: true\n_favorite_index: 0\n---\nBody'
+    const patch = contentToEntryPatch(content)
+    expect(patch.favoriteIndex).toBe(0)
+  })
+
+  it('preserves order as a number', () => {
+    const content = '---\ntype: Type\norder: 3\n---\n'
+    expect(contentToEntryPatch(content)).toEqual({ isA: 'Type', order: 3 })
+  })
 })
 
 describe('todayDateString', () => {
@@ -491,9 +509,9 @@ describe('buildDailyNoteContent', () => {
     expect(content).toContain('## Reflections')
   })
 
-  it('includes H1 heading with the date', () => {
+  it('does not include H1 heading with the date', () => {
     const content = buildDailyNoteContent('2026-03-02')
-    expect(content).toContain('# 2026-03-02')
+    expect(content).not.toMatch(/^# /m)
   })
 })
 

src/hooks/useNoteCreation.test.ts

@@ -116,11 +116,11 @@ describe('entryMatchesTarget', () => {
 
 describe('buildNoteContent', () => {
   it('generates frontmatter with status', () => {
-    expect(buildNoteContent('My Note', 'Note', 'Active')).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n\n# My Note\n\n')
+    expect(buildNoteContent('My Note', 'Note', 'Active')).toBe('---\ntitle: My Note\ntype: Note\nstatus: Active\n---\n')
   })
 
   it('omits status when null', () => {
-    expect(buildNoteContent('AI', 'Topic', null)).toBe('---\ntitle: AI\ntype: Topic\n---\n\n# AI\n\n')
+    expect(buildNoteContent('AI', 'Topic', null)).toBe('---\ntitle: AI\ntype: Topic\n---\n')
   })
 
   it('includes template body when provided', () => {

src/hooks/useNoteCreation.ts

@@ -19,7 +19,7 @@ export function buildNewEntry({ path, slug, title, type, status }: NewEntryParam
     aliases: [], belongsTo: [], relatedTo: [],
     status, archived: false, trashed: false, trashedAt: null,
     modifiedAt: now, createdAt: now, fileSize: 0,
-    snippet: '', wordCount: 0, relationships: {}, icon: null, color: null, order: null, outgoingLinks: [], sidebarLabel: null, template: null, sort: null, view: null, visible: null, properties: {},
+    snippet: '', wordCount: 0, relationships: {}, icon: null, color: null, order: null, outgoingLinks: [], sidebarLabel: null, template: null, sort: null, view: null, visible: null, properties: {}, favorite: false, favoriteIndex: null,
   }
 }
 
@@ -66,8 +66,8 @@ export function buildNoteContent(title: string, type: string, status: string | n
   const lines = ['---', `title: ${title}`, `type: ${type}`]
   if (status) lines.push(`status: ${status}`)
   lines.push('---')
-  const body = template ? `\n${template}` : '\n'
-  return `${lines.join('\n')}\n\n# ${title}\n${body}`
+  const body = template ? `\n${template}` : ''
+  return `${lines.join('\n')}\n${body}`
 }
 
 export function resolveNewNote(title: string, type: string, vaultPath: string, template?: string | null): { entry: VaultEntry; content: string } {
@@ -80,7 +80,7 @@ export function resolveNewNote(title: string, type: string, vaultPath: string, t
 export function resolveNewType(typeName: string, vaultPath: string): { entry: VaultEntry; content: string } {
   const slug = slugify(typeName)
   const entry = buildNewEntry({ path: `${vaultPath}/${slug}.md`, slug, title: typeName, type: 'Type', status: null })
-  return { entry, content: `---\ntype: Type\n---\n\n# ${typeName}\n\n` }
+  return { entry, content: `---\ntype: Type\n---\n` }
 }
 
 export function todayDateString(): string {
@@ -89,7 +89,7 @@ export function todayDateString(): string {
 
 export function buildDailyNoteContent(date: string): string {
   const lines = ['---', `title: ${date}`, 'type: Journal', `date: ${date}`, '---']
-  return `${lines.join('\n')}\n\n# ${date}\n\n## Intentions\n\n\n\n## Reflections\n\n`
+  return `${lines.join('\n')}\n\n## Intentions\n\n\n\n## Reflections\n\n`
 }
 
 export function resolveDailyNote(date: string, vaultPath: string): { entry: VaultEntry; content: string } {

src/hooks/usePropertyPanelState.ts

@@ -12,7 +12,7 @@ import { containsWikilinks } from '../components/DynamicPropertiesPanel'
 
 // Keys to skip showing in Properties (handled by dedicated UI or internal)
 // 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'])
+const SKIP_KEYS = new Set(['aliases', 'workspace', 'title', 'type', 'is_a', 'is a', '_trashed', 'trashed', '_trashed_at', 'trashed_at', 'trashed at', '_archived', 'archived', 'archived_at', 'icon', '_favorite', '_favorite_index'])
 
 function coerceValue(raw: string): FrontmatterValue {
   if (raw.toLowerCase() === 'true') return true

src/hooks/useTabManagement.ts

@@ -73,13 +73,15 @@ export function useTabManagement() {
 
   /** Open a note — replaces the current note (single-note model). */
   const handleSelectNote = useCallback(async (entry: VaultEntry) => {
+    // Binary files cannot be opened
+    if (entry.fileKind === 'binary') return
     // Already viewing this note — no-op
     if (tabsRef.current.some(t => t.entry.path === entry.path)) {
       setActiveTabPath(entry.path)
       return
     }
     const seq = ++navSeqRef.current
-    await syncNoteTitle(entry.path)
+    if (!entry.fileKind || entry.fileKind === 'markdown') await syncNoteTitle(entry.path)
     try {
       const content = await loadNoteContent(entry.path)
       if (navSeqRef.current === seq) {
@@ -104,6 +106,8 @@ export function useTabManagement() {
   }, [])
 
   const handleReplaceActiveTab = useCallback(async (entry: VaultEntry) => {
+    // Binary files cannot be opened
+    if (entry.fileKind === 'binary') return
     // In single-note model, replace is the same as select
     if (tabsRef.current.some(t => t.entry.path === entry.path)) {
       setActiveTabPath(entry.path)

src/hooks/useVaultLoader.test.ts

@@ -424,6 +424,32 @@ describe('useVaultLoader', () => {
     })
   })
 
+  describe('reloadFolders', () => {
+    it('refreshes folder tree from backend', async () => {
+      const folders = [{ name: 'projects', path: 'projects', children: [] }]
+      mockInvokeFn.mockImplementation(((cmd: string) => {
+        if (cmd === 'list_vault') return Promise.resolve(mockEntries)
+        if (cmd === 'get_modified_files') return Promise.resolve([])
+        if (cmd === 'list_vault_folders') return Promise.resolve(folders)
+        return Promise.resolve(null)
+      }) as typeof defaultMockInvoke)
+
+      const { result } = await renderVaultLoader()
+
+      expect(result.current.folders).toEqual(folders)
+
+      const updatedFolders = [...folders, { name: 'journal', path: 'journal', children: [] }]
+      mockInvokeFn.mockImplementation(((cmd: string) => {
+        if (cmd === 'list_vault_folders') return Promise.resolve(updatedFolders)
+        return defaultMockInvoke(cmd)
+      }) as typeof defaultMockInvoke)
+
+      await act(async () => { await result.current.reloadFolders() })
+
+      expect(result.current.folders).toEqual(updatedFolders)
+    })
+  })
+
   describe('loadModifiedFiles', () => {
     it('refreshes modified files list', async () => {
       const { result } = renderHook(() => useVaultLoader('/vault'))

src/hooks/useVaultLoader.ts

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useState, startTransition } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from '../mock-tauri'
-import type { VaultEntry, FolderNode, GitCommit, ModifiedFile, NoteStatus, GitPushResult } from '../types'
+import type { VaultEntry, FolderNode, GitCommit, ModifiedFile, NoteStatus, GitPushResult, ViewFile } from '../types'
 import { clearPrefetchCache } from './useTabManagement'
 
 function tauriCall<T>(command: string, tauriArgs: Record<string, unknown>, mockArgs?: Record<string, unknown>): Promise<T> {
@@ -90,6 +90,7 @@ export function resolveNoteStatus(
 export function useVaultLoader(vaultPath: string) {
   const [entries, setEntries] = useState<VaultEntry[]>([])
   const [folders, setFolders] = useState<FolderNode[]>([])
+  const [views, setViews] = useState<ViewFile[]>([])
   const [modifiedFiles, setModifiedFiles] = useState<ModifiedFile[]>([])
   const [modifiedFilesError, setModifiedFilesError] = useState<string | null>(null)
   const tracker = useNewNoteTracker()
@@ -98,13 +99,16 @@ export function useVaultLoader(vaultPath: string) {
 
   useEffect(() => {
     // eslint-disable-next-line react-hooks/set-state-in-effect -- clear stale data then load new vault
-    setEntries([]); setFolders([]); setModifiedFiles([]); setModifiedFilesError(null); tracker.clear(); unsaved.clearAll()
+    setEntries([]); setFolders([]); setViews([]); setModifiedFiles([]); setModifiedFilesError(null); tracker.clear(); unsaved.clearAll()
     loadVaultData(vaultPath)
       .then(({ entries: e }) => { setEntries(e) })
       .catch((err) => console.warn('Vault scan failed:', err))
     tauriCall<FolderNode[]>('list_vault_folders', { path: vaultPath })
       .then((f) => { setFolders(f ?? []) })
       .catch(() => { /* folders are optional — ignore errors */ })
+    tauriCall<ViewFile[]>('list_views', { vaultPath })
+      .then((v) => { setViews(v ?? []) })
+      .catch(() => { /* views are optional — ignore errors */ })
   }, [vaultPath]) // eslint-disable-line react-hooks/exhaustive-deps -- tracker.clear is stable
 
   const loadModifiedFiles = useCallback(async () => {
@@ -169,6 +173,13 @@ export function useVaultLoader(vaultPath: string) {
   const commitAndPush = useCallback((message: string): Promise<GitPushResult> =>
     commitWithPush(vaultPath, message), [vaultPath])
 
+  const reloadFolders = useCallback(
+    () => tauriCall<FolderNode[]>('list_vault_folders', { path: vaultPath })
+      .then((f) => { setFolders(f ?? []) })
+      .catch(() => { /* folders are optional — ignore errors */ }),
+    [vaultPath],
+  )
+
   const reloadVault = useCallback(
     () => {
       clearPrefetchCache()
@@ -179,11 +190,17 @@ export function useVaultLoader(vaultPath: string) {
     [vaultPath, loadModifiedFiles],
   )
 
+  const reloadViews = useCallback(async () => {
+    try {
+      setViews(await tauriCall<ViewFile[]>('list_views', { vaultPath }) ?? [])
+    } catch { /* views are optional */ }
+  }, [vaultPath])
+
   return {
-    entries, folders, modifiedFiles, modifiedFilesError,
+    entries, folders, views, modifiedFiles, modifiedFilesError,
     addEntry, updateEntry, removeEntry, replaceEntry,
     loadModifiedFiles, loadGitHistory, loadDiff, loadDiffAtCommit,
-    getNoteStatus, commitAndPush, reloadVault,
+    getNoteStatus, commitAndPush, reloadVault, reloadFolders, reloadViews,
     addPendingSave: pendingSave.addPendingSave,
     removePendingSave: pendingSave.removePendingSave,
     unsavedPaths: unsaved.unsavedPaths,

src/mock-tauri/mock-entries.ts

@@ -37,6 +37,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['q1-2026', 'software-development', 'matteo-cellini', 'maria-bianchi', 'marco-verdi'],
     properties: { Priority: 'High', 'Due date': '2026-06-15', Owner: 'Luca Rossi' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/grow-newsletter.md',
@@ -72,6 +73,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['on-writing-well', 'engineering-leadership-101', 'ai-agents-primer', 'growth', 'writing'],
     properties: { Priority: 'High', Rating: 5, Cadence: 'Weekly', Owner: 'Luca Rossi' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/manage-sponsorships.md',
@@ -101,6 +103,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['matteo-cellini'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/write-weekly-essays.md',
@@ -130,6 +133,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['grow-newsletter'],
     properties: { Owner: 'Luca Rossi', Cadence: 'Weekly' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/run-sponsorships.md',
@@ -159,6 +163,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['manage-sponsorships'],
     properties: { Owner: 'Matteo Cellini', Cadence: 'Weekly' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/stock-screener.md',
@@ -189,6 +194,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['trading', 'algorithmic-trading', 'ema200-backtest-results'],
     properties: { Priority: 'Low', 'Due date': '2026-03-01', Owner: 'Luca Rossi' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/facebook-ads-strategy.md',
@@ -219,6 +225,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['26q1-laputa-app', 'growth', 'ads'],
     properties: { Priority: 'Medium', Rating: 4 },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/budget-allocation.md',
@@ -248,6 +255,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['26q1-laputa-app'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/matteo-cellini.md',
@@ -276,6 +284,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: { Company: 'Acme Corp', Role: 'Engineering Lead' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/maria-bianchi.md',
@@ -304,6 +313,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: { Company: 'TechStart', Role: 'Product Manager' },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/marco-verdi.md',
@@ -332,6 +342,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/elena-russo.md',
@@ -360,6 +371,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/2026-02-14-laputa-app-kickoff.md',
@@ -389,6 +401,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['26q1-laputa-app', 'matteo-cellini'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/software-development.md',
@@ -418,6 +431,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/trading.md',
@@ -447,6 +461,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/on-writing-well.md',
@@ -476,6 +491,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['grow-newsletter'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/engineering-leadership-101.md',
@@ -506,6 +522,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['grow-newsletter', 'software-development'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/ai-agents-primer.md',
@@ -535,6 +552,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: ['grow-newsletter'],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   // --- Type documents ---
   {
@@ -562,6 +580,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/responsibility.md',
@@ -588,6 +607,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/procedure.md',
@@ -614,6 +634,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/experiment.md',
@@ -640,6 +661,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: false,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/person.md',
@@ -666,6 +688,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/event.md',
@@ -692,6 +715,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/topic.md',
@@ -718,6 +742,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/essay.md',
@@ -744,6 +769,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/note.md',
@@ -770,6 +796,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   // --- Custom type documents ---
   {
@@ -797,6 +824,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/recipe.md',
@@ -823,6 +851,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/book.md',
@@ -849,6 +878,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   // --- Instances of custom types ---
   {
@@ -878,6 +908,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/pasta-carbonara.md',
@@ -906,6 +937,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: { Difficulty: 'Easy', 'Prep time': '30 min', Servings: 4 },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/designing-data-intensive-applications.md',
@@ -934,6 +966,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: { Author: 'Martin Kleppmann', Rating: 5, 'Year published': 2017 },
+    favorite: false, favoriteIndex: null,
   },
   // --- Trashed entries ---
   {
@@ -964,6 +997,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/deprecated-api-notes.md',
@@ -992,6 +1026,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/failed-seo-experiment.md',
@@ -1021,6 +1056,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: { Owner: 'Luca Rossi' },
+    favorite: false, favoriteIndex: null,
   },
   // --- Archived entries ---
   {
@@ -1051,6 +1087,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
       'Belongs to': ['[[q3-2025]]'],
       'Type': ['[[project]]'],
     },
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/twitter-thread-experiment.md',
@@ -1080,6 +1117,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
       'Related to': ['[[grow-newsletter]]'],
       'Type': ['[[experiment]]'],
     },
+    favorite: false, favoriteIndex: null,
   },
   // --- Refactoring entries for exact-match search testing ---
   {
@@ -1107,6 +1145,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/refactoring-ideas.md',
@@ -1133,6 +1172,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/refactoring-key-ideas.md',
@@ -1159,6 +1199,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
   {
     path: '/Users/luca/Laputa/refactoring-patterns.md',
@@ -1185,6 +1226,7 @@ export const MOCK_ENTRIES: VaultEntry[] = [
     template: null, sort: null, view: null, visible: null,
     outgoingLinks: [],
     properties: {},
+    favorite: false, favoriteIndex: null,
   },
 ]
 
@@ -1237,6 +1279,7 @@ function generateBulkEntries(count: number): VaultEntry[] {
       sidebarLabel: null,
       template: null, sort: null, view: null, visible: null,
       properties: {},
+      favorite: false, favoriteIndex: null,
     })
   }
   return entries

src/mock-tauri/mock-handlers.ts

@@ -136,6 +136,9 @@ const trimOrNull = (v: string | null | undefined): string | null => v?.trim() ||
 export const mockHandlers: Record<string, (args: any) => any> = {
   list_vault: () => MOCK_ENTRIES,
   list_vault_folders: () => [],
+  list_views: () => [],
+  save_view_cmd: () => {},
+  delete_view_cmd: () => {},
   reload_vault: () => MOCK_ENTRIES,
   reload_vault_entry: (args: { path: string }) => MOCK_ENTRIES.find(e => e.path === args.path) ?? { path: args.path, title: 'Unknown', filename: 'unknown.md', aliases: [], belongsTo: [], relatedTo: [], archived: false, trashed: false, snippet: '', wordCount: 0, fileSize: 0, relationships: {}, outgoingLinks: [], properties: {} },
   sync_note_title: () => false,

src/types.ts

@@ -35,10 +35,17 @@ export interface VaultEntry {
   view: string | null
   /** Whether this Type is visible in the sidebar. Defaults to true when absent. */
   visible: boolean | null
+  /** Whether this note is a user favorite (shown in FAVORITES sidebar section). */
+  favorite: boolean
+  /** Display order within the FAVORITES section (lower = higher). */
+  favoriteIndex: number | null
   /** All wikilink targets found in the note content. Extracted from [[target]] patterns. */
   outgoingLinks: string[]
   /** Custom scalar frontmatter properties (non-relationship, non-structural). */
   properties: Record<string, string | number | boolean | null>
+  /** File kind: "markdown", "text", or "binary". Determines editor behavior.
+   *  Defaults to "markdown" when absent (for backwards compatibility). */
+  fileKind?: 'markdown' | 'text' | 'binary'
 }
 
 export type NoteStatus = 'new' | 'modified' | 'clean' | 'pendingSave' | 'unsaved'
@@ -171,7 +178,7 @@ export interface PulseCommit {
   deleted: number
 }
 
-export type SidebarFilter = 'all' | 'archived' | 'trash' | 'changes' | 'pulse' | 'inbox'
+export type SidebarFilter = 'all' | 'archived' | 'trash' | 'changes' | 'pulse' | 'inbox' | 'favorites'
 
 export type InboxPeriod = 'week' | 'month' | 'quarter' | 'all'
 
@@ -180,6 +187,33 @@ export type SidebarSelection =
   | { kind: 'sectionGroup'; type: string }
   | { kind: 'folder'; path: string }
   | { kind: 'entity'; entry: VaultEntry }
+  | { kind: 'view'; filename: string }
+
+// --- Custom Views ---
+
+export type FilterOp = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'any_of' | 'none_of' | 'is_empty' | 'is_not_empty' | 'before' | 'after'
+
+export interface FilterCondition {
+  field: string
+  op: FilterOp
+  value?: unknown
+}
+
+export type FilterGroup = { all: FilterNode[] } | { any: FilterNode[] }
+export type FilterNode = FilterCondition | FilterGroup
+
+export interface ViewDefinition {
+  name: string
+  icon: string | null
+  color: string | null
+  sort: string | null
+  filters: FilterGroup
+}
+
+export interface ViewFile {
+  filename: string
+  definition: ViewDefinition
+}
 
 /** A node in the vault's folder tree (directories only, no files). */
 export interface FolderNode {

src/utils/frontmatter.test.ts

@@ -2,6 +2,33 @@ import { describe, it, expect } from 'vitest'
 import { parseFrontmatter, detectFrontmatterState } from './frontmatter'
 
 describe('parseFrontmatter', () => {
+  describe('numeric values', () => {
+    it('parses integer values as numbers', () => {
+      const fm = parseFrontmatter('---\n_favorite_index: 2\n---\nBody')
+      expect(fm['_favorite_index']).toBe(2)
+    })
+
+    it('parses zero as number 0', () => {
+      const fm = parseFrontmatter('---\n_favorite_index: 0\n---\nBody')
+      expect(fm['_favorite_index']).toBe(0)
+    })
+
+    it('parses float values as numbers', () => {
+      const fm = parseFrontmatter('---\norder: 3.5\n---\nBody')
+      expect(fm['order']).toBe(3.5)
+    })
+
+    it('parses negative numbers', () => {
+      const fm = parseFrontmatter('---\norder: -1\n---\nBody')
+      expect(fm['order']).toBe(-1)
+    })
+
+    it('does not parse quoted numbers as numbers', () => {
+      const fm = parseFrontmatter('---\nversion: "42"\n---\nBody')
+      expect(fm['version']).toBe('42')
+    })
+  })
+
   describe('boolean-like Yes/No values', () => {
     it('parses Archived: Yes as true', () => {
       const fm = parseFrontmatter('---\nArchived: Yes\n---\nBody')

src/utils/frontmatter.ts

@@ -26,6 +26,7 @@ function parseScalar(value: string): FrontmatterValue {
   const lower = clean.toLowerCase()
   if (lower === 'true' || lower === 'yes') return true
   if (lower === 'false' || lower === 'no') return false
+  if (clean === value && /^-?\d+(\.\d+)?$/.test(clean)) return Number(clean)
   return clean
 }
 

src/utils/noteListHelpers.test.ts

@@ -739,3 +739,38 @@ describe('filterEntries — folder selection', () => {
     expect(result.find(e => e.title === 'Archived')).toBeUndefined()
   })
 })
+
+describe('filterEntries — fileKind filtering', () => {
+  const entries = [
+    makeEntry({ path: '/vault/note.md', title: 'Note', fileKind: 'markdown' }),
+    makeEntry({ path: '/vault/config.yml', title: 'config.yml', fileKind: 'text' }),
+    makeEntry({ path: '/vault/photo.png', title: 'photo.png', fileKind: 'binary' }),
+    makeEntry({ path: '/vault/projects/readme.md', title: 'README', fileKind: 'markdown' }),
+    makeEntry({ path: '/vault/projects/data.json', title: 'data.json', fileKind: 'text' }),
+    makeEntry({ path: '/vault/projects/image.jpg', title: 'image.jpg', fileKind: 'binary' }),
+  ]
+
+  it('all-notes filter only shows markdown files', () => {
+    const result = filterEntries(entries, { kind: 'filter', filter: 'all' })
+    expect(result.map(e => e.title)).toEqual(['Note', 'README'])
+  })
+
+  it('folder view shows all file kinds including binary', () => {
+    const result = filterEntries(entries, { kind: 'folder', path: 'projects' })
+    expect(result.map(e => e.title)).toEqual(['README', 'data.json', 'image.jpg'])
+  })
+
+  it('sectionGroup filter only shows markdown files', () => {
+    const typed = entries.map(e => ({ ...e, isA: 'Note' }))
+    const result = filterEntries(typed, { kind: 'sectionGroup', type: 'Note' })
+    expect(result.map(e => e.title)).toEqual(['Note', 'README'])
+  })
+
+  it('entries without fileKind are treated as markdown', () => {
+    const legacy = [
+      makeEntry({ path: '/vault/old.md', title: 'Old' }),
+    ]
+    const result = filterEntries(legacy, { kind: 'filter', filter: 'all' })
+    expect(result.map(e => e.title)).toEqual(['Old'])
+  })
+})

src/utils/noteListHelpers.ts

@@ -1,4 +1,5 @@
-import type { VaultEntry, SidebarSelection, InboxPeriod } from '../types'
+import type { VaultEntry, SidebarSelection, InboxPeriod, ViewFile } from '../types'
+import { evaluateView } from './viewFilters'
 import { wikilinkTarget, resolveEntry } from './wikilink'
 
 export type NoteListFilter = 'open' | 'archived' | 'trashed'
@@ -306,6 +307,7 @@ export function buildRelationshipGroups(
 }
 
 const isActive = (e: VaultEntry) => !e.archived && !e.trashed
+const isMarkdown = (e: VaultEntry) => e.fileKind === 'markdown' || !e.fileKind
 
 function applySubFilter(entries: VaultEntry[], subFilter: NoteListFilter): VaultEntry[] {
   if (subFilter === 'archived') return entries.filter((e) => e.archived && !e.trashed)
@@ -318,37 +320,46 @@ function isInFolder(entryPath: string, folderRelPath: string): boolean {
   return entryPath.includes(needle) || entryPath.startsWith(folderRelPath + '/')
 }
 
-function filterByKind(entries: VaultEntry[], selection: SidebarSelection, subFilter?: NoteListFilter): VaultEntry[] {
+function filterByKind(entries: VaultEntry[], selection: SidebarSelection, subFilter?: NoteListFilter, views?: ViewFile[]): VaultEntry[] {
   if (selection.kind === 'entity') return []
+  if (selection.kind === 'view') {
+    const view = views?.find((v) => v.filename === selection.filename)
+    if (!view) return []
+    return evaluateView(view.definition, entries.filter(isMarkdown))
+  }
   if (selection.kind === 'folder') {
+    // Folder view shows ALL files (text + binary), not just markdown
     const folderEntries = entries.filter((e) => isInFolder(e.path, selection.path))
     return subFilter ? applySubFilter(folderEntries, subFilter) : folderEntries.filter(isActive)
   }
   if (selection.kind === 'sectionGroup') {
-    const typeEntries = entries.filter((e) => e.isA === selection.type)
+    const typeEntries = entries.filter((e) => isMarkdown(e) && e.isA === selection.type)
     return subFilter ? applySubFilter(typeEntries, subFilter) : typeEntries.filter(isActive)
   }
-  if (selection.filter === 'all' && subFilter) return applySubFilter(entries, subFilter)
-  return filterByFilterType(entries, selection.filter)
+  // Non-folder views: only markdown files
+  const mdEntries = entries.filter(isMarkdown)
+  if (selection.filter === 'all' && subFilter) return applySubFilter(mdEntries, subFilter)
+  return filterByFilterType(mdEntries, selection.filter)
 }
 
 function filterByFilterType(entries: VaultEntry[], filter: string): VaultEntry[] {
   if (filter === 'all') return entries.filter(isActive)
   if (filter === 'archived') return entries.filter((e) => e.archived && !e.trashed)
   if (filter === 'trash') return entries.filter((e) => e.trashed)
+  if (filter === 'favorites') return entries.filter((e) => e.favorite && !e.archived && !e.trashed)
   if (filter === 'pulse') return []
   return []
 }
 
-export function filterEntries(entries: VaultEntry[], selection: SidebarSelection, subFilter?: NoteListFilter): VaultEntry[] {
-  return filterByKind(entries, selection, subFilter)
+export function filterEntries(entries: VaultEntry[], selection: SidebarSelection, subFilter?: NoteListFilter, views?: ViewFile[]): VaultEntry[] {
+  return filterByKind(entries, selection, subFilter, views)
 }
 
 /** Count notes per sub-filter for a given type. */
 export function countByFilter(entries: VaultEntry[], type: string): Record<NoteListFilter, number> {
   let open = 0, archived = 0, trashed = 0
   for (const e of entries) {
-    if (e.isA !== type) continue
+    if (!isMarkdown(e) || e.isA !== type) continue
     if (e.trashed) trashed++
     else if (e.archived) archived++
     else open++
@@ -360,6 +371,7 @@ export function countByFilter(entries: VaultEntry[], type: string): Record<NoteL
 export function countAllByFilter(entries: VaultEntry[]): Record<NoteListFilter, number> {
   let open = 0, archived = 0, trashed = 0
   for (const e of entries) {
+    if (!isMarkdown(e)) continue
     if (e.trashed) trashed++
     else if (e.archived) archived++
     else open++

src/utils/viewFilters.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest'
+import { evaluateView } from './viewFilters'
+import type { VaultEntry, ViewDefinition } from '../types'
+
+const NOW = Math.floor(Date.now() / 1000)
+
+function makeEntry(overrides: Partial<VaultEntry>): VaultEntry {
+  return {
+    path: '/vault/test.md', filename: 'test.md', title: 'Test', isA: null,
+    aliases: [], belongsTo: [], relatedTo: [], status: null,
+    archived: false, trashed: false, trashedAt: null,
+    modifiedAt: NOW, createdAt: NOW, fileSize: 100, snippet: '',
+    wordCount: 0, relationships: {}, icon: null, color: null,
+    order: null, sidebarLabel: null, template: null, sort: null, view: null,
+    visible: null, favorite: false, favoriteIndex: null,
+    outgoingLinks: [], properties: {},
+    ...overrides,
+  }
+}
+
+describe('evaluateView', () => {
+  it('filters by type equals', () => {
+    const view: ViewDefinition = {
+      name: 'Projects', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'type', op: 'equals', value: 'Project' }] },
+    }
+    const entries = [
+      makeEntry({ isA: 'Project', title: 'P1' }),
+      makeEntry({ isA: 'Note', title: 'N1' }),
+      makeEntry({ isA: 'Project', title: 'P2' }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['P1', 'P2'])
+  })
+
+  it('filters by status not_equals', () => {
+    const view: ViewDefinition = {
+      name: 'Active', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'status', op: 'not_equals', value: 'done' }] },
+    }
+    const entries = [
+      makeEntry({ status: 'active', title: 'A' }),
+      makeEntry({ status: 'done', title: 'D' }),
+      makeEntry({ status: null, title: 'N' }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['A', 'N'])
+  })
+
+  it('filters by relationship contains wikilink', () => {
+    const view: ViewDefinition = {
+      name: 'Related', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'Related to', op: 'contains', value: '[[laputa-app]]' }] },
+    }
+    const entries = [
+      makeEntry({ title: 'Match', relationships: { 'Related to': ['[[laputa-app|Laputa App]]', '[[other]]'] } }),
+      makeEntry({ title: 'No match', relationships: { 'Related to': ['[[something]]'] } }),
+      makeEntry({ title: 'No rels', relationships: {} }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['Match'])
+  })
+
+  it('evaluates nested AND/OR groups', () => {
+    const view: ViewDefinition = {
+      name: 'Complex', icon: null, color: null, sort: null,
+      filters: {
+        any: [
+          { all: [{ field: 'type', op: 'equals', value: 'Project' }, { field: 'status', op: 'equals', value: 'active' }] },
+          { all: [{ field: 'type', op: 'equals', value: 'Event' }] },
+        ],
+      },
+    }
+    const entries = [
+      makeEntry({ isA: 'Project', status: 'active', title: 'Active Proj' }),
+      makeEntry({ isA: 'Project', status: 'done', title: 'Done Proj' }),
+      makeEntry({ isA: 'Event', title: 'My Event' }),
+      makeEntry({ isA: 'Note', title: 'Random' }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['Active Proj', 'My Event'])
+  })
+
+  it('filters by is_empty and is_not_empty', () => {
+    const view: ViewDefinition = {
+      name: 'Has Status', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'status', op: 'is_not_empty' }] },
+    }
+    const entries = [
+      makeEntry({ status: 'active', title: 'Has' }),
+      makeEntry({ status: null, title: 'Null' }),
+      makeEntry({ status: '', title: 'Empty' }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['Has'])
+  })
+
+  it('excludes archived and trashed entries', () => {
+    const view: ViewDefinition = {
+      name: 'All', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'type', op: 'equals', value: 'Note' }] },
+    }
+    const entries = [
+      makeEntry({ isA: 'Note', title: 'Active' }),
+      makeEntry({ isA: 'Note', title: 'Archived', archived: true }),
+      makeEntry({ isA: 'Note', title: 'Trashed', trashed: true }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['Active'])
+  })
+
+  it('filters by property field', () => {
+    const view: ViewDefinition = {
+      name: 'By Owner', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'Owner', op: 'equals', value: 'Luca' }] },
+    }
+    const entries = [
+      makeEntry({ title: 'Match', properties: { Owner: 'Luca' } }),
+      makeEntry({ title: 'Other', properties: { Owner: 'Brian' } }),
+      makeEntry({ title: 'None', properties: {} }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['Match'])
+  })
+
+  it('filters with any_of operator', () => {
+    const view: ViewDefinition = {
+      name: 'Multi', icon: null, color: null, sort: null,
+      filters: { all: [{ field: 'status', op: 'any_of', value: ['active', 'in progress'] }] },
+    }
+    const entries = [
+      makeEntry({ status: 'active', title: 'A' }),
+      makeEntry({ status: 'In Progress', title: 'B' }),
+      makeEntry({ status: 'done', title: 'C' }),
+    ]
+    const result = evaluateView(view, entries)
+    expect(result.map((e) => e.title)).toEqual(['A', 'B'])
+  })
+})

src/utils/viewFilters.ts

@@ -0,0 +1,112 @@
+import type { VaultEntry, ViewDefinition, FilterGroup, FilterNode, FilterCondition } from '../types'
+
+/** Evaluate a view's filters against a list of entries, returning only matches. */
+export function evaluateView(definition: ViewDefinition, entries: VaultEntry[]): VaultEntry[] {
+  return entries.filter((e) => !e.trashed && !e.archived && evaluateGroup(definition.filters, e))
+}
+
+function evaluateGroup(group: FilterGroup, entry: VaultEntry): boolean {
+  if ('all' in group) return group.all.every((node) => evaluateNode(node, entry))
+  if ('any' in group) return group.any.some((node) => evaluateNode(node, entry))
+  return true
+}
+
+function isFilterGroup(node: FilterNode): node is FilterGroup {
+  return 'all' in node || 'any' in node
+}
+
+function evaluateNode(node: FilterNode, entry: VaultEntry): boolean {
+  if (isFilterGroup(node)) return evaluateGroup(node, entry)
+  return evaluateCondition(node as FilterCondition, entry)
+}
+
+function resolveField(entry: VaultEntry, field: string): { scalar?: string | number | boolean | null; array?: string[] } {
+  const lower = field.toLowerCase()
+  if (lower === 'type' || lower === 'isa') return { scalar: entry.isA }
+  if (lower === 'status') return { scalar: entry.status }
+  if (lower === 'title') return { scalar: entry.title }
+  if (lower === 'filename') return { scalar: entry.filename }
+  if (lower === 'archived') return { scalar: entry.archived }
+  if (lower === 'trashed') return { scalar: entry.trashed }
+  if (lower === 'favorite') return { scalar: entry.favorite }
+
+  // Check relationships first (returns string[])
+  const relKey = Object.keys(entry.relationships).find((k) => k.toLowerCase() === lower)
+  if (relKey) return { array: entry.relationships[relKey] }
+
+  // Then properties (returns scalar)
+  const propKey = Object.keys(entry.properties).find((k) => k.toLowerCase() === lower)
+  if (propKey) return { scalar: entry.properties[propKey] }
+
+  return { scalar: null }
+}
+
+function wikilinkStem(raw: string): string {
+  let s = raw.trim()
+  if (s.startsWith('[[')) s = s.slice(2)
+  if (s.endsWith(']]')) s = s.slice(0, -2)
+  const pipe = s.indexOf('|')
+  if (pipe >= 0) s = s.substring(0, pipe)
+  return s.toLowerCase()
+}
+
+function toString(v: unknown): string {
+  if (v == null) return ''
+  if (typeof v === 'string') return v
+  return String(v)
+}
+
+function evaluateCondition(cond: FilterCondition, entry: VaultEntry): boolean {
+  const resolved = resolveField(entry, cond.field)
+  const { op, value } = cond
+
+  if (op === 'is_empty') {
+    if (resolved.array) return resolved.array.length === 0
+    const s = resolved.scalar
+    return s == null || s === '' || s === false
+  }
+  if (op === 'is_not_empty') {
+    if (resolved.array) return resolved.array.length > 0
+    const s = resolved.scalar
+    return s != null && s !== '' && s !== false
+  }
+
+  const condVal = toString(value)
+
+  if (resolved.array) {
+    const stem = wikilinkStem(condVal)
+    const arrayMatch = (arr: string[]) => arr.some((item) => wikilinkStem(item) === stem)
+    if (op === 'contains') return arrayMatch(resolved.array)
+    if (op === 'not_contains') return !arrayMatch(resolved.array)
+    if (op === 'any_of' && Array.isArray(value)) {
+      const stems = (value as string[]).map(wikilinkStem)
+      return resolved.array.some((item) => stems.includes(wikilinkStem(item)))
+    }
+    if (op === 'none_of' && Array.isArray(value)) {
+      const stems = (value as string[]).map(wikilinkStem)
+      return !resolved.array.some((item) => stems.includes(wikilinkStem(item)))
+    }
+    return false
+  }
+
+  const fieldStr = toString(resolved.scalar).toLowerCase()
+  const condStr = condVal.toLowerCase()
+
+  if (op === 'equals') return fieldStr === condStr
+  if (op === 'not_equals') return fieldStr !== condStr
+  if (op === 'contains') return fieldStr.includes(condStr)
+  if (op === 'not_contains') return !fieldStr.includes(condStr)
+  if (op === 'any_of' && Array.isArray(value)) return (value as string[]).some((v) => toString(v).toLowerCase() === fieldStr)
+  if (op === 'none_of' && Array.isArray(value)) return !(value as string[]).some((v) => toString(v).toLowerCase() === fieldStr)
+
+  // Date comparisons
+  if (op === 'before' || op === 'after') {
+    const ts = typeof resolved.scalar === 'number' ? resolved.scalar : null
+    if (!ts) return false
+    const target = Date.parse(condVal) / 1000
+    if (isNaN(target)) return false
+    return op === 'before' ? ts < target : ts > target
+  }
+
+  return false
+}

tests/integration/vault-workflows.spec.ts

@@ -138,7 +138,7 @@ test('create note saves file to disk with correct slug', async ({ page }) => {
   }).toPass({ timeout: 5_000 })
 
   const content = fs.readFileSync(expectedPath, 'utf-8')
-  expect(content).toContain('# Untitled note')
+  expect(content).not.toContain('# Untitled note')
   expect(content).toContain('type: Note')
 })