feat: rebuild FilterBuilder with shadcn/ui components

Replace native HTML elements with design system components:
- Operator <select> → shadcn Select dropdown
- Field <input>+<datalist> → shadcn Select with all available fields
- Value input → shadcn Select (when suggestions available) or Input
- Date input (type="date") for before/after operators
- Remove button → shadcn Button variant="ghost"
- AND/OR toggle → shadcn Button variant="outline" with rounded-full

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

.claude/commands/laputa-done.md

@@ -0,0 +1,42 @@
+# /laputa-done <task_id>
+
+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**.
+
+⚠️ A task is NOT done until the push succeeds. If the push is blocked by the pre-push hook (clippy, tests, CodeScene, build):
+- Read the error
+- Fix it (never use `--no-verify`)
+- Commit the fix and push again
+- Repeat until push exits with code 0
+
+## Steps
+
+**1. Add completion comment to the task**
+
+Summarize what was done — this is the context Luca and Brian will read in Todoist:
+
+```bash
+curl -s -X POST "https://api.todoist.com/api/v1/comments" \
+  -H "Authorization: Bearer $TODOIST_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "task_id": "$ARGUMENTS",
+    "content": "✅ Implementation complete.\n\n**What changed:** [brief summary of the implementation]\n**ADR:** [if an ADR was created, reference it here; otherwise omit]\n**Playwright:** all tests pass\n**Native QA:** tested with pnpm tauri dev — [describe what was tested and what was observed]"
+  }'
+```
+
+**2. Move task to In Review**
+
+```bash
+curl -s -X POST "https://api.todoist.com/api/v1/tasks/$ARGUMENTS/move" \
+  -H "Authorization: Bearer $TODOIST_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"section_id": "6g3XjX33FF4Vj86M"}'
+```
+
+**3. Pick the next task**
+
+Run `/laputa-next-task` to get the next task and start working on it immediately.
+
+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

@@ -0,0 +1,56 @@
+# /laputa-next-task
+
+Pick the next Laputa task from Todoist and move it to In Progress.
+
+Priority order: **To Rework** first, then **Open** (sorted by Todoist priority p1→p4).
+
+## Steps
+
+1. Fetch tasks from To Rework (`6g6QqvR9rRpvJWvv`), then Open (`6g3XjWR832hVHhCM`)
+2. Sort each section by priority (p1 highest)
+3. Take the first available task
+4. Move it to In Progress (`6g3XjWjfmJFcGgHM`) via Todoist API:
+
+```bash
+curl -s -X POST "https://api.todoist.com/api/v1/tasks/<task_id>/move" \
+  -H "Authorization: Bearer $TODOIST_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"section_id": "6g3XjWjfmJFcGgHM"}'
+```
+
+5. Add a "started" comment to the task:
+
+```bash
+curl -s -X POST "https://api.todoist.com/api/v1/comments" \
+  -H "Authorization: Bearer $TODOIST_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"task_id": "<task_id>", "content": "🚀 Starting work. [Brief description of approach or what needs to be fixed]"}'
+```
+
+6. Fetch the full task details (description, comments) from Todoist:
+
+```bash
+curl -s "https://api.todoist.com/api/v1/tasks/<task_id>" \
+  -H "Authorization: Bearer $TODOIST_API_KEY"
+
+curl -s "https://api.todoist.com/api/v1/comments?task_id=<task_id>" \
+  -H "Authorization: Bearer $TODOIST_API_KEY"
+```
+
+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 → 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

@@ -0,0 +1,2 @@
+HOTSPOT_THRESHOLD=9.56
+AVERAGE_THRESHOLD=9.33

.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

.husky/pre-push

@@ -110,12 +110,19 @@ else
   echo "⏭️  [4/5] Playwright smoke tests — skipped (no tests/smoke/*.spec.ts)"
 fi
 
-# ── 5. CodeScene code health gate ────────────────────────────────────────
-# Blocks push if Hotspot < 9.5 OR Average < 9.33.
-# Remote scores reflect state after last push — this catches regressions
-# introduced in a previous push that weren't caught yet.
+# ── 5. CodeScene code health gate (ratchet) ──────────────────────────────
+# Thresholds live in .codescene-thresholds and only ever go UP (ratchet).
+# After every successful push the file is updated if scores improved.
+THRESHOLDS_FILE="$(git rev-parse --show-toplevel)/.codescene-thresholds"
+HOTSPOT_MIN=9.5
+AVERAGE_MIN=9.31
+if [ -f "$THRESHOLDS_FILE" ]; then
+  HOTSPOT_MIN=$(grep HOTSPOT_THRESHOLD "$THRESHOLDS_FILE" | cut -d= -f2)
+  AVERAGE_MIN=$(grep AVERAGE_THRESHOLD "$THRESHOLDS_FILE" | cut -d= -f2)
+fi
+
 echo ""
-echo "🏥 [5/5] CodeScene code health (Hotspot ≥9.5 + Average ≥9.33)..."
+echo "🏥 [5/5] CodeScene code health (Hotspot ≥${HOTSPOT_MIN} + Average ≥${AVERAGE_MIN})..."
 if [ -z "$CODESCENE_PAT" ] || [ -z "$CODESCENE_PROJECT_ID" ]; then
   echo "  ⚠️  CODESCENE_PAT or CODESCENE_PROJECT_ID not set — skipping"
 else
@@ -128,25 +135,44 @@ else
   if [ -z "$HOTSPOT_SCORE" ] || [ -z "$AVERAGE_SCORE" ]; then
     echo "  ⚠️  Could not fetch remote scores — skipping (CI will enforce)"
   else
-    echo "  Remote Hotspot Code Health: $HOTSPOT_SCORE (threshold: 9.5)"
-    echo "  Remote Average Code Health: $AVERAGE_SCORE (threshold: 9.33)"
+    echo "  Remote Hotspot Code Health: $HOTSPOT_SCORE (threshold: $HOTSPOT_MIN)"
+    echo "  Remote Average Code Health: $AVERAGE_SCORE (threshold: $AVERAGE_MIN)"
     python3 -c "
-import sys
+import sys, os
+
 hotspot = float('$HOTSPOT_SCORE')
 average = float('$AVERAGE_SCORE')
+hotspot_min = float('$HOTSPOT_MIN')
+average_min = float('$AVERAGE_MIN')
 failed = False
-if hotspot < 9.5:
-    print(f'FAIL: Hotspot Code Health {hotspot:.2f} < 9.5')
+
+if hotspot < hotspot_min:
+    print(f'FAIL: Hotspot Code Health {hotspot:.2f} < {hotspot_min}')
     failed = True
 else:
-    print(f'OK: Hotspot {hotspot:.2f} >= 9.5')
-if average < 9.33:
-    print(f'FAIL: Average Code Health {average:.2f} < 9.33 — regressions detected, fix before pushing')
+    print(f'OK: Hotspot {hotspot:.2f} >= {hotspot_min}')
+
+if average < average_min:
+    print(f'FAIL: Average Code Health {average:.2f} < {average_min} — regressions detected, fix before pushing')
     failed = True
 else:
-    print(f'OK: Average {average:.2f} >= 9.33')
+    print(f'OK: Average {average:.2f} >= {average_min}')
+
 if failed:
     sys.exit(1)
+
+# Ratchet: update thresholds file if scores improved
+# Truncate (floor) to 2 decimals so the threshold never exceeds the actual score
+import math
+thresholds_file = '$THRESHOLDS_FILE'
+new_hotspot = max(hotspot_min, math.floor(hotspot * 100) / 100)
+new_average = max(average_min, math.floor(average * 100) / 100)
+if new_hotspot > hotspot_min or new_average > average_min:
+    with open(thresholds_file, 'w') as f:
+        f.write(f'HOTSPOT_THRESHOLD={new_hotspot}\nAVERAGE_THRESHOLD={new_average}\n')
+    print(f'  📈 Ratchet updated: Hotspot {hotspot_min} → {new_hotspot}, Average {average_min} → {new_average}')
+    # Stage and amend the thresholds update into the last commit would change history — instead just auto-commit it
+    os.system(f'git add {thresholds_file} && git commit -m \"chore: ratchet CodeScene thresholds to {new_hotspot}/{new_average}\" --no-verify 2>/dev/null || true')
 " || exit 1
   fi
 fi

CLAUDE.md

@@ -1,38 +1,32 @@
 # CLAUDE.md — Laputa App
 
-## ⛔ BEFORE EVERY COMMIT
+> Quick links: [Project Spec](docs/PROJECT-SPEC.md) · [Architecture](docs/ARCHITECTURE.md) · [Abstractions](docs/ABSTRACTIONS.md) · [Wireframes](ui-design.pen)
 
-```bash
-pnpm lint && npx tsc --noEmit
-pnpm test
-pnpm test:coverage                  # frontend ≥70%
-cargo test
-cargo llvm-cov --manifest-path src-tauri/Cargo.toml --no-clean --fail-under-lines 85
-```
+---
 
-**CodeScene Code Health** — the pre-commit and pre-push hooks enforce:
-- Hotspot Code Health ≥ 9.5 (most-edited files)
-- Average Code Health ≥ 9.31 (project-wide, ALL files)
+## 1. Task Workflow
 
-**Both gates block commit/push.** If either fails: extract hooks, split large components, reduce function complexity. Never add `// eslint-disable`, `#[allow(...)]`, or `as any` to pass the gate. Check both scores via MCP CodeScene after every significant change:
-- `hotspot_code_health.now` ≥ 9.5
-- `code_health.now` ≥ 9.31 (average — do NOT ignore this one)
+### 1a. Pick up a task
 
-If Average Code Health is below 9.0, you must fix regressions before pushing — even in files you didn't directly modify, if your changes indirectly affected complexity.
+Run `/laputa-next-task` — fetches next task (To Rework first, then Open), moves to In Progress, returns full description.
 
-**Boy Scout Rule (Robert C. Martin):** Leave every file you touch better than you found it. When working on any task:
-1. Before modifying a file, check its CodeScene health: `mcp__codescene__code_health_review`
-2. If the file has issues (complexity, duplication, large functions), fix them as part of your work
-3. After your changes, verify the file's score is higher than before: `mcp__codescene__code_health_score`
-4. The goal: every commit either maintains or raises the overall average. No commit should lower it.
+- Read task description and all comments fully
+- For To Rework: the ❌ QA failed comment tells you exactly what to fix
+- Check `docs/adr/` for relevant architecture decisions before structural choices
+- Add a comment: `🚀 Starting work on this task. [Brief description of approach]`
 
-This is not optional — it's how we incrementally raise the codebase quality with every task.
+### 1b. Implement
 
-## ⛔ BEFORE FIRING laputa-task-done — Two-phase QA
+- Work on `main` branch — **no branches, no PRs, ever**
+- Commit every 20–30 min: `feat:`, `fix:`, `refactor:`, `test:`, `docs:`
+- **⛔ NEVER use --no-verify**
+- For UI tasks: open `ui-design.pen` first, study visual language, design in light mode
 
-### Phase 1: Playwright (you do this)
+### 1c. When done
 
-Write a test in `tests/smoke/<slug>.spec.ts` that covers every acceptance criterion. The test must fail before your fix and pass after. Run it:
+**Phase 1 — Playwright (only for core user flows):**
+
+Write smoke test in `tests/smoke/<slug>.spec.ts` only if feature touches: vault open, note create/save/delete, search, wikilink navigation, git commit/push, conflict resolution. Do NOT write Playwright tests for cosmetic changes — use Vitest instead. Suite must stay under **10 minutes**.
 
 ```bash
 pnpm dev --port 5201 &
@@ -40,95 +34,91 @@ sleep 3
 BASE_URL="http://localhost:5201" npx playwright test tests/smoke/<slug>.spec.ts
 ```
 
-**If your task touches filesystem, git, AI, MCP, or any native Tauri command**: also test with `pnpm tauri dev` against `~/Laputa` (not demo vault). Use `osascript` keyboard events — no mouse, no `cliclick`.
-
-### Phase 2: Native QA (Brian does this after push)
-
-Brian installs the release build and runs keyboard-only QA. Phase 1 must pass first or the task goes to To Rework.
-
-Fire done signal only after Phase 1 passes — **two steps, both required**:
+**Phase 2 — Native app QA:**
 
 ```bash
-# 1. Move task to In Review on Todoist
-curl -s -X POST "https://api.todoist.com/api/v1/tasks/<task_id>/move" \
-  -H "Authorization: Bearer $TODOIST_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"section_id": "6g3XjX33FF4Vj86M"}'
-
-# 2. Notify Brian
-openclaw system event --text "laputa-task-done:<task_id>" --mode now
+pnpm tauri dev &
+sleep 10
+bash ~/.openclaw/skills/laputa-qa/scripts/focus-app.sh laputa
+bash ~/.openclaw/skills/laputa-qa/scripts/screenshot.sh /tmp/qa-native.png
 ```
 
-## Project
+Use `osascript` for keyboard interactions. Write result as Todoist comment (✅ or ❌). **⚠️ WKWebView:** `osascript keystroke` blocked inside editor — rely on Playwright for text input features.
 
-Tauri v2 + React + TypeScript desktop app. Reads a vault of markdown files with YAML frontmatter.
+After both phases pass, run `/laputa-done <task_id>` → moves to In Review, notifies Brian, self-dispatches next task.
 
-- **Spec**: `docs/PROJECT-SPEC.md` | **Architecture**: `docs/ARCHITECTURE.md` | **Abstractions**: `docs/ABSTRACTIONS.md`
-- **Wireframes**: `ui-design.pen` | **Luca's vault**: `~/Laputa/` (~9200 markdown files)
-- Stack: Rust backend, React + BlockNote editor, Vitest + Playwright + cargo test, pnpm
+---
 
-## How to Work
+## 2. Development Process
 
-- **Push directly to main** — no PRs ever. The pre-push hook runs all checks.
-- **⛔ NEVER open a PR** — branches diverge and cause rebase churn.
+### Commits & pushes
+
+- Push directly to `main` — no PRs, no branches
+- Pre-push hook runs full check suite (build + tests + Playwright + CodeScene)
+- **A task is NOT done until `git push origin main` succeeds.** If the hook blocks: read the error, fix it (clippy, tests, CodeScene, build), commit the fix, push again. Never use `--no-verify`.
 - **⛔ NEVER use --no-verify**
-- Commit every 20–30 min: `feat:`, `fix:`, `refactor:`, `test:`, `docs:`
 
-## TDD (mandatory)
+### TDD (mandatory)
 
-Red → Green → Refactor → Commit. One cycle per commit. For bugs: write a failing regression test first, then fix. Exception: pure CSS/layout with no logic.
+Red → Green → Refactor → Commit. One cycle per commit. For bugs: write failing regression test first, then fix. Exception: pure CSS/layout changes.
 
-**Test quality (Kent Beck's Desiderata):** every test must be Isolated (no shared state), Deterministic (no flakiness), Fast, Behavioral (tests behavior not implementation), Structure-insensitive (refactoring doesn't break it), Specific (failure points to exact cause), Predictive (all pass = production-ready). Fix flaky/non-deterministic tests before adding new ones. E2E tests over unit tests for user flows.
+**Test quality (Kent Beck's Desiderata):** Isolated · Deterministic · Fast · Behavioral · Structure-insensitive · Specific · Predictive. Fix flaky tests before adding new ones. Prefer E2E over unit tests for user flows.
 
-## ⛔ Docs — Keep docs/ in sync
+### Code health (mandatory)
 
-After adding a Tauri command, new component/hook, data model change, or new integration: update `docs/ARCHITECTURE.md`, `docs/ABSTRACTIONS.md`, and/or `docs/GETTING-STARTED.md` in the same commit. Use Mermaid for diagrams (not ASCII). Exception: spatial wireframe layouts.
+Pre-commit and pre-push hooks enforce **Hotspot Code Health** and **Average Code Health** ≥ thresholds in `.codescene-thresholds`. Both gates block commit/push. Thresholds are a **ratchet** — only go up, auto-updated after each successful push. Never add `// eslint-disable`, `#[allow(...)]`, or `as any`.
 
-## Architecture Decision Records (ADRs)
+**Before every commit:**
+- `mcp__codescene__code_health_review` — check file before touching
+- `mcp__codescene__code_health_score` — verify score is higher after changes
 
-ADRs live in `docs/adr/`. Before making an architectural choice, check existing ADRs there first.
+**Boy Scout Rule:** every file you touch must leave with a higher score. If Average drops below 9.0, fix regressions before pushing.
 
-**When to create one**: storage strategy, new dependency, platform support, core abstraction change, cross-cutting concern. Use `/create-adr` for the full template and instructions.
+### Check suite (runs on every push)
+```bash
+pnpm lint && npx tsc --noEmit
+pnpm test
+pnpm test:coverage        # frontend ≥70%
+cargo test
+cargo llvm-cov --manifest-path src-tauri/Cargo.toml --no-clean --fail-under-lines 85
+```
 
-**Timing**: create the ADR **in the same commit as the code** that implements the decision — never before, never after. An ADR committed without the corresponding code is invalid.
+### Architecture Decision Records (ADRs)
 
-**When your work supersedes an existing ADR**: do not edit the existing file — use `/create-adr` which covers the superseding flow.
+ADRs live in `docs/adr/`. Check before structural choices. Create the ADR **in the same commit as the code**. Never edit existing ADRs — create a new one that supersedes. Use `/create-adr` for template.
 
-**Do not create ADRs for**: bug fixes, UI styling, refactors, or test additions.
+**When to create one:** new dependency, storage strategy, platform target, core abstraction change, cross-cutting pattern. **Not for:** bug fixes, UI styling, refactors, test additions.
 
-## Design File (UI tasks)
+### Keep docs/ in sync
 
-1. Open `ui-design.pen` first — study existing frames for visual language.
-2. Design in light mode. Create `design/<slug>.pen` for the task.
-3. On merge to main: merge frames into `ui-design.pen`, delete `design/<slug>.pen`.
+After Tauri command, new component/hook, data model change, or new integration: update `docs/ARCHITECTURE.md`, `docs/ABSTRACTIONS.md`, and/or `docs/GETTING-STARTED.md` in the same commit.
 
-## ⛔ Never modify the user vault for testing
+---
 
-`~/Laputa/` is Luca's real vault. **Never create, edit, or delete notes there for testing purposes.**
+## 3. Product Rules
 
-Use the demo vault for all testing:
-- Playwright / Vitest: use the fixtures in `tests/` or `demo-vault-v2/`
-- `pnpm tauri dev` manual testing: open `demo-vault-v2/` as the vault, not `~/Laputa/`
-- If a test genuinely requires the real vault (e.g. verifying git history), read only — never write
+### User vault (`~/Laputa/`)
 
-Any commit that touches `~/Laputa/` content is a bug. If you accidentally created test notes there, delete them before committing.
+Default to `demo-vault-v2/`. If you must use `~/Laputa/` for testing: **never commit changes** — always run `cd ~/Laputa && git checkout -- . && git clean -fd` when done.
 
-## Vault Retrocompatibility
+### UI design
 
-Every feature that depends on vault files must auto-bootstrap: check if file/folder exists on vault open, create with defaults if missing (silent, idempotent). Register with the central `Cmd+K → "Repair Vault"` command.
+1. Open `ui-design.pen` first — study existing frames for visual language
+2. Design in light mode. Create `design/<slug>.pen` for the task
+3. On completion: merge frames into `ui-design.pen`, delete `design/<slug>.pen`
 
-## Keyboard-First + Menu Bar (mandatory)
+---
 
-Every feature must be reachable via keyboard. Every new command palette entry must also appear in the macOS menu bar (File / Edit / View / Note / Vault / Window). This is a QA requirement.
+## 4. Reference
 
-## macOS / Tauri Gotchas
+### macOS / Tauri gotchas
 
-- `Option+N` → special chars on macOS. Use `e.code` or `Cmd+N`.
-- Tauri menu accelerators: `MenuItemBuilder::new(label).accelerator("CmdOrCtrl+1")`.
-- `app.set_menu()` replaces the ENTIRE menu bar — include all submenus.
-- `mock-tauri.ts` silently swallows Tauri calls — not a substitute for native app testing.
+- `Option+N` → special chars on macOS. Use `e.code` or `Cmd+N`
+- Tauri menu accelerators: `MenuItemBuilder::new(label).accelerator("CmdOrCtrl+1")`
+- `app.set_menu()` replaces the ENTIRE menu bar — include all submenus
+- `mock-tauri.ts` silently swallows Tauri calls — not a substitute for native testing
 
-## QA Scripts
+### QA scripts
 
 ```bash
 bash ~/.openclaw/skills/laputa-qa/scripts/focus-app.sh laputa
@@ -136,6 +126,6 @@ bash ~/.openclaw/skills/laputa-qa/scripts/screenshot.sh /tmp/out.png
 bash ~/.openclaw/skills/laputa-qa/scripts/shortcut.sh "command" "s"
 ```
 
-## Documentation Diagrams
+### Diagrams
 
-Prefer Mermaid for all diagrams (`flowchart`, `sequenceDiagram`, `classDiagram`, `stateDiagram-v2`). ASCII only for spatial wireframe layouts. GitHub renders Mermaid natively.
+Prefer Mermaid (`flowchart`, `sequenceDiagram`, `classDiagram`, `stateDiagram-v2`). ASCII only for spatial wireframe layouts.

docs/ABSTRACTIONS.md

@@ -523,7 +523,6 @@ App-level settings persisted at `~/.config/com.laputa.app/settings.json`:
 
 ```typescript
 interface Settings {
-  anthropic_key: string | null
   openai_key: string | null
   google_key: string | null
   github_token: string | null

docs/ARCHITECTURE.md

@@ -21,7 +21,7 @@ When deciding where to persist a piece of data, ask: **"Would the user want this
 | Follows the vault | Stays with the installation |
 |-------------------|-----------------------------|
 | Type icon, type color | Editor zoom level |
-| Pinned properties per type | API keys (Anthropic, OpenAI) |
+| Pinned properties per type | API keys (OpenAI, Google) |
 | Sidebar label overrides | GitHub token |
 | Property display order | Window size / position |
 | Any user-visible customization of how content is organized or displayed | Any machine-specific or credential-type setting |
@@ -31,7 +31,6 @@ When deciding where to persist a piece of data, ask: **"Would the user want this
 Examples:
 - ✅ Vault: `_pinned_properties` in a Type note (every device should show the same pinned properties)
 - ✅ Vault: `_icon: shapes` in a Type note (icon is part of the type's identity)
-- ✅ App settings: `anthropic_key` (credential, not vault data)
 - ✅ App settings: `zoom: 1.3` (machine-specific preference)
 
 ### No hardcoded exceptions
@@ -97,7 +96,6 @@ flowchart LR
 | Build | Vite | 7.3.1 |
 | Backend language | Rust (edition 2021) | 1.77.2 |
 | Frontmatter parsing | gray_matter | 0.2 |
-| AI (in-app chat) | Anthropic Claude API (Haiku 3.5 default) | - |
 | AI (agent panel) | Claude CLI subprocess (streaming NDJSON) | - |
 | Search | Keyword (walkdir-based file scan) | - |
 | MCP | @modelcontextprotocol/sdk | 1.0 |
@@ -116,14 +114,13 @@ flowchart TD
             NL["NoteList / PulseView\n(filtered list / activity)"]
             ED["Editor\n(BlockNote + diff + raw)"]
             IN["Inspector\n(metadata + relationships)"]
-            AIC["AIChatPanel\n(API-based chat)"]
             AIP["AiPanel\n(Claude CLI agent + tools)"]
             SP["SearchPanel\n(keyword search)"]
             ST["StatusBar\n(vault picker + sync + version)"]
             CP["CommandPalette\n(Cmd+K launcher)"]
 
             App --> WS & SB & NL & ED & SP & ST & CP
-            ED --> IN & AIC & AIP
+            ED --> IN & AIP
         end
 
         subgraph RB["Rust Backend"]
@@ -138,7 +135,6 @@ flowchart TD
         end
 
         subgraph EXT["External Services"]
-            ANTH["Anthropic API\n(Claude chat)"]
             CCLI["Claude CLI\n(agent subprocess)"]
             MCP["MCP Server\n(ws://9710, 9711)"]
             GHAPI["GitHub API\n(OAuth, repos, clone)"]
@@ -179,7 +175,7 @@ flowchart TD
 - **Sidebar** (150-400px, resizable): Top-level filters (All Notes, Changes, Pulse) and collapsible type-based section groups. Each type can have a custom icon, color, sort, and visibility set via its type document in `type/`.
 - **Note List / Pulse View** (200-500px, resizable): When a section group or filter is selected, shows filtered notes with snippets, modified dates, and status indicators. When Pulse filter is active, shows `PulseView` — a chronological git activity feed grouped by day.
 - **Editor** (flex, fills remaining space): Single note open at a time (no tabs — see ADR-0003). Breadcrumb bar with word count, BlockNote rich text editor with wikilink support. Can toggle to diff view (modified files) or raw CodeMirror view. Decomposed into `Editor` (orchestrator), `EditorContent`, `EditorRightPanel`, `SingleEditorView`, with hooks `useDiffMode`, `useEditorFocus`, `useEditorSave`, `useRawMode`. Navigation history (Cmd+[/]) replaces tabs.
-- **Inspector / AI Chat / AI Agent** (200-500px or 40px collapsed): Toggles between Inspector (frontmatter, relationships, instances, backlinks, git history), AI Chat panel (API-based), and AI Agent panel (Claude CLI subprocess with tool execution). The Sparkle icon in the breadcrumb bar toggles between them. When viewing a Type note, the Inspector shows an **Instances** section listing all notes of that type (sorted by modified_at desc, capped at 50).
+- **Inspector / AI Agent** (200-500px or 40px collapsed): Toggles between Inspector (frontmatter, relationships, instances, backlinks, git history) and AI Agent panel (Claude CLI subprocess with tool execution). The Sparkle icon in the breadcrumb bar toggles between them. When viewing a Type note, the Inspector shows an **Instances** section listing all notes of that type (sorted by modified_at desc, capped at 50).
 
 Panels are separated by `ResizeHandle` components that support drag-to-resize.
 
@@ -203,16 +199,6 @@ Notes can be opened in separate Tauri windows for focused editing. Secondary win
 
 ## AI System
 
-Laputa has two AI interfaces with distinct architectures:
-
-### AI Chat (AIChatPanel)
-
-Simple chat mode — no tool execution, streaming text responses.
-
-1. **Frontend** (`AIChatPanel` + `useAIChat` hook) — UI and state management
-2. **API Proxy** (Vite middleware in dev, Rust `ai_chat` command in Tauri) — routes to Anthropic
-3. **Context picker** — selected notes sent as system context with token estimation
-
 ### AI Agent (AiPanel)
 
 Full agent mode — spawns Claude CLI as a subprocess with tool access and MCP vault integration.
@@ -263,7 +249,7 @@ When the agent writes or edits vault files, `useAiAgent` detects this from tool
 
 ### Context Building
 
-Both AI modes use context from the active note and linked entries. The agent panel (`ai-context.ts`) builds a structured JSON snapshot:
+The agent panel (`ai-context.ts`) builds a structured JSON snapshot from the active note and linked entries:
 
 ```json
 {
@@ -277,19 +263,9 @@ Both AI modes use context from the active note and linked entries. The agent pan
 
 Token budget: 60% of 180k context limit (~108k tokens max). Active note gets priority, then linked notes, then truncation.
 
-### Models (Chat mode)
+### Authentication
 
-| Model | ID | Use case |
-|-------|----|----------|
-| Haiku 3.5 | `claude-3-5-haiku-20241022` | Fast, cheap — default |
-| Sonnet 4 | `claude-sonnet-4-20250514` | Balanced |
-| Opus 4 | `claude-opus-4-20250514` | Most capable |
-
-### API Key Management
-
-- Stored in app settings (`~/.config/com.laputa.app/settings.json`) under `anthropic_key`
-- Configurable via Settings panel (also supports `openai_key`, `google_key`)
-- Claude CLI (agent mode) uses its own authentication — no API key needed
+Claude CLI (agent mode) uses its own authentication — no API key configuration needed in Laputa.
 
 ## MCP Server
 
@@ -589,7 +565,6 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `github/` | GitHub OAuth + API (`auth.rs`, `api.rs`, `clone.rs`) |
 | `search.rs` | Keyword search — walkdir-based vault file scan |
 | `claude_cli.rs` | Claude CLI subprocess spawning + NDJSON stream parsing |
-| `ai_chat.rs` | Direct Anthropic API client (non-streaming, for Tauri builds) |
 | `mcp.rs` | MCP server spawning + config registration |
 | `commands/` | Tauri command handlers (split into submodules) |
 | `settings.rs` | App settings persistence |
@@ -674,7 +649,6 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 
 | Command | Description |
 |---------|-------------|
-| `ai_chat` | Direct Anthropic API call (non-streaming) |
 | `stream_claude_chat` | Claude CLI chat mode (streaming) |
 | `stream_claude_agent` | Claude CLI agent mode (streaming + tools) |
 | `check_claude_cli` | Check if Claude CLI is available |
@@ -726,7 +700,6 @@ No Redux or global context. State lives in the root `App.tsx` and custom hooks:
 | `useTabManagement` | Navigation history, note switching | Note navigation lifecycle |
 | `useVaultSwitcher` | `vaultPath`, `extraVaults` | Vault switching |
 | `useTheme` | Editor theme CSS vars | Editor typography theme |
-| `useAIChat` | `messages`, `isStreaming` | AI chat conversation |
 | `useAiAgent` | `messages`, `status`, tool actions | AI agent conversation |
 | `useAutoSync` | Sync interval, pull/push state | Git auto-sync |
 | `useUnifiedSearch` | Query, results, loading state | Keyword search |
@@ -825,7 +798,7 @@ sequenceDiagram
 
 **Architecture:**
 - **Rust:** `sentry` crate initialized in `lib.rs::setup()` via `telemetry::init_sentry_from_settings()`
-- **JS:** `@sentry/browser` + `posthog-js` initialized lazily by `useTelemetry` hook
+- **JS:** `@sentry/react` + `posthog-js` initialized lazily by `useTelemetry` hook
 - **Settings:** `telemetry_consent`, `crash_reporting_enabled`, `analytics_enabled`, `anonymous_id` in `Settings` struct
 - **Consent:** `TelemetryConsentDialog` shown when `telemetry_consent === null`
 
@@ -853,9 +826,13 @@ flowchart LR
 - **Canary**: `useUpdater` hook fetches `latest-canary.json` via HTTP, compares versions, and opens the GitHub release page for manual download
 - Canary versions use semver prerelease: `0.YYYYMMDD.N-canary`
 
-### Feature Flags (Local V1)
+### Feature Flags (PostHog + Release Channels)
 
-Feature flags use a local-only system with no external dependencies:
+Feature flags are backed by PostHog and evaluated per release channel:
+
+- **Alpha**: all features always enabled (no PostHog lookup)
+- **Beta**: sees features where the PostHog flag targets `release_channel = beta`
+- **Stable** (default): sees features where the flag targets `release_channel = stable`
 
 ```typescript
 import { useFeatureFlag } from './hooks/useFeatureFlag'
@@ -865,18 +842,14 @@ const enabled = useFeatureFlag('example_flag') // boolean
 
 **Resolution order:**
 1. `localStorage` override: key `ff_<name>` with value `"true"` or `"false"`
-2. Compile-time default in `FLAG_DEFAULTS` map
+2. `isFeatureEnabled(flag)` in `telemetry.ts` → checks release channel, then PostHog, then hardcoded defaults
 
 **How to add a new flag:**
 1. Add the flag name to the `FeatureFlagName` union type in `src/hooks/useFeatureFlag.ts`
-2. Set its default in the `FLAG_DEFAULTS` record
+2. Create the flag on PostHog dashboard with rollout rules per channel
 3. Use `useFeatureFlag('your_flag')` in components
 
-**Design decisions:**
-- No remote fetching, no PostHog dependency — zero privacy concerns
-- `localStorage` overrides allow dev/QA testing without rebuilding
-- Type-safe flag names via TypeScript union type
-- API surface is compatible with future migration to remote flags
+Release channel is selectable in Settings (alpha / beta / stable) and passed to PostHog as a person property via `identify()`. See ADR-0042.
 
 ## Platform Support — iOS / iPadOS (Prototype)
 

docs/GETTING-STARTED.md

@@ -53,7 +53,6 @@ laputa-app/
 │   │   ├── RawEditorView.tsx     # CodeMirror raw editor
 │   │   ├── Inspector.tsx         # Fourth panel: metadata + relationships
 │   │   ├── DynamicPropertiesPanel.tsx  # Editable frontmatter properties
-│   │   ├── AIChatPanel.tsx       # AI chat (API-based)
 │   │   ├── AiPanel.tsx           # AI agent (Claude CLI subprocess)
 │   │   ├── AiMessage.tsx         # Agent message display
 │   │   ├── AiActionCard.tsx      # Agent tool action cards
@@ -86,7 +85,6 @@ laputa-app/
 │   │   ├── useNoteActions.ts     # Composes creation + rename + frontmatter
 │   │   ├── useNoteCreation.ts   # Note/type/daily-note creation
 │   │   ├── useNoteRename.ts     # Note renaming + wikilink updates
-│   │   ├── useAIChat.ts          # AI chat state
 │   │   ├── useAiAgent.ts         # AI agent state + tool tracking
 │   │   ├── useAiActivity.ts      # MCP UI bridge listener
 │   │   ├── useAutoSync.ts        # Auto git pull/push
@@ -110,7 +108,7 @@ laputa-app/
 │   │   ├── wikilinks.ts          # Wikilink preprocessing pipeline
 │   │   ├── frontmatter.ts        # TypeScript YAML parser
 │   │   ├── ai-agent.ts           # Agent stream utilities
-│   │   ├── ai-chat.ts            # Chat API client + token estimation
+│   │   ├── ai-chat.ts            # Token estimation utilities
 │   │   ├── ai-context.ts         # Context snapshot builder
 │   │   ├── noteListHelpers.ts    # Sorting, filtering, date formatting
 │   │   ├── wikilink.ts           # Wikilink resolution
@@ -155,7 +153,6 @@ laputa-app/
 │   │   ├── telemetry.rs          # Sentry init + path scrubber
 │   │   ├── search.rs             # Keyword search (walkdir-based)
 │   │   ├── claude_cli.rs         # Claude CLI subprocess management
-│   │   ├── ai_chat.rs            # Direct Anthropic API client
 │   │   ├── mcp.rs                # MCP server lifecycle + registration
 │   │   ├── settings.rs           # App settings persistence
 │   │   ├── vault_config.rs       # Per-vault UI config
@@ -231,7 +228,6 @@ laputa-app/
 | File | Why it matters |
 |------|---------------|
 | `src/components/AiPanel.tsx` | AI agent panel — Claude CLI with tool execution, reasoning, actions. |
-| `src/components/AIChatPanel.tsx` | AI chat panel — API-based chat without tools. |
 | `src/hooks/useAiAgent.ts` | Agent state: messages, streaming, tool tracking, file detection. |
 | `src/utils/ai-context.ts` | Context snapshot builder for AI conversations. |
 

docs/IPAD-PROTOTYPE.md

@@ -30,7 +30,7 @@ Laputa can be ported to iPad using Tauri v2 iOS (beta) with **minimal code chang
 |---------|---------|---------------------|
 | Git operations | No `git` binary on iOS | **Option B (Working Copy)** for prototype; **Option A (isomorphic-git)** for production |
 | GitHub clone/push/pull | Depends on git CLI | Same as above |
-| Claude CLI streaming | No `claude` binary on iOS | Use Anthropic API directly (already available via `ai_chat`) |
+| Claude CLI streaming | No `claude` binary on iOS | Use Anthropic API directly (requires new implementation) |
 | MCP server / WS bridge | Spawns Node.js child process | Skip for mobile; explore in-process MCP later |
 | macOS menu bar | Desktop-only API | Touch-native navigation (already handled by React) |
 | Updater plugin | Desktop-only | Use TestFlight for updates |

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/0027-dual-ai-architecture.md

@@ -2,7 +2,8 @@
 type: ADR
 id: "0027"
 title: "Dual AI architecture (API chat + CLI agent)"
-status: active
+status: superseded
+superseded_by: "0028"
 date: 2026-03-01
 ---
 

docs/adr/0028-cli-agent-only-no-api-key.md

@@ -0,0 +1,40 @@
+---
+type: ADR
+id: "0028"
+title: "CLI agent only — no direct Anthropic API key"
+status: active
+date: 2026-03-29
+supersedes: "0027"
+---
+
+## Context
+
+ADR-0027 introduced a dual AI architecture: a lightweight API-based chat (AIChatPanel) using the Anthropic API directly, and a full CLI agent (AiPanel) spawning Claude CLI as a subprocess with MCP tool access. In practice, the API chat was never shipped to users — the CLI agent covered all use cases and provided a superior experience through tool access and MCP integration. Maintaining two codepaths added complexity, and requiring users to manage an Anthropic API key created friction.
+
+## Decision
+
+**Remove the direct Anthropic API integration entirely. AI is available exclusively via CLI agent subprocesses (Claude Code, and in the future Codex or other CLI agents).** No API key field in settings. The CLI agent authenticates via its own mechanism (e.g. `claude` CLI login).
+
+Removed:
+- `AIChatPanel` component, `useAIChat` hook
+- Rust `ai_chat` command and `ai_chat.rs` module
+- `anthropic_key` field from Settings (Rust and TypeScript)
+- Vite dev-server Anthropic API proxy (`aiChatProxyPlugin`, `aiAgentProxyPlugin`)
+
+Kept:
+- `AiPanel` + `useAiAgent` — Claude CLI subprocess with MCP vault integration
+- Shared utilities in `ai-chat.ts` (`trimHistory`, `formatMessageWithHistory`, `streamClaudeChat`, etc.)
+- `Cmd+I` keyboard shortcut and menu item for toggling the AI panel
+
+## Options considered
+
+- **Option A** (chosen): Remove API chat, keep CLI agent only. Simplifies codebase, removes API key management, single codepath.
+- **Option B**: Keep both but hide API chat behind feature flag. Adds dead code weight without benefit.
+- **Option C**: Replace CLI agent with API chat + manual tool calling. Loses MCP integration and Claude CLI features.
+
+## Consequences
+
+- Users no longer need to obtain or manage an Anthropic API key
+- Existing saved API keys are silently ignored (the field no longer exists in the Settings struct; serde skips unknown fields on deserialization)
+- Future CLI agents (Codex, etc.) can plug into the same `AiPanel` architecture
+- If a lightweight chat mode is needed later, it should be built as a CLI agent mode, not a separate API integration

docs/adr/0029-domain-command-builder-pattern.md

@@ -0,0 +1,29 @@
+---
+type: ADR
+id: "0029"
+title: "Domain command builder pattern for useCommandRegistry"
+status: active
+date: 2026-03-30
+---
+
+## Context
+
+`useCommandRegistry` was a 224-line "brain method" (CodeScene hotspot) that defined all command palette commands inline: navigation, note actions, git operations, view toggles, settings, type management, and filter controls. This monolithic structure scored 39 on CodeScene's complexity scale (target: ≤9.5 for hotspots), making it increasingly hard to add new commands without touching the central file.
+
+## Decision
+
+**Split command definitions into focused domain modules under `src/hooks/commands/`, each exporting a `build*Commands(config)` factory function. `useCommandRegistry` becomes a thin assembler that calls each builder and merges the results.** Domain modules: `navigationCommands`, `noteCommands`, `gitCommands`, `viewCommands`, `settingsCommands`, `typeCommands`, `filterCommands`. Shared types live in `commands/types.ts`; public API re-exported from `commands/index.ts`.
+
+## Options considered
+
+- **Option A** (chosen): Domain builder modules — each module owns its command shape and receives typed config. `useCommandRegistry` is pure assembly. All new files score 9.58–10.0. Downside: more files to navigate.
+- **Option B**: Split by file but keep one large hook calling sub-hooks — sub-hooks still need shared state passed down, similar coupling. No real complexity win.
+- **Option C**: Register commands imperatively via a global registry — decouples callers entirely. Downside: harder to trace, no TypeScript inference at the registration site, over-engineering for current scale.
+
+## Consequences
+
+- Adding a new command means editing the relevant domain module (e.g. `noteCommands.ts`) only, not touching the assembler.
+- Each domain module receives only the config it needs — explicit, typed interface, no hook dependency.
+- `useCommandRegistry` reduced from 224 lines to a thin assembler.
+- Pattern is consistent with the Rust commands/ module split (ADR-0030).
+- Re-evaluation trigger: if command count grows to the point where the assembler itself becomes a complexity hotspot.

docs/adr/0030-rust-commands-module-split.md

@@ -0,0 +1,29 @@
+---
+type: ADR
+id: "0030"
+title: "Rust commands/ module split by domain"
+status: active
+date: 2026-03-30
+---
+
+## Context
+
+`src-tauri/src/commands.rs` grew to 937 lines as Tauri command handlers accumulated for vault CRUD, git/GitHub sync, AI, system, and window operations. All commands shared a single file with no domain separation, making it hard to navigate, review, and extend. The file was a CodeScene hotspot dragging down overall code health.
+
+## Decision
+
+**Replace `commands.rs` with a `commands/` module split by domain: `vault.rs`, `git.rs`, `github.rs`, `ai.rs`, `system.rs`, and `mod.rs` (shared utilities + re-exports).** Each file owns the Tauri command handlers for its domain and the `#[cfg(desktop)]` / `#[cfg(mobile)]` stubs for platform-conditional availability. `mod.rs` is kept thin (≤100 lines) with no command logic — only re-exports and shared helpers (`expand_tilde`, `parse_build_label`).
+
+## Options considered
+
+- **Option A** (chosen): Domain-based module split — mirrors the TypeScript `hooks/commands/` pattern (ADR-0029). Each file is independently reviewable and scores well on code health. Downside: more files to navigate.
+- **Option B**: Split by platform (`desktop.rs`, `mobile.rs`) — aligns with `#[cfg(...)]` guards but mixes domain concerns. Harder to find a specific command.
+- **Option C**: Keep monolith but add section comments — zero file-count cost, but doesn't solve complexity or reviewability.
+
+## Consequences
+
+- `github.rs` separates GitHub OAuth/API commands from git sync commands (`git.rs`), matching the underlying Rust module split (`github/` vs `git/`).
+- Platform stubs (`#[cfg(mobile)]` error returns) live alongside the desktop implementation in the same domain file.
+- `mod.rs` re-exports all command functions so `lib.rs` `invoke_handler!` registration is unchanged.
+- New Tauri commands go into the appropriate domain file; if no domain fits, create a new one rather than putting it in `mod.rs`.
+- Re-evaluation trigger: if a single domain file (e.g. `vault.rs`) itself grows beyond ~300 lines and becomes a hotspot.

docs/adr/0031-full-app-for-note-windows.md

@@ -0,0 +1,30 @@
+---
+type: ADR
+id: "0031"
+title: "Full App instance for secondary note windows"
+status: active
+date: 2026-03-31
+---
+
+## Context
+
+Laputa supports opening a note in a secondary window ("Open in New Window"). The original implementation used a dedicated `NoteWindow` component — a thin shell that rendered only the editor, duplicating some App-level logic (vault loading, settings, keyboard shortcuts) in a simplified but diverging form. As the main App gained features (properties editing, zoom, command palette, keyboard shortcuts), the `NoteWindow` shell fell behind, requiring ongoing maintenance to keep parity.
+
+## Decision
+
+**Remove `NoteWindow` and render the full `App` component in secondary note windows.** The window type is detected at startup via URL query parameters (`?window=note&path=...&vault=...`). When in note-window mode, the App initialises with panels hidden (sidebar collapsed, inspector collapsed) and auto-opens the target note once vault entries load. The window title is kept in sync with the active note title via the Tauri window API.
+
+## Options considered
+
+- **Keep `NoteWindow` shell** (status quo): lower initial bundle weight per window, but divergence grows with every main-App feature. Rejected — maintenance cost dominates.
+- **Full `App` instance with URL-param mode** (chosen): complete feature parity for free; single code path for all window types. Trade-off: slightly heavier startup for secondary windows (full vault load), acceptable given local filesystem speed.
+- **IPC-driven secondary window (no vault reload)**: secondary window subscribes to primary window's vault state via Tauri events. Maximum efficiency, avoids double vault reads. Deferred — requires significant IPC plumbing; can be layered on top later without changing the rendering model.
+
+## Consequences
+
+- Removes ~163 lines (`NoteWindow.tsx` deleted entirely)
+- Secondary note windows get full feature parity: all keyboard shortcuts, properties panel, zoom, command palette, diff mode, raw editor
+- `useLayoutPanels` gains an `initialInspectorCollapsed` option to support the hidden-panel initial state
+- A new `src/utils/windowMode.ts` utility encapsulates URL-param detection — single source of truth for window-type logic
+- Vault is loaded independently in each note window (no shared state with the main window); writes go to the same filesystem so eventual consistency is maintained via file-watching
+- Triggers re-evaluation if: multiple simultaneous note windows cause measurable vault-read contention, or if IPC-driven shared-state windows become a product requirement

docs/adr/0032-status-bar-for-git-actions.md

@@ -0,0 +1,30 @@
+---
+type: ADR
+id: "0032"
+title: 0032 Status Bar For Git Actions
+status: active
+date: 2026-03-31
+---
+[[Subfolder scanning and folder tree navigation]]
+
+## Context
+
+The Laputa sidebar originally surfaced git-related affordances — a "Changes" nav item (visible when modified files > 0), a "Pulse" nav item, and a "Commit & Push" button — alongside the note-type navigation filters and sections. This mixed two concerns in the sidebar: **navigation** (where to go) and **git status / actions** (what changed, what to do). As the sidebar grew, the git items created visual noise and made the nav hierarchy harder to scan.
+
+## Decision
+
+**Move Changes, Pulse, and Commit & Push out of the sidebar and into the bottom status bar.** The status bar shows a GitDiff icon with an orange count badge for modified files; a Pulse icon sits next to it. Commit & Push is accessible via an icon button beside the Changes indicator. The sidebar now contains only navigation items (filters and type sections).
+
+## Options considered
+
+* **Keep git items in sidebar** (status quo): familiar placement, visible at all times. Rejected — mixes navigation and action concerns; sidebar becomes harder to scan.
+* **Status bar** (chosen): consistent with app conventions (build number, sync status, vault switcher already live there); persistent but unobtrusive; follows macOS app patterns where status/action items live at window bottom.
+* **Toolbar / breadcrumb bar**: would require a new chrome layer or polluting the per-note breadcrumb with global git state. Rejected.
+
+## Consequences
+
+* Sidebar props `modifiedCount`, `onCommitPush`, `isGitVault` removed; sidebar renders navigation-only
+* `StatusBar` gains `onClickPending`, `onClickPulse`, `onCommitPush`, `isGitVault` props
+* Sidebar tests for Changes/Pulse/Commit button removed; StatusBar tests extended
+* Users find Commit & Push in the status bar (same location as sync indicators) rather than bottom of sidebar — small discoverability change, offset by status bar being always visible regardless of sidebar collapsed state
+* Triggers re-evaluation if: user research shows git actions are hard to discover in the status bar

docs/adr/0033-subfolder-scanning-and-folder-tree.md

@@ -0,0 +1,34 @@
+---
+type: ADR
+id: "0033"
+title: "Subfolder scanning and folder tree navigation"
+status: active
+date: 2026-03-31
+---
+## Context
+
+[[0032 Status Bar For Git Actions]]
+
+Supersedes the scanning constraint in [ADR-0006](0006-flat-vault-structure.md) which limited vault indexing to root-level `.md` files plus protected folders (`attachments/`, `assets/`).
+
+Users with folder-based workflows (PARA, Zettelkasten with folders, project directories) could not see or filter notes by directory. The vault scanner silently ignored all subdirectory `.md` files, making Laputa unsuitable for vaults with any folder structure.
+
+## Decision
+
+**Extend the Rust vault scanner to index **`.md`** files in all visible subdirectories, and expose the vault's folder tree via a new **`list_vault_folders`** Tauri command so the sidebar can render a collapsible FOLDERS section.**
+
+Hidden directories (names starting with `.`, plus `.git` and `.laputa`) are excluded from both scanning and the folder tree.
+
+## Options considered
+
+* **Option A** (chosen): Scan all subdirectories with `walkdir`, expose separate `list_vault_folders` command — simple, no schema changes to VaultEntry, folder tree is lightweight and independent of the entry cache.
+* **Option B**: Add a `folder` field to VaultEntry and derive the tree on the frontend — couples folder metadata to the entry cache, complicates cache invalidation when folders are created/deleted without file changes.
+* **Option C**: Keep flat scanning, add a "virtual folders" feature that groups by path prefix from frontmatter — doesn't solve the core problem of missing notes in subdirectories.
+
+## Consequences
+
+* All `.md` files in the vault are now indexed regardless of depth — vaults with many non-note `.md` files (e.g. node_modules) will see spurious entries. Mitigation: hidden directories are already excluded; users can add a `.laputaignore` in the future if needed.
+* The git-based cache in `cache.rs` already uses `walkdir` for change detection, so this change aligns scanning with caching.
+* `SidebarSelection` gains a new `{ kind: 'folder'; path: string }` variant — all exhaustive switches on selection kind must handle it.
+* ADR-0006's "flat vault" principle is relaxed: notes can now live in subdirectories. Type definitions still live in `type/` at the root.
+* Re-evaluate if users request recursive folder filtering (currently only direct children are shown when a folder is selected).

docs/adr/0034-git-repo-required-for-vault.md

@@ -0,0 +1,29 @@
+---
+type: ADR
+id: "0034"
+title: "Git repo required — blocking modal enforces vault prerequisite"
+status: active
+date: 2026-04-01
+---
+
+## Context
+
+ADR-0014 (git-based vault cache) and ADR-0021 (push-to-main workflow) both assume the vault is a git repository, but neither codified it as a hard enforcement. In practice, opening a non-git folder silently degraded: the cache couldn't compute a commit hash, Pulse/Changes were empty, and commit/push commands failed. The failure mode was invisible to users.
+
+## Decision
+
+**When the app opens a vault that has no `.git` directory, a blocking modal prevents all app use until the user either initialises a git repository (git init + initial commit, offered as a one-click action) or selects a different vault. The check is performed by a new `is_git_repo` Tauri command. In browser/dev mode, the check fails open (modal is skipped).**
+
+## Options considered
+
+- **Option A** (chosen): Hard block via modal on vault open — unambiguous, prevents silent failures, surfaces the fix immediately. Downside: breaks existing workflows for users with non-git vaults; requires a clear escape hatch (choose different vault).
+- **Option B**: Soft warning banner, allow using the app without git — avoids blocking users, but silent failures persist for Pulse/Changes/commit features.
+- **Option C**: Auto-init git on vault open without asking — less friction, but surprising; user may not want their vault in git.
+
+## Consequences
+
+- Git is now a first-class prerequisite for Laputa vaults, not just implied by the cache strategy.
+- The `is_git_repo` command is intentionally lightweight (checks for `.git` existence only; does not validate remote or commit history).
+- The modal offers `git init` + an initial commit as a one-click path, lowering the barrier for new users.
+- Browser mode bypasses the check so dev/Storybook workflows are unaffected.
+- Re-evaluate if Laputa needs to support non-git vaults (e.g., iCloud-only, shared network drive); at that point ADR-0014 would also need revisiting.

docs/adr/0035-path-suffix-wikilink-resolution.md

@@ -0,0 +1,31 @@
+---
+type: ADR
+id: "0035"
+title: "Path-suffix wikilink resolution for subfolder vaults"
+status: active
+date: 2026-04-01
+---
+
+## Context
+
+ADR-0006 stated that wikilink resolution was "simplified to multi-pass title/filename matching — no path-based matching needed" because the vault was flat. ADR-0033 relaxed the flat-vault constraint by adding subfolder scanning. As a result, wikilinks like `[[docs/adr/0031-foo]]` or `[[adr/0031-foo]]` could not resolve to entries in subdirectories: the resolver only matched on `title` and `filename` stem, never on the vault-relative path.
+
+The backlink detection in the Inspector also used a hardcoded `/Laputa/` path regex, which was wrong for any vault that isn't named "Laputa".
+
+## Decision
+
+**Add path-suffix matching as Pass 1 of wikilink resolution: a link target resolves to a `VaultEntry` if the entry's vault-relative path ends with the link string (with or without `.md`). Filename-stem matching (the previous Pass 1) becomes Pass 2. Inspector backlinks replace the hardcoded `/Laputa/` regex with a generic `targetMatchesEntry` path-suffix helper. Autocomplete pre-filter also matches against the full vault-relative path so subfolder names surface results.**
+
+## Options considered
+
+- **Option A** (chosen): Path-suffix as Pass 1, then filename match as Pass 2 — consistent with how Obsidian resolves links in multi-folder vaults, zero config. Downside: if two notes share the same filename in different folders, only the first (path-suffix) match wins.
+- **Option B**: Strict full-path matching only (disable title-stem resolution) — unambiguous, but breaks the majority of existing short-form `[[note-title]]` links.
+- **Option C**: Keep title-only matching, require full paths for subfolder notes — backwards-compatible, but forces users to always type full paths for subfolders, defeating the purpose of wikilinks.
+
+## Consequences
+
+- Supersedes the "no path-based matching needed" clause from ADR-0006 (that assumption was contingent on the flat vault invariant, which ADR-0033 relaxed).
+- `relativePathStem` utility added in `wikilink.ts` to extract the vault-relative path stem from a full `VaultEntry`.
+- The Inspector's `targetMatchesEntry` helper is now the canonical way to test if a link resolves to an entry — use it everywhere instead of ad-hoc regex.
+- Wikilink autocomplete suggestions now surface notes in subfolders when users type a folder prefix (e.g. `[[adr/`).
+- Re-evaluate if path-suffix ambiguity (two files with the same name in different folders) becomes a user complaint.

docs/adr/0036-external-rename-detection-via-git-diff.md

@@ -0,0 +1,31 @@
+---
+type: ADR
+id: "0036"
+title: "External rename detection via git diff on focus regain"
+status: active
+date: 2026-04-01
+---
+
+## Context
+
+Laputa handles in-app renames (rename.rs) and propagates wikilink updates across the vault. But notes can also be renamed externally — from Finder, another editor, or a git operation (e.g., `git mv`). In those cases, the app had no way to detect that a rename had occurred, leaving wikilinks broken and the vault inconsistent.
+
+The app already uses git for the cache (ADR-0014) and requires git as a vault prerequisite (ADR-0034), making git diff a natural and already-available detection mechanism.
+
+## Decision
+
+**When the app window regains focus, run `git diff --diff-filter=R --name-status HEAD` to detect file renames that occurred since the last committed HEAD. If any renamed `.md` files are found, show a non-blocking banner ("X file(s) renamed — update wikilinks?"). Accepting triggers the existing vault-wide wikilink replacement logic (reused from rename.rs). Ignoring dismisses the banner without changes. New Tauri commands: `detect_renames` and `update_wikilinks_for_renames`.**
+
+## Options considered
+
+- **Option A** (chosen): Git diff on focus regain, non-blocking banner — uses existing infrastructure, non-disruptive, user retains control. Downside: only detects renames that are staged/committed; uncommitted renames via `git mv` are captured, but renames done purely in Finder (no git involvement) are not.
+- **Option B**: `FSEvents` / file-system watcher for rename events — catches all renames regardless of git. Downside: significantly more complex, requires Rust async machinery, false positives from editor temp files, and this feature is already planned as a separate enhancement.
+- **Option C**: Scan for broken wikilinks on focus — correct but O(n) and noisy; doesn't tell us the new filename.
+
+## Consequences
+
+- Git's rename detection (`--diff-filter=R`) requires the rename to be git-tracked (either staged or committed); renames that happen outside git knowledge are not detected by this mechanism.
+- The on-focus check runs `git diff HEAD` which is fast but adds a small shell invocation overhead each time the window activates. This is acceptable for typical vault sizes.
+- `rename.rs` is now shared between in-app renames and external rename recovery — the replacement logic is the canonical entry point for wikilink bulk updates.
+- The banner is non-blocking and "Ignore" is always available — the user never loses work.
+- Re-evaluate if FS-level rename detection (outside git) becomes a priority; at that point this mechanism would be a fallback, not the primary strategy.

docs/adr/0037-codemirror-language-markdown-highlighting.md

@@ -0,0 +1,31 @@
+---
+type: ADR
+id: "0037"
+title: "Language-based markdown syntax highlighting in raw editor"
+status: active
+date: 2026-04-01
+---
+
+## Context
+
+The raw editor (CodeMirror 6, introduced in ADR-0022) initially had a custom `frontmatterHighlight` extension that used regex-based decoration for YAML frontmatter and headings. Markdown body content had no syntax highlighting at all, making the raw editor feel like a plain textarea despite being a full CodeMirror instance.
+
+Extending the custom regex-based approach to cover all markdown syntax (bold, italic, links, lists, blockquotes, code) would have been brittle and hard to maintain.
+
+## Decision
+
+**Replace the custom heading decoration in `frontmatterHighlight.ts` with `@codemirror/lang-markdown` (the official CodeMirror language package). A custom `HighlightStyle` maps CodeMirror highlight tags to visual styles for headings, bold, italic, strikethrough, links, lists, blockquotes, and inline code. The frontmatter YAML plugin is retained for YAML-specific colouring but its heading decoration is removed in favour of the language parser.**
+
+## Options considered
+
+- **Option A** (chosen): `@codemirror/lang-markdown` with custom HighlightStyle — uses the official, maintained language parser; future highlight rules are one CSS declaration. Downside: adds a new npm dependency; the custom frontmatter plugin must be kept separately.
+- **Option B**: Extend the custom regex plugin to cover all markdown — no new dependency. Downside: regex-based tokenisation is fragile (e.g., nested formatting), already proving hard to maintain after the heading/frontmatter overlap bug.
+- **Option C**: Switch to a markdown-aware editor (e.g., Milkdown, Monaco) — full-featured. Downside: major migration, breaks the dual-editor architecture in ADR-0022, significant scope.
+
+## Consequences
+
+- `@codemirror/lang-markdown` added to `package.json` — this is the only new runtime dependency introduced by this change.
+- `frontmatterHighlight.ts` is simplified (heading decoration removed); `markdownHighlight.ts` is the new extension responsible for body highlighting.
+- The two extensions are composed in `useCodeMirror.ts` — YAML frontmatter block is still styled by the custom plugin; everything else by the language parser.
+- Future syntax highlighting changes (e.g., task lists, tables) can be added by extending the `HighlightStyle` without modifying the parser.
+- Re-evaluate if `@codemirror/lang-markdown` conflicts with the custom frontmatter YAML handling as the editor evolves (e.g., if frontmatter block needs to be parsed as a code block rather than decorated text).

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/0042-posthog-release-channels-feature-flags.md

@@ -0,0 +1,37 @@
+---
+type: ADR
+id: "0042"
+title: "PostHog-based release channels and feature flags"
+status: active
+date: 2026-04-03
+supersedes: "0017"
+---
+## Context
+
+ADR-0017 introduced canary/stable update channels with localStorage-based feature flags. This worked for local development but lacked remote flag management — promoting a feature from beta to stable required a code change and rebuild.
+
+## Decision
+
+**Replace localStorage feature flags with PostHog-based feature flags, evaluated per release channel (alpha/beta/stable). The release channel is a user-selectable setting; PostHog flag rules determine which features are visible for each channel.**
+
+- **Alpha**: all features always enabled (no PostHog lookup needed, works offline)
+- **Beta**: sees features where the PostHog flag targets `release_channel = beta`
+- **Stable** (default): sees features where the PostHog flag targets `release_channel = stable`
+- Promotion = flipping a PostHog flag on the dashboard. Zero code changes, zero rebuilds.
+- `isFeatureEnabled(flagKey)` in `telemetry.ts` is the single evaluation point.
+- localStorage overrides (`ff_<name>`) still work for dev/QA testing (checked first).
+- Offline: PostHog caches flags in localStorage; alpha always works; first-launch-no-network falls back to hardcoded defaults.
+
+## Options considered
+
+* **Option A**: Keep localStorage-only flags (ADR-0017) — no server dependency, but no remote management.
+* **Option B** (chosen): PostHog feature flags — we already use PostHog for analytics, so no new dependency. Remote flag management, per-channel targeting, gradual rollouts via PostHog dashboard.
+* **Option C**: Dedicated feature flag service (LaunchDarkly, Unleash) — more powerful but adds a new vendor dependency.
+
+## Consequences
+
+* `release_channel` added to Settings (persisted via Tauri backend, not vault).
+* `useTelemetry` passes `release_channel` as a PostHog person property on identify.
+* `isFeatureEnabled()` checks channel → PostHog → hardcoded defaults.
+* `useFeatureFlag` hook updated to delegate to `isFeatureEnabled` (after localStorage override check).
+* ADR-0017 is superseded — the canary update channel remains, but feature gating moves from localStorage to PostHog.

docs/adr/README.md

@@ -82,4 +82,18 @@ proposed → active → superseded
 | [0024](0024-cache-outside-vault.md) | Vault cache stored outside vault directory | active |
 | [0025](0025-type-field-canonical.md) | type: as canonical field (replacing Is A:) | active |
 | [0026](0026-props-down-no-global-state.md) | Props-down callbacks-up (no global state) | active |
-| [0027](0027-dual-ai-architecture.md) | Dual AI architecture (API chat + CLI agent) | active |
+| [0027](0027-dual-ai-architecture.md) | Dual AI architecture (API chat + CLI agent) | superseded |
+| [0028](0028-cli-agent-only-no-api-key.md) | CLI agent only — no direct Anthropic API key | active |
+| [0029](0029-domain-command-builder-pattern.md) | Domain command builder pattern for useCommandRegistry | active |
+| [0030](0030-rust-commands-module-split.md) | Rust commands/ module split by domain | active |
+| [0031](0031-full-app-for-note-windows.md) | Full App instance for secondary note windows | active |
+| [0032](0032-status-bar-for-git-actions.md) | Git actions (Changes, Pulse, Commit) in status bar, not sidebar | active |
+| [0033](0033-subfolder-scanning-and-folder-tree.md) | Subfolder scanning and folder tree navigation | active |
+| [0034](0034-git-repo-required-for-vault.md) | Git repo required — blocking modal enforces vault prerequisite | active |
+| [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 |

docs/adr/canary-release-channel-and-local-feature-flags.md

@@ -5,26 +5,27 @@ title: "Canary release channel and local feature flags"
 status: active
 date: 2026-03-25
 ---
-
 ## Context
 
 Shipping new features directly to all users is risky. A mechanism was needed to let early adopters test pre-release builds and to gate experimental features behind flags that can be toggled without a new release.
 
+[[Keyboard-first design principle]]
+
 ## Decision
 
-**Add a canary release channel alongside stable, with builds from the `canary` branch. Feature flags are localStorage-based (`ff_<name>`) with compile-time defaults, checked via `useFeatureFlag(flag)` hook. The update channel is configurable in Settings.**
+**Add a canary release channel alongside stable, with builds from the&#x20;**`canary`**&#x20;branch. Feature flags are localStorage-based (**`ff_<name>`**) with compile-time defaults, checked via&#x20;**`useFeatureFlag(flag)`**&#x20;hook. The update channel is configurable in Settings.**
 
 ## Options considered
 
-- **Option A** (chosen): Canary branch + localStorage feature flags — simple, no server infrastructure, users opt in via Settings. Downside: no remote flag management, no gradual rollout percentages.
-- **Option B**: Server-side feature flags (LaunchDarkly, Unleash) — gradual rollouts, A/B testing. Downside: external dependency, requires server infrastructure, adds latency.
-- **Option C**: Single release channel with only feature flags — simpler CI. Downside: no way to test full pre-release builds.
+* **Option A** (chosen): Canary branch + localStorage feature flags — simple, no server infrastructure, users opt in via Settings. Downside: no remote flag management, no gradual rollout percentages.
+* **Option B**: Server-side feature flags (LaunchDarkly, Unleash) — gradual rollouts, A/B testing. Downside: external dependency, requires server infrastructure, adds latency.
+* **Option C**: Single release channel with only feature flags — simpler CI. Downside: no way to test full pre-release builds.
 
 ## Consequences
 
-- `release.yml` builds stable from `main`; `release-canary.yml` builds canary from `canary` branch.
-- Canary releases produce `latest-canary.json` on GitHub Pages, marked as prerelease.
-- `useUpdater(channel)` checks the appropriate update manifest.
-- `useFeatureFlag(flag)` checks localStorage override, then compile-time default. Type-safe via `FeatureFlagName` union.
-- `update_channel` stored in Settings as `"stable"` or `"canary"`.
-- Re-evaluation trigger: if user base grows enough to warrant server-side gradual rollouts.
+* `release.yml` builds stable from `main`; `release-canary.yml` builds canary from `canary` branch.
+* Canary releases produce `latest-canary.json` on GitHub Pages, marked as prerelease.
+* `useUpdater(channel)` checks the appropriate update manifest.
+* `useFeatureFlag(flag)` checks localStorage override, then compile-time default. Type-safe via `FeatureFlagName` union.
+* `update_channel` stored in Settings as `"stable"` or `"canary"`.
+* Re-evaluation trigger: if user base grows enough to warrant server-side gradual rollouts.

index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet" />
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=Inter:wght@400;500;600;700&family=JetBrains+Mono&display=swap" rel="stylesheet" />
     <title>laputa-scaffold</title>
   </head>
   <body>

package.json

@@ -32,6 +32,7 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
+    "@lezer/highlight": "^1.2.3",
     "@mantine/core": "^8.3.14",
     "@phosphor-icons/react": "^2.1.10",
     "@radix-ui/react-dialog": "^1.1.15",
@@ -41,7 +42,7 @@
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
     "@radix-ui/react-tooltip": "^1.2.8",
-    "@sentry/browser": "^10.45.0",
+    "@sentry/react": "^10.47.0",
     "@tailwindcss/vite": "^4.1.18",
     "@tauri-apps/api": "^2.10.1",
     "@tauri-apps/plugin-dialog": "^2.6.0",

pnpm-lock.yaml

@@ -47,6 +47,9 @@ importers:
       '@dnd-kit/utilities':
         specifier: ^3.2.2
         version: 3.2.2(react@19.2.4)
+      '@lezer/highlight':
+        specifier: ^1.2.3
+        version: 1.2.3
       '@mantine/core':
         specifier: ^8.3.14
         version: 8.3.14(@mantine/hooks@8.3.14(react@19.2.4))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -74,9 +77,9 @@ importers:
       '@radix-ui/react-tooltip':
         specifier: ^1.2.8
         version: 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
-      '@sentry/browser':
-        specifier: ^10.45.0
-        version: 10.45.0
+      '@sentry/react':
+        specifier: ^10.47.0
+        version: 10.47.0(react@19.2.4)
       '@tailwindcss/vite':
         specifier: ^4.1.18
         version: 4.1.18(vite@7.3.1(@types/node@24.10.13)(jiti@2.6.1)(lightningcss@1.30.2))
@@ -1782,30 +1785,36 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@sentry-internal/browser-utils@10.45.0':
-    resolution: {integrity: sha512-ZPZpeIarXKScvquGx2AfNKcYiVNDA4wegMmjyGVsTA2JPmP0TrJoO3UybJS6KGDeee8V3I3EfD/ruauMm7jOFQ==}
+  '@sentry-internal/browser-utils@10.47.0':
+    resolution: {integrity: sha512-bVFRAeJWMBcBCvJKIFCMJ1/yQToL4vPGqfmlnDZeypcxkqUDKQ/Y3ziLHXoDL2sx0lagcgU2vH1QhCQ67Aujjw==}
     engines: {node: '>=18'}
 
-  '@sentry-internal/feedback@10.45.0':
-    resolution: {integrity: sha512-vCSurazFVq7RUeYiM5X326jA5gOVrWYD6lYX2fbjBOMcyCEhDnveNxMT62zKkZDyNT/jyD194nz/cjntBUkyWA==}
+  '@sentry-internal/feedback@10.47.0':
+    resolution: {integrity: sha512-pdvMmi4dQpX5S/vAAzrhHPIw3T3HjUgDNgUiCBrlp7N9/6zGO2gNPhUnNekP+CjgI/z0rvf49RLqlDenpNrMOg==}
     engines: {node: '>=18'}
 
-  '@sentry-internal/replay-canvas@10.45.0':
-    resolution: {integrity: sha512-nvq/AocdZTuD7y0KSiWi3gVaY0s5HOFy86mC/v1kDZmT/jsBAzN5LDkk/f1FvsWma1peqQmpUqxvhC+YIW294Q==}
+  '@sentry-internal/replay-canvas@10.47.0':
+    resolution: {integrity: sha512-A5OY8friSe6g8WAK4L8IeOPiEd9D3Ps40DzRH5j2f6SUja0t90mKMvHRcRf8zq0d4BkdB+JM7tjOkwxpuv8heA==}
     engines: {node: '>=18'}
 
-  '@sentry-internal/replay@10.45.0':
-    resolution: {integrity: sha512-vjosRoGA1bzhVAEO1oce+CsRdd70quzBeo7WvYqpcUnoLe/Rv8qpOMqWX3j26z7XfFHMExWQNQeLxmtYOArvlw==}
+  '@sentry-internal/replay@10.47.0':
+    resolution: {integrity: sha512-ScdovxP7hJxgMt70+7hFvwT02GIaIUAxdEM/YPsayZBeCoAukPW8WiwztJfoKtsfPyKJ5A6f0H3PIxTPcA9Row==}
     engines: {node: '>=18'}
 
-  '@sentry/browser@10.45.0':
-    resolution: {integrity: sha512-e/a8UMiQhqqv706McSIcG6XK+AoQf9INthi2pD+giZfNRTzXTdqHzUT5OIO5hg8Am6eF63nDJc+vrYNPhzs51Q==}
+  '@sentry/browser@10.47.0':
+    resolution: {integrity: sha512-rC0agZdxKA5XWfL4VwPOr/rJMogXDqZgnVzr93YWpFn9DMZT/7LzxSJVPIJwRUjx3bFEby3PcTa3YaX7pxm1AA==}
     engines: {node: '>=18'}
 
-  '@sentry/core@10.45.0':
-    resolution: {integrity: sha512-s69UXxvefeQxuZ5nY7/THtTrIEvJxNVCp3ns4kwoCw1qMpgpvn/296WCKVmM7MiwnaAdzEKnAvLAwaxZc2nM7Q==}
+  '@sentry/core@10.47.0':
+    resolution: {integrity: sha512-nsYRAx3EWezDut+Zl+UwwP07thh9uY7CfSAi2whTdcJl5hu1nSp2z8bba7Vq/MGbNLnazkd3A+GITBEML924JA==}
     engines: {node: '>=18'}
 
+  '@sentry/react@10.47.0':
+    resolution: {integrity: sha512-ZtJV6xxF8jUVE9e3YQUG3Do0XapG1GjniyLyqMPgN6cNvs/HaRJODf7m60By+VGqcl5XArEjEPTvx8CdPUXDfA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: ^16.14.0 || 17.x || 18.x || 19.x
+
   '@shikijs/types@3.22.0':
     resolution: {integrity: sha512-491iAekgKDBFE67z70Ok5a8KBMsQ2IJwOWw3us/7ffQkIBCyOQfm/aNwVMBUriP02QshIfgHCBSIYAl3u2eWjg==}
 
@@ -5938,33 +5947,39 @@ snapshots:
   '@rollup/rollup-win32-x64-msvc@4.57.1':
     optional: true
 
-  '@sentry-internal/browser-utils@10.45.0':
+  '@sentry-internal/browser-utils@10.47.0':
     dependencies:
-      '@sentry/core': 10.45.0
+      '@sentry/core': 10.47.0
 
-  '@sentry-internal/feedback@10.45.0':
+  '@sentry-internal/feedback@10.47.0':
     dependencies:
-      '@sentry/core': 10.45.0
+      '@sentry/core': 10.47.0
 
-  '@sentry-internal/replay-canvas@10.45.0':
+  '@sentry-internal/replay-canvas@10.47.0':
     dependencies:
-      '@sentry-internal/replay': 10.45.0
-      '@sentry/core': 10.45.0
+      '@sentry-internal/replay': 10.47.0
+      '@sentry/core': 10.47.0
 
-  '@sentry-internal/replay@10.45.0':
+  '@sentry-internal/replay@10.47.0':
     dependencies:
-      '@sentry-internal/browser-utils': 10.45.0
-      '@sentry/core': 10.45.0
+      '@sentry-internal/browser-utils': 10.47.0
+      '@sentry/core': 10.47.0
 
-  '@sentry/browser@10.45.0':
+  '@sentry/browser@10.47.0':
     dependencies:
-      '@sentry-internal/browser-utils': 10.45.0
-      '@sentry-internal/feedback': 10.45.0
-      '@sentry-internal/replay': 10.45.0
-      '@sentry-internal/replay-canvas': 10.45.0
-      '@sentry/core': 10.45.0
+      '@sentry-internal/browser-utils': 10.47.0
+      '@sentry-internal/feedback': 10.47.0
+      '@sentry-internal/replay': 10.47.0
+      '@sentry-internal/replay-canvas': 10.47.0
+      '@sentry/core': 10.47.0
 
-  '@sentry/core@10.45.0': {}
+  '@sentry/core@10.47.0': {}
+
+  '@sentry/react@10.47.0(react@19.2.4)':
+    dependencies:
+      '@sentry/browser': 10.47.0
+      '@sentry/core': 10.47.0
+      react: 19.2.4
 
   '@shikijs/types@3.22.0':
     dependencies:

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/ai_chat.rs

@@ -1,386 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Deserialize)]
-pub struct AiChatRequest {
-    pub model: Option<String>,
-    pub messages: Vec<AiMessage>,
-    pub system: Option<String>,
-    pub max_tokens: Option<u32>,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct AiMessage {
-    pub role: String,
-    pub content: String,
-}
-
-#[derive(Debug, Serialize)]
-pub struct AiChatResponse {
-    pub content: String,
-    pub model: String,
-    pub stop_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct AnthropicResponse {
-    content: Vec<ContentBlock>,
-    model: String,
-    stop_reason: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ContentBlock {
-    text: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-struct AnthropicRequest {
-    model: String,
-    max_tokens: u32,
-    messages: Vec<AiMessage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    system: Option<String>,
-}
-
-fn get_api_key() -> Result<String, String> {
-    std::env::var("ANTHROPIC_API_KEY")
-        .map_err(|_| "ANTHROPIC_API_KEY environment variable not set".to_string())
-}
-
-fn build_request(req: &AiChatRequest) -> AnthropicRequest {
-    AnthropicRequest {
-        model: req
-            .model
-            .clone()
-            .unwrap_or_else(|| "claude-3-5-haiku-20241022".to_string()),
-        max_tokens: req.max_tokens.unwrap_or(4096),
-        messages: req.messages.clone(),
-        system: req.system.clone(),
-    }
-}
-
-fn extract_response_text(resp: &AnthropicResponse) -> String {
-    resp.content
-        .iter()
-        .filter_map(|block| block.text.as_ref())
-        .cloned()
-        .collect::<Vec<_>>()
-        .join("")
-}
-
-pub async fn send_chat(req: AiChatRequest) -> Result<AiChatResponse, String> {
-    let api_key = get_api_key()?;
-    send_chat_with_base(req, "https://api.anthropic.com", &api_key).await
-}
-
-async fn send_chat_with_base(
-    req: AiChatRequest,
-    api_base: &str,
-    api_key: &str,
-) -> Result<AiChatResponse, String> {
-    let anthropic_req = build_request(&req);
-
-    let client = reqwest::Client::new();
-    let response = client
-        .post(format!("{}/v1/messages", api_base))
-        .header("x-api-key", api_key)
-        .header("anthropic-version", "2023-06-01")
-        .header("content-type", "application/json")
-        .json(&anthropic_req)
-        .send()
-        .await
-        .map_err(|e| format!("Request failed: {}", e))?;
-
-    if !response.status().is_success() {
-        let status = response.status();
-        let body = response.text().await.unwrap_or_default();
-        return Err(format!("Anthropic API error ({}): {}", status, body));
-    }
-
-    let anthropic_resp: AnthropicResponse = response
-        .json()
-        .await
-        .map_err(|e| format!("Failed to parse response: {}", e))?;
-
-    Ok(AiChatResponse {
-        content: extract_response_text(&anthropic_resp),
-        model: anthropic_resp.model,
-        stop_reason: anthropic_resp.stop_reason,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // ── Pure logic tests ─────────────────────────────────────────────────────
-
-    #[test]
-    fn test_build_request_defaults() {
-        let req = AiChatRequest {
-            model: None,
-            messages: vec![AiMessage {
-                role: "user".to_string(),
-                content: "Hello".to_string(),
-            }],
-            system: None,
-            max_tokens: None,
-        };
-        let built = build_request(&req);
-        assert_eq!(built.model, "claude-3-5-haiku-20241022");
-        assert_eq!(built.max_tokens, 4096);
-        assert!(built.system.is_none());
-    }
-
-    #[test]
-    fn test_build_request_custom() {
-        let req = AiChatRequest {
-            model: Some("claude-sonnet-4-20250514".to_string()),
-            messages: vec![],
-            system: Some("You are helpful".to_string()),
-            max_tokens: Some(1024),
-        };
-        let built = build_request(&req);
-        assert_eq!(built.model, "claude-sonnet-4-20250514");
-        assert_eq!(built.max_tokens, 1024);
-        assert_eq!(built.system.unwrap(), "You are helpful");
-    }
-
-    #[test]
-    fn test_extract_response_text() {
-        let resp = AnthropicResponse {
-            content: vec![
-                ContentBlock {
-                    text: Some("Hello ".to_string()),
-                },
-                ContentBlock {
-                    text: Some("world".to_string()),
-                },
-                ContentBlock { text: None },
-            ],
-            model: "test".to_string(),
-            stop_reason: Some("end_turn".to_string()),
-        };
-        assert_eq!(extract_response_text(&resp), "Hello world");
-    }
-
-    #[test]
-    fn test_extract_response_text_empty() {
-        let resp = AnthropicResponse {
-            content: vec![],
-            model: "test".to_string(),
-            stop_reason: None,
-        };
-        assert_eq!(extract_response_text(&resp), "");
-    }
-
-    #[test]
-    fn test_extract_response_text_all_none() {
-        let resp = AnthropicResponse {
-            content: vec![ContentBlock { text: None }, ContentBlock { text: None }],
-            model: "test".to_string(),
-            stop_reason: None,
-        };
-        assert_eq!(extract_response_text(&resp), "");
-    }
-
-    // Mutex to serialize env-var tests and avoid race conditions in parallel test runs
-    static ENV_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());
-
-    #[test]
-    fn test_get_api_key_missing() {
-        let _guard = ENV_MUTEX.lock().unwrap();
-        // Temporarily clear the env var
-        let prev = std::env::var("ANTHROPIC_API_KEY").ok();
-        unsafe {
-            std::env::remove_var("ANTHROPIC_API_KEY");
-        }
-        let result = get_api_key();
-        // Restore
-        if let Some(val) = prev {
-            unsafe {
-                std::env::set_var("ANTHROPIC_API_KEY", val);
-            }
-        }
-        assert!(result.is_err());
-        assert!(result
-            .unwrap_err()
-            .contains("ANTHROPIC_API_KEY environment variable not set"));
-    }
-
-    #[test]
-    fn test_get_api_key_present() {
-        let _guard = ENV_MUTEX.lock().unwrap();
-        let prev = std::env::var("ANTHROPIC_API_KEY").ok();
-        unsafe {
-            std::env::set_var("ANTHROPIC_API_KEY", "sk-test-key-123");
-        }
-        let result = get_api_key();
-        if let Some(val) = prev {
-            unsafe {
-                std::env::set_var("ANTHROPIC_API_KEY", val);
-            }
-        } else {
-            unsafe {
-                std::env::remove_var("ANTHROPIC_API_KEY");
-            }
-        }
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "sk-test-key-123");
-    }
-
-    // ── HTTP mock tests ──────────────────────────────────────────────────────
-
-    #[tokio::test]
-    async fn test_send_chat_success() {
-        let mut server = mockito::Server::new_async().await;
-        let mock = server
-            .mock("POST", "/v1/messages")
-            .with_status(200)
-            .with_header("content-type", "application/json")
-            .with_body(
-                r#"{"id":"msg_01","type":"message","role":"assistant","content":[{"type":"text","text":"Hello there!"}],"model":"claude-3-5-haiku-20241022","stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":5}}"#,
-            )
-            .create_async()
-            .await;
-
-        let req = AiChatRequest {
-            model: None,
-            messages: vec![AiMessage {
-                role: "user".to_string(),
-                content: "Say hello".to_string(),
-            }],
-            system: None,
-            max_tokens: None,
-        };
-
-        let result = send_chat_with_base(req, &server.url(), "sk-test-key").await;
-        mock.assert_async().await;
-        assert!(result.is_ok());
-        let resp = result.unwrap();
-        assert_eq!(resp.content, "Hello there!");
-        assert_eq!(resp.model, "claude-3-5-haiku-20241022");
-        assert_eq!(resp.stop_reason, Some("end_turn".to_string()));
-    }
-
-    #[tokio::test]
-    async fn test_send_chat_with_system_prompt() {
-        let mut server = mockito::Server::new_async().await;
-        let mock = server
-            .mock("POST", "/v1/messages")
-            .with_status(200)
-            .with_header("content-type", "application/json")
-            .with_body(
-                r#"{"id":"msg_02","type":"message","role":"assistant","content":[{"type":"text","text":"I am a helpful assistant."}],"model":"claude-sonnet-4-20250514","stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":20,"output_tokens":8}}"#,
-            )
-            .create_async()
-            .await;
-
-        let req = AiChatRequest {
-            model: Some("claude-sonnet-4-20250514".to_string()),
-            messages: vec![AiMessage {
-                role: "user".to_string(),
-                content: "Who are you?".to_string(),
-            }],
-            system: Some("You are a helpful assistant.".to_string()),
-            max_tokens: Some(512),
-        };
-
-        let result = send_chat_with_base(req, &server.url(), "sk-key").await;
-        mock.assert_async().await;
-        assert!(result.is_ok());
-        let resp = result.unwrap();
-        assert_eq!(resp.model, "claude-sonnet-4-20250514");
-        assert_eq!(resp.content, "I am a helpful assistant.");
-    }
-
-    #[tokio::test]
-    async fn test_send_chat_api_error() {
-        let mut server = mockito::Server::new_async().await;
-        let mock = server
-            .mock("POST", "/v1/messages")
-            .with_status(401)
-            .with_header("content-type", "application/json")
-            .with_body(r#"{"type":"error","error":{"type":"authentication_error","message":"Invalid API key"}}"#)
-            .create_async()
-            .await;
-
-        let req = AiChatRequest {
-            model: None,
-            messages: vec![AiMessage {
-                role: "user".to_string(),
-                content: "Hello".to_string(),
-            }],
-            system: None,
-            max_tokens: None,
-        };
-
-        let result = send_chat_with_base(req, &server.url(), "bad-key").await;
-        mock.assert_async().await;
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(
-            err.contains("Anthropic API error") && err.contains("401"),
-            "unexpected error: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn test_send_chat_rate_limit() {
-        let mut server = mockito::Server::new_async().await;
-        let mock = server
-            .mock("POST", "/v1/messages")
-            .with_status(429)
-            .with_header("content-type", "application/json")
-            .with_body(r#"{"type":"error","error":{"type":"rate_limit_error","message":"Rate limit exceeded"}}"#)
-            .create_async()
-            .await;
-
-        let req = AiChatRequest {
-            model: None,
-            messages: vec![],
-            system: None,
-            max_tokens: None,
-        };
-
-        let result = send_chat_with_base(req, &server.url(), "sk-key").await;
-        mock.assert_async().await;
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(
-            err.contains("Anthropic API error") && err.contains("429"),
-            "unexpected error: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn test_send_chat_multiple_content_blocks() {
-        let mut server = mockito::Server::new_async().await;
-        let mock = server
-            .mock("POST", "/v1/messages")
-            .with_status(200)
-            .with_header("content-type", "application/json")
-            .with_body(
-                r#"{"id":"msg_03","type":"message","role":"assistant","content":[{"type":"text","text":"Part one. "},{"type":"text","text":"Part two."}],"model":"claude-3-5-haiku-20241022","stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":5,"output_tokens":10}}"#,
-            )
-            .create_async()
-            .await;
-
-        let req = AiChatRequest {
-            model: None,
-            messages: vec![AiMessage {
-                role: "user".to_string(),
-                content: "Give me two parts".to_string(),
-            }],
-            system: None,
-            max_tokens: None,
-        };
-
-        let result = send_chat_with_base(req, &server.url(), "sk-key").await;
-        mock.assert_async().await;
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap().content, "Part one. Part two.");
-    }
-}

src-tauri/src/commands/ai.rs

@@ -1,14 +1,8 @@
-use crate::ai_chat::{AiChatRequest, AiChatResponse};
 #[cfg(desktop)]
 use crate::claude_cli::ClaudeStreamEvent;
 use crate::claude_cli::{AgentStreamRequest, ChatStreamRequest, ClaudeCliStatus};
 
-// ── AI / Claude commands (desktop) ──────────────────────────────────────────
-
-#[tauri::command]
-pub async fn ai_chat(request: AiChatRequest) -> Result<AiChatResponse, String> {
-    crate::ai_chat::send_chat(request).await
-}
+// ── Claude CLI commands (desktop) ───────────────────────────────────────────
 
 #[cfg(desktop)]
 #[tauri::command]

src-tauri/src/commands/git.rs

@@ -128,6 +128,22 @@ pub async fn git_remote_status(vault_path: String) -> Result<GitRemoteStatus, St
         .map_err(|e| format!("Task panicked: {e}"))?
 }
 
+#[cfg(desktop)]
+#[tauri::command]
+pub fn is_git_repo(vault_path: String) -> bool {
+    let vault_path = expand_tilde(&vault_path);
+    std::path::Path::new(vault_path.as_ref())
+        .join(".git")
+        .is_dir()
+}
+
+#[cfg(desktop)]
+#[tauri::command]
+pub fn init_git_repo(vault_path: String) -> Result<(), String> {
+    let vault_path = expand_tilde(&vault_path);
+    crate::git::init_repo(&vault_path)
+}
+
 // ── Git commands (mobile stubs) ─────────────────────────────────────────────
 
 #[cfg(mobile)]
@@ -230,3 +246,15 @@ pub async fn git_remote_status(_vault_path: String) -> Result<GitRemoteStatus, S
         behind: 0,
     })
 }
+
+#[cfg(mobile)]
+#[tauri::command]
+pub fn is_git_repo(_vault_path: String) -> bool {
+    false
+}
+
+#[cfg(mobile)]
+#[tauri::command]
+pub fn init_git_repo(_vault_path: String) -> Result<(), String> {
+    Err("Git init is not available on mobile".into())
+}

src-tauri/src/commands/vault.rs

@@ -1,6 +1,8 @@
 use crate::frontmatter::FrontmatterValue;
 use crate::search::SearchResponse;
-use crate::vault::{RenameResult, VaultEntry};
+use crate::vault::{
+    DetectedRename, FolderNode, RenameResult, VaultEntry, ViewDefinition, ViewFile,
+};
 use crate::{frontmatter, git, search, vault};
 
 use super::expand_tilde;
@@ -13,6 +15,12 @@ pub fn list_vault(path: String) -> Result<Vec<VaultEntry>, String> {
     vault::scan_vault_cached(std::path::Path::new(path.as_ref()))
 }
 
+#[tauri::command]
+pub fn list_vault_folders(path: String) -> Result<Vec<FolderNode>, String> {
+    let path = expand_tilde(&path);
+    vault::scan_vault_folders(std::path::Path::new(path.as_ref()))
+}
+
 #[tauri::command]
 pub fn get_note_content(path: String) -> Result<String, String> {
     let path = expand_tilde(&path);
@@ -37,6 +45,21 @@ pub fn rename_note(
     vault::rename_note(&vault_path, &old_path, &new_title, old_title.as_deref())
 }
 
+#[tauri::command]
+pub fn detect_renames(vault_path: String) -> Result<Vec<DetectedRename>, String> {
+    let vault_path = expand_tilde(&vault_path);
+    vault::detect_renames(&vault_path)
+}
+
+#[tauri::command]
+pub fn update_wikilinks_for_renames(
+    vault_path: String,
+    renames: Vec<DetectedRename>,
+) -> Result<usize, String> {
+    let vault_path = expand_tilde(&vault_path);
+    vault::update_wikilinks_for_renames(&vault_path, &renames)
+}
+
 #[tauri::command]
 pub fn purge_trash(vault_path: String) -> Result<Vec<String>, String> {
     let vault_path = expand_tilde(&vault_path);
@@ -68,15 +91,14 @@ pub fn migrate_is_a_to_type(vault_path: String) -> Result<usize, String> {
 }
 
 #[tauri::command]
-pub fn flatten_vault(vault_path: String) -> Result<usize, String> {
+pub fn create_vault_folder(vault_path: String, folder_name: String) -> Result<String, String> {
     let vault_path = expand_tilde(&vault_path);
-    vault::flatten_vault(&vault_path)
-}
-
-#[tauri::command]
-pub fn vault_health_check(vault_path: String) -> Result<vault::VaultHealthReport, String> {
-    let vault_path = expand_tilde(&vault_path);
-    vault::vault_health_check(&vault_path)
+    let folder_path = std::path::Path::new(vault_path.as_ref()).join(&folder_name);
+    if folder_path.exists() {
+        return Err(format!("Folder '{}' already exists", folder_name));
+    }
+    std::fs::create_dir_all(&folder_path).map_err(|e| format!("Failed to create folder: {}", e))?;
+    Ok(folder_name)
 }
 
 #[tauri::command]
@@ -138,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]
@@ -161,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)
@@ -173,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;
@@ -206,7 +252,6 @@ pub async fn search_vault(
 pub fn repair_vault(vault_path: String) -> Result<String, String> {
     let vault_path = expand_tilde(&vault_path);
     vault::migrate_is_a_to_type(&vault_path)?;
-    vault::flatten_vault(&vault_path)?;
     vault::repair_config_files(&vault_path)?;
     git::ensure_gitignore(&vault_path)?;
     Ok("Vault repaired".to_string())
@@ -231,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"));
     }
 
@@ -243,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]
@@ -341,7 +386,7 @@ mod tests {
     }
 
     #[test]
-    fn test_repair_vault_flattens_type_folders() {
+    fn test_repair_vault_migrates_is_a_to_type() {
         let dir = tempfile::TempDir::new().unwrap();
         let vault_path = dir.path();
         let note_dir = vault_path.join("note");
@@ -350,9 +395,8 @@ mod tests {
 
         let result = repair_vault(vault_path.to_str().unwrap().to_string());
         assert!(result.is_ok());
-        assert!(vault_path.join("hello.md").exists());
-        assert!(!note_dir.join("hello.md").exists());
-        let content = std::fs::read_to_string(vault_path.join("hello.md")).unwrap();
+        assert!(note_dir.join("hello.md").exists());
+        let content = std::fs::read_to_string(note_dir.join("hello.md")).unwrap();
         assert!(content.contains("type: Note"));
         assert!(!content.contains("is_a:"));
     }

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

@@ -1,4 +1,3 @@
-pub mod ai_chat;
 pub mod claude_cli;
 mod commands;
 pub mod frontmatter;
@@ -118,11 +117,14 @@ pub fn run() {
         })
         .invoke_handler(tauri::generate_handler![
             commands::list_vault,
+            commands::list_vault_folders,
             commands::get_note_content,
             commands::save_note_content,
             commands::update_frontmatter,
             commands::delete_frontmatter_property,
             commands::rename_note,
+            commands::detect_renames,
+            commands::update_wikilinks_for_renames,
             commands::get_file_history,
             commands::get_modified_files,
             commands::get_file_diff,
@@ -138,7 +140,8 @@ pub fn run() {
             commands::get_conflict_mode,
             commands::git_resolve_conflict,
             commands::git_commit_conflict_resolution,
-            commands::ai_chat,
+            commands::is_git_repo,
+            commands::init_git_repo,
             commands::check_claude_cli,
             commands::stream_claude_chat,
             commands::stream_claude_agent,
@@ -152,8 +155,7 @@ pub fn run() {
             commands::batch_delete_notes,
             commands::empty_trash,
             commands::migrate_is_a_to_type,
-            commands::flatten_vault,
-            commands::vault_health_check,
+            commands::create_vault_folder,
             commands::batch_archive_notes,
             commands::batch_trash_notes,
             commands::get_settings,
@@ -174,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/menu.rs

@@ -293,9 +293,9 @@ fn build_note_menu(app: &App) -> MenuResult {
         .id(EDIT_TOGGLE_RAW_EDITOR)
         .accelerator("CmdOrCtrl+\\")
         .build(app)?;
-    let toggle_ai_chat = MenuItemBuilder::new("Toggle AI Chat")
+    let toggle_ai_chat = MenuItemBuilder::new("Toggle AI Panel")
         .id(VIEW_TOGGLE_AI_CHAT)
-        .accelerator("CmdOrCtrl+I")
+        .accelerator("CmdOrCtrl+Alt+I")
         .build(app)?;
     let toggle_backlinks = MenuItemBuilder::new("Toggle Backlinks")
         .id(VIEW_TOGGLE_BACKLINKS)

src-tauri/src/settings.rs

@@ -4,7 +4,6 @@ use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct Settings {
-    pub anthropic_key: Option<String>,
     pub openai_key: Option<String>,
     pub google_key: Option<String>,
     pub github_token: Option<String>,
@@ -15,6 +14,7 @@ pub struct Settings {
     pub analytics_enabled: Option<bool>,
     pub anonymous_id: Option<String>,
     pub update_channel: Option<String>,
+    pub release_channel: Option<String>,
 }
 
 fn settings_path() -> Result<PathBuf, String> {
@@ -40,10 +40,6 @@ fn save_settings_at(path: &PathBuf, settings: Settings) -> Result<(), String> {
 
     // Trim whitespace and convert empty strings to None
     let cleaned = Settings {
-        anthropic_key: settings
-            .anthropic_key
-            .map(|k| k.trim().to_string())
-            .filter(|k| !k.is_empty()),
         openai_key: settings
             .openai_key
             .map(|k| k.trim().to_string())
@@ -72,6 +68,10 @@ fn save_settings_at(path: &PathBuf, settings: Settings) -> Result<(), String> {
             .update_channel
             .map(|k| k.trim().to_string())
             .filter(|k| !k.is_empty()),
+        release_channel: settings
+            .release_channel
+            .map(|k| k.trim().to_string())
+            .filter(|k| !k.is_empty()),
     };
 
     let json = serde_json::to_string_pretty(&cleaned)
@@ -132,7 +132,6 @@ mod tests {
     #[test]
     fn test_default_settings_all_none() {
         let s = Settings::default();
-        assert!(s.anthropic_key.is_none());
         assert!(s.openai_key.is_none());
         assert!(s.google_key.is_none());
         assert!(s.github_token.is_none());
@@ -148,7 +147,6 @@ mod tests {
     #[test]
     fn test_settings_json_roundtrip() {
         let settings = Settings {
-            anthropic_key: Some("sk-ant-test123".to_string()),
             openai_key: None,
             google_key: Some("AIza-test".to_string()),
             github_token: Some("gho_xyz789".to_string()),
@@ -161,7 +159,6 @@ mod tests {
         };
         let json = serde_json::to_string(&settings).unwrap();
         let parsed: Settings = serde_json::from_str(&json).unwrap();
-        assert_eq!(parsed.anthropic_key, settings.anthropic_key);
         assert_eq!(parsed.google_key, settings.google_key);
         assert_eq!(parsed.github_token, settings.github_token);
         assert_eq!(parsed.github_username, settings.github_username);
@@ -176,13 +173,12 @@ mod tests {
         let dir = tempfile::TempDir::new().unwrap();
         let path = dir.path().join("nonexistent.json");
         let result = get_settings_at(&path).unwrap();
-        assert!(result.anthropic_key.is_none());
+        assert!(result.openai_key.is_none());
     }
 
     #[test]
     fn test_save_and_load_preserves_values() {
         let loaded = save_and_reload(Settings {
-            anthropic_key: Some("sk-ant-key".to_string()),
             openai_key: Some("sk-openai".to_string()),
             google_key: None,
             github_token: Some("gho_token123".to_string()),
@@ -190,7 +186,6 @@ mod tests {
             auto_pull_interval_minutes: Some(10),
             ..Default::default()
         });
-        assert_eq!(loaded.anthropic_key.as_deref(), Some("sk-ant-key"));
         assert_eq!(loaded.openai_key.as_deref(), Some("sk-openai"));
         assert_eq!(loaded.github_token.as_deref(), Some("gho_token123"));
         assert_eq!(loaded.github_username.as_deref(), Some("lucaong"));
@@ -200,12 +195,10 @@ mod tests {
     #[test]
     fn test_save_trims_whitespace() {
         let loaded = save_and_reload(Settings {
-            anthropic_key: Some("  sk-ant-test  ".to_string()),
             github_token: Some("  gho_abc  ".to_string()),
             github_username: Some("  lucaong  ".to_string()),
             ..Default::default()
         });
-        assert_eq!(loaded.anthropic_key.as_deref(), Some("sk-ant-test"));
         assert_eq!(loaded.github_token.as_deref(), Some("gho_abc"));
         assert_eq!(loaded.github_username.as_deref(), Some("lucaong"));
     }
@@ -213,12 +206,10 @@ mod tests {
     #[test]
     fn test_save_filters_empty_and_whitespace_only() {
         let loaded = save_and_reload(Settings {
-            anthropic_key: Some("".to_string()),
             openai_key: Some("   ".to_string()),
             github_username: Some("".to_string()),
             ..Default::default()
         });
-        assert!(loaded.anthropic_key.is_none());
         assert!(loaded.openai_key.is_none());
         assert!(loaded.github_username.is_none());
     }
@@ -231,14 +222,14 @@ mod tests {
         save_settings_at(
             &path,
             Settings {
-                anthropic_key: Some("key".to_string()),
+                openai_key: Some("key".to_string()),
                 ..Default::default()
             },
         )
         .unwrap();
         assert!(path.exists());
         assert_eq!(
-            get_settings_at(&path).unwrap().anthropic_key.as_deref(),
+            get_settings_at(&path).unwrap().openai_key.as_deref(),
             Some("key")
         );
     }
@@ -273,9 +264,9 @@ mod tests {
         let dir = tempfile::TempDir::new().unwrap();
         let path = dir.path().join("settings.json");
         // Simulate old settings.json without telemetry fields
-        fs::write(&path, r#"{"anthropic_key":"sk-test"}"#).unwrap();
+        fs::write(&path, r#"{"openai_key":"sk-test"}"#).unwrap();
         let loaded = get_settings_at(&path).unwrap();
-        assert_eq!(loaded.anthropic_key.as_deref(), Some("sk-test"));
+        assert_eq!(loaded.openai_key.as_deref(), Some("sk-test"));
         assert!(loaded.telemetry_consent.is_none());
         assert!(loaded.crash_reporting_enabled.is_none());
         assert!(loaded.analytics_enabled.is_none());

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 = 8;
+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

@@ -1,6 +1,17 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+/// A node in the vault's folder tree. Only contains directories, not files.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct FolderNode {
+    /// Folder name (last path component).
+    pub name: String,
+    /// Path relative to the vault root, using `/` separators (e.g. "projects/laputa").
+    pub path: String,
+    /// Child folders (sorted alphabetically).
+    pub children: Vec<FolderNode>,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct VaultEntry {
     pub path: String,
@@ -48,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,
@@ -59,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.
@@ -284,20 +305,120 @@ fn pod_to_json(pod: gray_matter::Pod) -> serde_json::Value {
     }
 }
 
+/// Strip matching outer quotes (single or double) from a YAML scalar.
+fn unquote(s: &str) -> &str {
+    s.strip_prefix('"')
+        .and_then(|rest| rest.strip_suffix('"'))
+        .or_else(|| {
+            s.strip_prefix('\'')
+                .and_then(|rest| rest.strip_suffix('\''))
+        })
+        .unwrap_or(s)
+}
+
+/// Parse a scalar YAML value into a JSON value.
+fn parse_scalar(s: &str) -> serde_json::Value {
+    let trimmed = unquote(s);
+    match trimmed.to_lowercase().as_str() {
+        "true" | "yes" => serde_json::Value::Bool(true),
+        "false" | "no" => serde_json::Value::Bool(false),
+        _ => trimmed
+            .parse::<i64>()
+            .map(|n| serde_json::json!(n))
+            .unwrap_or_else(|_| serde_json::Value::String(trimmed.to_string())),
+    }
+}
+
+/// Return the key from a top-level `key:` or `"key":` YAML line.
+/// Returns `None` for indented, blank, or non-key lines.
+fn extract_yaml_key(line: &str) -> Option<&str> {
+    if line.is_empty() || line.starts_with(' ') || line.starts_with('\t') {
+        return None;
+    }
+    let (k, _) = line.split_once(':')?;
+    Some(k.trim().trim_matches('"'))
+}
+
+/// Flush a pending list accumulator into the map.
+fn flush_list(
+    map: &mut HashMap<String, serde_json::Value>,
+    key: &mut Option<String>,
+    items: &mut Vec<serde_json::Value>,
+) {
+    if let Some(k) = key.take() {
+        if !items.is_empty() {
+            map.insert(k, serde_json::Value::Array(std::mem::take(items)));
+        }
+    }
+}
+
+/// Fallback parser for when gray_matter fails to parse YAML (returns raw string).
+/// Extracts simple `key: value` lines, handling booleans, numbers, quoted strings,
+/// and YAML lists.
+fn fallback_parse_yaml_string(raw: &str) -> HashMap<String, serde_json::Value> {
+    let mut map = HashMap::new();
+    let mut list_key: Option<String> = None;
+    let mut list_items: Vec<serde_json::Value> = Vec::new();
+
+    for line in raw.lines() {
+        // Accumulate list items under the current key
+        if list_key.is_some() {
+            if let Some(item) = line.strip_prefix("  - ") {
+                list_items.push(parse_scalar(item.trim()));
+                continue;
+            }
+            flush_list(&mut map, &mut list_key, &mut list_items);
+        }
+
+        let Some(key) = extract_yaml_key(line) else {
+            continue;
+        };
+        let value_part = line.split_once(':').map(|(_, v)| v.trim()).unwrap_or("");
+        if value_part.is_empty() {
+            list_key = Some(key.to_string());
+        } else {
+            map.insert(key.to_string(), parse_scalar(value_part));
+        }
+    }
+    flush_list(&mut map, &mut list_key, &mut list_items);
+    map
+}
+
+/// Extract the raw YAML frontmatter string from between `---` delimiters.
+fn extract_raw_frontmatter(content: &str) -> Option<&str> {
+    let rest = content.strip_prefix("---")?;
+    let rest = rest
+        .strip_prefix('\n')
+        .or_else(|| rest.strip_prefix("\r\n"))?;
+    let end = rest.find("\n---")?;
+    Some(&rest[..end])
+}
+
 /// Extract frontmatter, relationships, and custom properties from parsed gray_matter data.
+/// When gray_matter fails to parse YAML (e.g. malformed quotes from Notion exports),
+/// `raw_content` is used as a fallback: simple key:value pairs are extracted line-by-line
+/// so that critical fields like Trashed, Archived, type are not silently lost.
 pub(crate) fn extract_fm_and_rels(
     data: Option<gray_matter::Pod>,
+    raw_content: &str,
 ) -> (
     Frontmatter,
     HashMap<String, Vec<String>>,
     HashMap<String, serde_json::Value>,
 ) {
-    let hash = match data {
-        Some(gray_matter::Pod::Hash(map)) => map,
-        _ => return (Frontmatter::default(), HashMap::new(), HashMap::new()),
+    let json_map = match data {
+        Some(gray_matter::Pod::Hash(map)) => {
+            map.into_iter().map(|(k, v)| (k, pod_to_json(v))).collect()
+        }
+        _ => {
+            // gray_matter returned Null, String, or None — YAML parse failed.
+            // Fall back to line-by-line extraction from the raw frontmatter block.
+            match extract_raw_frontmatter(raw_content) {
+                Some(raw) => fallback_parse_yaml_string(raw),
+                None => return (Frontmatter::default(), HashMap::new(), HashMap::new()),
+            }
+        }
     };
-    let json_map: HashMap<String, serde_json::Value> =
-        hash.into_iter().map(|(k, v)| (k, pod_to_json(v))).collect();
     (
         parse_frontmatter(&json_map),
         extract_relationships(&json_map),

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/migration.rs

@@ -1,6 +1,3 @@
-use regex::Regex;
-use serde::Serialize;
-use std::collections::HashSet;
 use std::fs;
 use std::path::Path;
 use walkdir::WalkDir;
@@ -118,311 +115,6 @@ pub fn migrate_is_a_to_type(vault_path: &str) -> Result<usize, String> {
     Ok(migrated)
 }
 
-/// Folders that are NOT flattened — they contain assets, not notes.
-const KEEP_FOLDERS: &[&str] = &["attachments", "assets"];
-
-/// Determine a unique filename at `dest_dir`, appending -2, -3, etc. on collision.
-fn unique_filename(dest_dir: &Path, filename: &str, taken: &HashSet<String>) -> String {
-    if !dest_dir.join(filename).exists() && !taken.contains(filename) {
-        return filename.to_string();
-    }
-    let stem = Path::new(filename)
-        .file_stem()
-        .map(|s| s.to_string_lossy().to_string())
-        .unwrap_or_default();
-    let ext = Path::new(filename)
-        .extension()
-        .map(|s| format!(".{}", s.to_string_lossy()))
-        .unwrap_or_default();
-    let mut counter = 2;
-    loop {
-        let candidate = format!("{}-{}{}", stem, counter, ext);
-        if !dest_dir.join(&candidate).exists() && !taken.contains(&candidate) {
-            return candidate;
-        }
-        counter += 1;
-    }
-}
-
-/// Flatten vault structure: move all notes from type-based subfolders to the vault root.
-/// Skips `type/`, `config/`, `attachments/`, and `_themes/` folders.
-/// Updates path-based wikilinks to title-based after moving.
-/// Returns the number of files moved.
-pub fn flatten_vault(vault_path: &str) -> Result<usize, String> {
-    let vault = Path::new(vault_path);
-    if !vault.exists() || !vault.is_dir() {
-        return Err(format!(
-            "Vault path does not exist or is not a directory: {}",
-            vault_path
-        ));
-    }
-
-    // Collect all .md files in subfolders (not already at root, not in KEEP_FOLDERS)
-    let mut to_move: Vec<(std::path::PathBuf, String)> = Vec::new();
-    for entry in WalkDir::new(vault)
-        .follow_links(true)
-        .into_iter()
-        .filter_map(|e| e.ok())
-    {
-        let path = entry.path();
-        if !path.is_file() || path.extension().map(|ext| ext != "md").unwrap_or(true) {
-            continue;
-        }
-        // Skip files already at vault root
-        if path.parent() == Some(vault) {
-            continue;
-        }
-        // Check if this file is inside a KEEP_FOLDER
-        let rel = path.strip_prefix(vault).unwrap_or(path);
-        let top_folder = rel
-            .components()
-            .next()
-            .map(|c| c.as_os_str().to_string_lossy().to_string())
-            .unwrap_or_default();
-        if KEEP_FOLDERS.iter().any(|&k| k == top_folder) {
-            continue;
-        }
-        // Hidden folders (e.g. .laputa, .git)
-        if top_folder.starts_with('.') {
-            continue;
-        }
-
-        let filename = path
-            .file_name()
-            .map(|f| f.to_string_lossy().to_string())
-            .unwrap_or_default();
-        to_move.push((path.to_path_buf(), filename));
-    }
-
-    if to_move.is_empty() {
-        return Ok(0);
-    }
-
-    // Build a map of old path → (new filename, old relative stem) for wikilink updates
-    let mut taken: HashSet<String> = HashSet::new();
-    // Pre-populate with files already at root
-    if let Ok(entries) = fs::read_dir(vault) {
-        for e in entries.flatten() {
-            if e.path().is_file() {
-                if let Some(name) = e.file_name().to_str() {
-                    taken.insert(name.to_string());
-                }
-            }
-        }
-    }
-
-    let vault_prefix = format!("{}/", vault.to_string_lossy());
-    let mut moves: Vec<(std::path::PathBuf, std::path::PathBuf, String)> = Vec::new(); // (old, new, old_rel_stem)
-    for (old_path, filename) in &to_move {
-        let new_name = unique_filename(vault, filename, &taken);
-        taken.insert(new_name.clone());
-        let new_path = vault.join(&new_name);
-        let old_rel = old_path
-            .to_string_lossy()
-            .strip_prefix(&vault_prefix)
-            .unwrap_or(&old_path.to_string_lossy())
-            .strip_suffix(".md")
-            .unwrap_or(&old_path.to_string_lossy())
-            .to_string();
-        moves.push((old_path.clone(), new_path, old_rel));
-    }
-
-    // Move all files
-    let mut moved = 0;
-    for (old, new, _) in &moves {
-        match fs::rename(old, new) {
-            Ok(()) => moved += 1,
-            Err(e) => log::warn!(
-                "Failed to move {} → {}: {}",
-                old.display(),
-                new.display(),
-                e
-            ),
-        }
-    }
-
-    // Update path-based wikilinks across the vault.
-    // Replace [[folder/slug]] with [[slug]] (title-based).
-    // Build a single regex matching any old path stem.
-    let path_stems: Vec<&str> = moves.iter().map(|(_, _, stem)| stem.as_str()).collect();
-    if !path_stems.is_empty() {
-        let escaped: Vec<String> = path_stems.iter().map(|s| regex::escape(s)).collect();
-        let pattern_str = format!(r"\[\[({})\]\]", escaped.join("|"));
-        if let Ok(re) = Regex::new(&pattern_str) {
-            // Collect all .md files in vault (now at root + keep folders)
-            let all_md: Vec<std::path::PathBuf> = WalkDir::new(vault)
-                .follow_links(true)
-                .into_iter()
-                .filter_map(|e| e.ok())
-                .filter(|e| {
-                    e.path().is_file() && e.path().extension().is_some_and(|ext| ext == "md")
-                })
-                .map(|e| e.into_path())
-                .collect();
-
-            for md_path in &all_md {
-                let content = match fs::read_to_string(md_path) {
-                    Ok(c) => c,
-                    Err(_) => continue,
-                };
-                if !re.is_match(&content) {
-                    continue;
-                }
-                let replaced = re.replace_all(&content, |caps: &regex::Captures| {
-                    let matched = caps.get(1).map(|m| m.as_str()).unwrap_or("");
-                    // Extract just the filename stem (last segment)
-                    let slug = matched.rsplit('/').next().unwrap_or(matched);
-                    format!("[[{}]]", slug)
-                });
-                if replaced != content {
-                    let _ = fs::write(md_path, replaced.as_ref());
-                }
-            }
-        }
-    }
-
-    // Clean up empty directories (only type-folder directories, not KEEP_FOLDERS)
-    for (old, _, _) in &moves {
-        if let Some(parent) = old.parent() {
-            if parent != vault {
-                let _ = fs::remove_dir(parent); // only succeeds if empty
-            }
-        }
-    }
-
-    Ok(moved)
-}
-
-/// Result of a vault health check.
-#[derive(Debug, Serialize, Default)]
-pub struct VaultHealthReport {
-    /// Files in non-protected subfolders (won't be scanned by scan_vault).
-    pub stray_files: Vec<String>,
-    /// Files whose filename doesn't match slugify(title).
-    pub title_mismatches: Vec<TitleMismatch>,
-}
-
-/// A single filename-title mismatch.
-#[derive(Debug, Serialize)]
-pub struct TitleMismatch {
-    pub path: String,
-    pub filename: String,
-    pub title: String,
-    pub expected_filename: String,
-}
-
-/// Slugify a title to produce the expected filename stem.
-fn slugify(text: &str) -> String {
-    let result: String = text
-        .to_lowercase()
-        .chars()
-        .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
-        .collect();
-    let trimmed = result.trim_matches('-').to_string();
-    // Collapse consecutive dashes
-    let mut prev_dash = false;
-    let collapsed: String = trimmed
-        .chars()
-        .filter(|&c| {
-            if c == '-' {
-                if prev_dash {
-                    return false;
-                }
-                prev_dash = true;
-            } else {
-                prev_dash = false;
-            }
-            true
-        })
-        .collect();
-    if collapsed.is_empty() {
-        "untitled".to_string()
-    } else {
-        collapsed
-    }
-}
-
-/// Check vault health: detect stray files and filename-title mismatches.
-pub fn vault_health_check(vault_path: &str) -> Result<VaultHealthReport, String> {
-    let vault = Path::new(vault_path);
-    if !vault.exists() || !vault.is_dir() {
-        return Err(format!(
-            "Vault path does not exist or is not a directory: {}",
-            vault_path
-        ));
-    }
-
-    let mut report = VaultHealthReport::default();
-
-    // 1. Detect stray files in non-protected subfolders
-    for entry in WalkDir::new(vault)
-        .follow_links(true)
-        .into_iter()
-        .filter_map(|e| e.ok())
-    {
-        let path = entry.path();
-        if !path.is_file() || path.extension().map(|ext| ext != "md").unwrap_or(true) {
-            continue;
-        }
-        // Skip root files (they're fine)
-        if path.parent() == Some(vault) {
-            continue;
-        }
-        let rel = path.strip_prefix(vault).unwrap_or(path);
-        let top_folder = rel
-            .components()
-            .next()
-            .map(|c| c.as_os_str().to_string_lossy().to_string())
-            .unwrap_or_default();
-        if KEEP_FOLDERS.iter().any(|&k| k == top_folder) || top_folder.starts_with('.') {
-            continue;
-        }
-        report.stray_files.push(rel.to_string_lossy().to_string());
-    }
-
-    // 2. Detect filename-title mismatches (root .md files only)
-    if let Ok(dir_entries) = fs::read_dir(vault) {
-        let matter = gray_matter::Matter::<gray_matter::engine::YAML>::new();
-        for dir_entry in dir_entries.flatten() {
-            let path = dir_entry.path();
-            if !path.is_file() || path.extension().map(|ext| ext != "md").unwrap_or(true) {
-                continue;
-            }
-            let filename = path
-                .file_name()
-                .map(|f| f.to_string_lossy().to_string())
-                .unwrap_or_default();
-            let content = match fs::read_to_string(&path) {
-                Ok(c) => c,
-                Err(_) => continue,
-            };
-            let parsed = matter.parse(&content);
-            let fm_title = parsed.data.as_ref().and_then(|pod| {
-                if let gray_matter::Pod::Hash(ref map) = pod {
-                    if let Some(gray_matter::Pod::String(s)) = map.get("title") {
-                        return Some(s.as_str());
-                    }
-                }
-                None
-            });
-            let title = super::parsing::extract_title(fm_title, &content, &filename);
-            let expected_stem = slugify(&title);
-            let expected_filename = format!("{}.md", expected_stem);
-            let current_stem = filename.strip_suffix(".md").unwrap_or(&filename);
-            if current_stem != expected_stem {
-                report.title_mismatches.push(TitleMismatch {
-                    path: path.to_string_lossy().to_string(),
-                    filename: filename.clone(),
-                    title,
-                    expected_filename,
-                });
-            }
-        }
-    }
-
-    Ok(report)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -561,226 +253,4 @@ mod tests {
         let count = migrate_is_a_to_type(tmp.path().to_str().unwrap()).unwrap();
         assert_eq!(count, 0, "non-markdown files should be ignored");
     }
-
-    // --- flatten_vault ---
-
-    fn write_nested_file(
-        dir: &std::path::Path,
-        rel_path: &str,
-        content: &str,
-    ) -> std::path::PathBuf {
-        let path = dir.join(rel_path);
-        if let Some(parent) = path.parent() {
-            fs::create_dir_all(parent).unwrap();
-        }
-        fs::write(&path, content).unwrap();
-        path
-    }
-
-    #[test]
-    fn test_flatten_vault_moves_notes_to_root() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_nested_file(vault, "note/hello.md", "---\ntype: Note\n---\n# Hello\n");
-        write_nested_file(
-            vault,
-            "project/my-proj.md",
-            "---\ntype: Project\n---\n# My Proj\n",
-        );
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 2);
-        assert!(vault.join("hello.md").exists());
-        assert!(vault.join("my-proj.md").exists());
-        assert!(!vault.join("note/hello.md").exists());
-        assert!(!vault.join("project/my-proj.md").exists());
-    }
-
-    #[test]
-    fn test_flatten_vault_skips_protected_folders() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_nested_file(vault, "attachments/image.md", "# Image note\n");
-        write_nested_file(vault, "note/hello.md", "---\ntype: Note\n---\n# Hello\n");
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 1);
-        assert!(vault.join("hello.md").exists());
-        assert!(vault.join("attachments/image.md").exists());
-    }
-
-    #[test]
-    fn test_flatten_vault_handles_filename_collision() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "hello.md", "---\ntype: Note\n---\n# Root Hello\n");
-        write_nested_file(
-            vault,
-            "note/hello.md",
-            "---\ntype: Note\n---\n# Note Hello\n",
-        );
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 1);
-        assert!(vault.join("hello.md").exists());
-        assert!(vault.join("hello-2.md").exists());
-        // Root file unchanged
-        let root_content = fs::read_to_string(vault.join("hello.md")).unwrap();
-        assert!(root_content.contains("Root Hello"));
-        // Moved file gets suffixed name
-        let moved_content = fs::read_to_string(vault.join("hello-2.md")).unwrap();
-        assert!(moved_content.contains("Note Hello"));
-    }
-
-    #[test]
-    fn test_flatten_vault_updates_path_wikilinks() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_nested_file(
-            vault,
-            "note/hello.md",
-            "---\ntype: Note\n---\n# Hello\n\nSee [[project/my-proj]] for details.\n",
-        );
-        write_nested_file(
-            vault,
-            "project/my-proj.md",
-            "---\ntype: Project\n---\n# My Proj\n",
-        );
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 2);
-        let content = fs::read_to_string(vault.join("hello.md")).unwrap();
-        assert!(content.contains("[[my-proj]]"));
-        assert!(!content.contains("[[project/my-proj]]"));
-    }
-
-    #[test]
-    fn test_flatten_vault_noop_when_already_flat() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "hello.md", "---\ntype: Note\n---\n# Hello\n");
-        write_file(vault, "world.md", "---\ntype: Note\n---\n# World\n");
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 0);
-    }
-
-    #[test]
-    fn test_flatten_vault_nested_subfolders() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_nested_file(vault, "note/sub/deep.md", "---\ntype: Note\n---\n# Deep\n");
-
-        let count = flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert_eq!(count, 1);
-        assert!(vault.join("deep.md").exists());
-    }
-
-    #[test]
-    fn test_flatten_vault_cleans_empty_directories() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_nested_file(vault, "note/hello.md", "---\ntype: Note\n---\n# Hello\n");
-
-        flatten_vault(vault.to_str().unwrap()).unwrap();
-        assert!(
-            !vault.join("note").exists(),
-            "empty folder should be removed"
-        );
-    }
-
-    // --- slugify ---
-
-    #[test]
-    fn test_slugify_basic() {
-        assert_eq!(slugify("Hello World"), "hello-world");
-    }
-
-    #[test]
-    fn test_slugify_special_chars() {
-        assert_eq!(slugify("My Note (v2)!"), "my-note-v2");
-        assert_eq!(slugify("Sprint Retrospective"), "sprint-retrospective");
-    }
-
-    #[test]
-    fn test_slugify_empty() {
-        assert_eq!(slugify(""), "untitled");
-    }
-
-    #[test]
-    fn test_slugify_unicode() {
-        assert_eq!(slugify("Café Résumé"), "caf-r-sum");
-    }
-
-    // --- vault_health_check ---
-
-    #[test]
-    fn test_health_check_detects_stray_files() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "root-note.md", "---\ntype: Note\n---\n# Root Note\n");
-        write_file(vault, "project.md", "---\ntype: Type\n---\n# Project\n");
-        write_nested_file(
-            vault,
-            "old-folder/stray.md",
-            "---\ntype: Note\n---\n# Stray\n",
-        );
-
-        let report = vault_health_check(vault.to_str().unwrap()).unwrap();
-        assert_eq!(report.stray_files.len(), 1);
-        assert!(report.stray_files[0].contains("stray.md"));
-    }
-
-    #[test]
-    fn test_health_check_no_stray_when_flat() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "my-note.md", "# My Note\n");
-        write_file(vault, "project.md", "---\ntype: Type\n---\n# Project\n");
-
-        let report = vault_health_check(vault.to_str().unwrap()).unwrap();
-        assert!(report.stray_files.is_empty());
-    }
-
-    #[test]
-    fn test_health_check_detects_title_mismatch() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        // Filename is "wrong-name.md" but title frontmatter says "My Actual Title"
-        write_file(
-            vault,
-            "wrong-name.md",
-            "---\ntitle: My Actual Title\ntype: Note\n---\n# My Actual Title\n",
-        );
-
-        let report = vault_health_check(vault.to_str().unwrap()).unwrap();
-        assert_eq!(report.title_mismatches.len(), 1);
-        assert_eq!(report.title_mismatches[0].filename, "wrong-name.md");
-        assert_eq!(
-            report.title_mismatches[0].expected_filename,
-            "my-actual-title.md"
-        );
-    }
-
-    #[test]
-    fn test_health_check_no_mismatch_when_correct() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "my-note.md", "---\ntype: Note\n---\n# My Note\n");
-
-        let report = vault_health_check(vault.to_str().unwrap()).unwrap();
-        assert!(report.title_mismatches.is_empty());
-    }
-
-    #[test]
-    fn test_health_check_skips_hidden_folders() {
-        let tmp = tempdir().unwrap();
-        let vault = tmp.path();
-        write_file(vault, "root.md", "# Root\n");
-        write_nested_file(vault, ".git/config.md", "# Git Config\n");
-        write_nested_file(vault, ".laputa/cache.md", "# Cache\n");
-
-        let report = vault_health_check(vault.to_str().unwrap()).unwrap();
-        assert!(report.stray_files.is_empty());
-    }
 }

src-tauri/src/vault/mod.rs

@@ -10,17 +10,24 @@ 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};
-pub use entry::VaultEntry;
+pub use entry::{FolderNode, VaultEntry};
 pub use file::{get_note_content, save_note_content};
 pub use getting_started::{create_getting_started_vault, default_vault_path, vault_exists};
 pub use image::{copy_image_to_vault, save_image};
-pub use migration::{flatten_vault, migrate_is_a_to_type, vault_health_check, VaultHealthReport};
-pub use rename::{rename_note, RenameResult};
+pub use migration::migrate_is_a_to_type;
+pub use rename::{
+    detect_renames, rename_note, update_wikilinks_for_renames, DetectedRename, RenameResult,
+};
 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};
@@ -33,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
@@ -43,13 +54,17 @@ pub fn parse_md_file(path: &Path) -> Result<VaultEntry, String> {
 
     let matter = Matter::<YAML>::new();
     let parsed = matter.parse(&content);
-    let (frontmatter, mut relationships, properties) = extract_fm_and_rels(parsed.data);
+    let (frontmatter, mut relationships, properties) = extract_fm_and_rels(parsed.data, &content);
 
     let title = extract_title(frontmatter.title.as_deref(), &content, &filename);
     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.
@@ -100,67 +115,249 @@ 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)
+    }
 }
 
-/// Folders that are scanned recursively (attachments, assets).
-/// All other subfolders are ignored — notes and type definitions live flat at the vault root.
-const PROTECTED_FOLDERS: &[&str] = &["attachments", "assets"];
+/// Directories that are never shown in the folder tree or scanned for notes.
+const HIDDEN_DIRS: &[&str] = &[".git", ".laputa", ".DS_Store"];
 
-fn is_md_file(path: &Path) -> bool {
+fn is_hidden_dir(name: &str) -> bool {
+    name.starts_with('.') || HIDDEN_DIRS.contains(&name)
+}
+
+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),
     }
 }
 
-fn scan_root_md_files(vault_path: &Path, entries: &mut Vec<VaultEntry>) {
-    let dir_entries = match fs::read_dir(vault_path) {
-        Ok(d) => d,
-        Err(_) => return,
-    };
-    for dir_entry in dir_entries.flatten() {
-        let path = dir_entry.path();
-        if is_md_file(&path) {
-            try_parse_md(&path, entries);
+/// Scan all files in the vault, including subdirectories.
+/// Hidden directories (starting with `.`) are excluded.
+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()
+        .filter_entry(|e| {
+            if e.file_type().is_dir() {
+                let name = e.file_name().to_string_lossy();
+                // Skip the vault root itself (depth 0) — we only filter subdirs
+                if e.depth() == 0 {
+                    return true;
+                }
+                return !is_hidden_dir(&name);
+            }
+            true
+        });
+    for entry in walker.filter_map(|e| e.ok()) {
+        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);
         }
     }
 }
 
-fn scan_protected_folders(vault_path: &Path, entries: &mut Vec<VaultEntry>) {
-    for folder in PROTECTED_FOLDERS {
-        let folder_path = vault_path.join(folder);
-        if !folder_path.is_dir() {
-            continue;
-        }
-        let md_files = WalkDir::new(&folder_path)
-            .follow_links(true)
-            .into_iter()
-            .filter_map(|e| e.ok())
-            .filter(|e| is_md_file(e.path()));
-        for entry in md_files {
-            try_parse_md(entry.path(), 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: {}",
@@ -175,13 +372,51 @@ pub fn scan_vault(vault_path: &Path) -> Result<Vec<VaultEntry>, String> {
     }
 
     let mut entries = Vec::new();
-    scan_root_md_files(vault_path, &mut entries);
-    scan_protected_folders(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)
 }
 
+/// Build a tree of visible folders in the vault.
+/// Excludes hidden directories (starting with `.`).
+pub fn scan_vault_folders(vault_path: &Path) -> Result<Vec<FolderNode>, String> {
+    if !vault_path.is_dir() {
+        return Err(format!("Not a directory: {}", vault_path.display()));
+    }
+    fn build_tree(dir: &Path, vault_root: &Path) -> Vec<FolderNode> {
+        let mut nodes: Vec<FolderNode> = Vec::new();
+        let entries = match fs::read_dir(dir) {
+            Ok(d) => d,
+            Err(_) => return nodes,
+        };
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+            let name = entry.file_name().to_string_lossy().to_string();
+            if is_hidden_dir(&name) {
+                continue;
+            }
+            let rel_path = path
+                .strip_prefix(vault_root)
+                .unwrap_or(&path)
+                .to_string_lossy()
+                .replace('\\', "/");
+            let children = build_tree(&path, vault_root);
+            nodes.push(FolderNode {
+                name,
+                path: rel_path,
+                children,
+            });
+        }
+        nodes.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        nodes
+    }
+    Ok(build_tree(vault_path, vault_path))
+}
+
 #[cfg(test)]
 #[path = "mod_tests.rs"]
 mod tests;

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,19 +133,31 @@ 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]
-fn test_scan_vault_skips_non_protected_subfolders() {
+fn test_scan_vault_includes_subdirectory_notes() {
     let dir = TempDir::new().unwrap();
     create_test_file(dir.path(), "root.md", "# Root Note\n");
     create_test_file(
@@ -159,9 +171,16 @@ fn test_scan_vault_skips_non_protected_subfolders() {
         "---\ntype: Project\n---\n# Old\n",
     );
 
-    let entries = scan_vault(dir.path()).unwrap();
-    assert_eq!(entries.len(), 1, "only root .md files should be scanned");
-    assert_eq!(entries[0].filename, "root.md");
+    let entries = scan_vault(dir.path(), &HashMap::new()).unwrap();
+    assert_eq!(
+        entries.len(),
+        3,
+        "all .md files including subdirs should be scanned"
+    );
+    let filenames: Vec<&str> = entries.iter().map(|e| e.filename.as_str()).collect();
+    assert!(filenames.contains(&"root.md"));
+    assert!(filenames.contains(&"nested.md"));
+    assert!(filenames.contains(&"old-project.md"));
 }
 
 #[test]
@@ -171,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);
 }
 
@@ -182,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());
 }
 
@@ -200,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());
 }
@@ -229,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.");
 }
 
@@ -240,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);
 }
 
@@ -250,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);
 }
 
@@ -271,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(),
@@ -303,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());
@@ -335,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!(
@@ -397,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!(
@@ -474,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!(
@@ -538,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
@@ -565,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()));
 }
 
@@ -573,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");
 }
 
@@ -585,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(),
@@ -1070,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]
@@ -1096,6 +1166,142 @@ fn test_parse_visible_missing_defaults_to_none() {
     assert_eq!(entry.visible, None);
 }
 
+// --- Regression: trashed/archived must survive unquoted date in "Trashed at" ---
+
+#[test]
+fn test_trashed_true_with_unquoted_date_in_trashed_at() {
+    let dir = TempDir::new().unwrap();
+    // Reproduces the engineering-management.md scenario: Trashed at has an
+    // unquoted YAML date (2026-03-11) which gray_matter may parse as a non-string.
+    // The entire Frontmatter deserialization must NOT fail because of this.
+    let content = "---\ntype: Topic\nTrashed: true\n\"Trashed at\": 2026-03-11\n---\n# Engineering Management\n";
+    let entry = parse_test_entry(&dir, "engineering-management.md", content);
+    assert!(
+        entry.trashed,
+        "Trashed must be true even when 'Trashed at' contains an unquoted date"
+    );
+}
+
+#[test]
+fn test_archived_true_with_extra_non_string_fields() {
+    let dir = TempDir::new().unwrap();
+    // If any StringOrList field gets a non-string value, archived must still parse.
+    let content = "---\nArchived: true\norder: 5\n---\n# Archived Note\n";
+    let entry = parse_test_entry(&dir, "archived-extra.md", content);
+    assert!(
+        entry.archived,
+        "Archived must be true even with other fields present"
+    );
+}
+
+#[test]
+fn test_trashed_with_reviewed_false_field() {
+    let dir = TempDir::new().unwrap();
+    let content = "---\ntype: Topic\nReviewed: False\nTrashed: true\n---\n# Test\n";
+    let entry = parse_test_entry(&dir, "reviewed-test.md", content);
+    assert!(
+        entry.trashed,
+        "Trashed must be true even when frontmatter contains Reviewed: False"
+    );
+    assert_eq!(entry.is_a, Some("Topic".to_string()));
+}
+
+/// Regression: wikilinks containing curly braces + nested quotes in YAML arrays
+/// cause gray_matter to produce Hash values instead of strings for array elements.
+/// This must NOT make parse_frontmatter fall back to default (losing trashed/archived).
+#[test]
+fn test_trashed_survives_malformed_wikilinks_in_yaml() {
+    let dir = TempDir::new().unwrap();
+    // This YAML has curly braces inside a double-quoted string, producing nested
+    // Hash values in some YAML parsers. The Frontmatter serde must not fail.
+    let content = "---\ntype: Topic\nNotes:\n  - \"[[foo|bar]]\"\n  - \"[[slug|{'Title': 'Subtitle'}]]\"\nTrashed: true\n---\n# Test\n";
+    let entry = parse_test_entry(&dir, "malformed-links.md", content);
+    assert!(
+        entry.trashed,
+        "Trashed must be true even with curly-brace wikilinks in frontmatter arrays"
+    );
+}
+
+/// Regression: files with malformed YAML (e.g. Notion exports with unescaped quotes
+/// in wikilinks) cause gray_matter to return Null instead of a Hash. The fallback
+/// parser must still extract Trashed, type, and other simple key:value fields.
+#[test]
+fn test_parse_real_engineering_management_file() {
+    let path = std::path::Path::new("/Users/luca/Laputa/engineering-management.md");
+    if !path.exists() {
+        return; // Skip when the Laputa vault is not available
+    }
+    let entry = parse_md_file(path, None).unwrap();
+    assert!(
+        entry.trashed,
+        "engineering-management.md must be trashed (has Trashed: true in frontmatter)"
+    );
+    assert_eq!(entry.is_a, Some("Topic".to_string()));
+}
+
+#[test]
+fn test_fallback_parser_extracts_trashed_from_malformed_yaml() {
+    let dir = TempDir::new().unwrap();
+    // Simulate malformed YAML that gray_matter can't parse: unescaped double
+    // quotes inside a double-quoted YAML string cause the YAML parser to fail.
+    // The fallback line-by-line parser must still extract simple key:value pairs.
+    //
+    // Write the file manually with literal unescaped quotes (can't use Rust string
+    // escaping for this since the YAML itself is the malformed part).
+    let fm = [
+        "---",
+        "type: Topic",
+        "Status: Draft",
+        "Belongs to:",
+        "  - \"[[engineering|Engineering]]\"",
+        "aliases:",
+        "  - Engineering Management",
+        "Notes:",
+        // This line has unescaped " inside a "-quoted YAML string — malformed YAML
+        "  - \"[[slug|{\"Title\": 'Subtitle'}]]\"",
+        "Trashed: true",
+        "\"Trashed at\": 2026-03-11",
+        "---",
+        "",
+        "# Engineering Management",
+    ];
+    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"), None).unwrap();
+    assert!(
+        entry.trashed,
+        "Trashed must be true even when YAML is malformed (fallback parser)"
+    );
+    assert_eq!(
+        entry.is_a,
+        Some("Topic".to_string()),
+        "isA must be extracted by fallback parser"
+    );
+}
+
+#[test]
+fn test_fallback_parser_extracts_archived_from_malformed_yaml() {
+    let dir = TempDir::new().unwrap();
+    let fm = [
+        "---",
+        "type: Essay",
+        "Notes:",
+        "  - \"[[slug|{\"Broken\": 'quotes'}]]\"",
+        "Archived: true",
+        "---",
+        "",
+        "# Archived Essay",
+    ];
+    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"), None).unwrap();
+    assert!(
+        entry.archived,
+        "Archived must be true even when YAML is malformed"
+    );
+    assert_eq!(entry.is_a, Some("Essay".to_string()));
+}
+
 #[test]
 fn test_visible_not_in_relationships() {
     let dir = TempDir::new().unwrap();
@@ -1211,6 +1417,46 @@ fn test_array_field_does_not_break_type_detection() {
     assert_eq!(entry.status, Some("Active".to_string()));
 }
 
+// ── Folder tree tests ──────────────────────────────────────────────────────
+
+#[test]
+fn test_scan_vault_folders_returns_tree() {
+    let dir = TempDir::new().unwrap();
+    fs::create_dir_all(dir.path().join("projects/laputa")).unwrap();
+    fs::create_dir_all(dir.path().join("areas")).unwrap();
+
+    let folders = scan_vault_folders(dir.path()).unwrap();
+    let names: Vec<&str> = folders.iter().map(|f| f.name.as_str()).collect();
+    assert!(names.contains(&"projects"));
+    assert!(names.contains(&"areas"));
+
+    let projects = folders.iter().find(|f| f.name == "projects").unwrap();
+    assert_eq!(projects.children.len(), 1);
+    assert_eq!(projects.children[0].name, "laputa");
+    assert_eq!(projects.children[0].path, "projects/laputa");
+}
+
+#[test]
+fn test_scan_vault_folders_excludes_hidden() {
+    let dir = TempDir::new().unwrap();
+    fs::create_dir_all(dir.path().join(".git")).unwrap();
+    fs::create_dir_all(dir.path().join(".laputa")).unwrap();
+    fs::create_dir_all(dir.path().join("visible")).unwrap();
+
+    let folders = scan_vault_folders(dir.path()).unwrap();
+    assert_eq!(folders.len(), 1);
+    assert_eq!(folders[0].name, "visible");
+}
+
+#[test]
+fn test_scan_vault_folders_flat_vault() {
+    let dir = TempDir::new().unwrap();
+    create_test_file(dir.path(), "note.md", "# Note\n");
+
+    let folders = scan_vault_folders(dir.path()).unwrap();
+    assert!(folders.is_empty(), "flat vault has no visible folders");
+}
+
 // Frontmatter update/delete tests are in frontmatter.rs
 // save_image tests are in vault/image.rs
 // purge_trash tests are in vault/trash.rs

src-tauri/src/vault/rename.rs

@@ -144,9 +144,10 @@ fn to_path_stem<'a>(abs_path: &'a str, vault_prefix: &str) -> &'a str {
 }
 
 /// Determine a unique destination path, appending -2, -3, etc. if a file already exists.
-fn unique_dest_path(dest_dir: &Path, filename: &str) -> std::path::PathBuf {
+/// `exclude` is the source file being renamed — it should not be treated as a collision.
+fn unique_dest_path(dest_dir: &Path, filename: &str, exclude: &Path) -> std::path::PathBuf {
     let dest = dest_dir.join(filename);
-    if !dest.exists() {
+    if !dest.exists() || dest == exclude {
         return dest;
     }
     let stem = Path::new(filename)
@@ -160,7 +161,7 @@ fn unique_dest_path(dest_dir: &Path, filename: &str) -> std::path::PathBuf {
     let mut counter = 2;
     loop {
         let candidate = dest_dir.join(format!("{}-{}{}", stem, counter, ext));
-        if !candidate.exists() {
+        if !candidate.exists() || candidate == exclude {
             return candidate;
         }
         counter += 1;
@@ -223,7 +224,7 @@ pub fn rename_note(
     let parent_dir = old_file
         .parent()
         .ok_or("Cannot determine parent directory")?;
-    let new_file = unique_dest_path(parent_dir, &expected_filename);
+    let new_file = unique_dest_path(parent_dir, &expected_filename, old_file);
     let new_path_str = new_file.to_string_lossy().to_string();
 
     fs::write(&new_file, &updated_content)
@@ -250,6 +251,89 @@ pub fn rename_note(
     })
 }
 
+/// A detected rename: old path → new path (both relative to vault root).
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct DetectedRename {
+    pub old_path: String,
+    pub new_path: String,
+}
+
+/// Detect renamed files by comparing working tree against HEAD using git diff.
+pub fn detect_renames(vault_path: &str) -> Result<Vec<DetectedRename>, String> {
+    let vault = Path::new(vault_path);
+    let output = std::process::Command::new("git")
+        .args(["diff", "HEAD", "--name-status", "--diff-filter=R", "-M"])
+        .current_dir(vault)
+        .output()
+        .map_err(|e| format!("Failed to run git diff: {e}"))?;
+
+    if !output.status.success() {
+        return Ok(vec![]); // No HEAD yet or other git issue — no renames
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let renames: Vec<DetectedRename> = stdout
+        .lines()
+        .filter_map(|line| {
+            let parts: Vec<&str> = line.split('\t').collect();
+            if parts.len() >= 3 && parts[0].starts_with('R') {
+                let old = parts[1].to_string();
+                let new = parts[2].to_string();
+                if old.ends_with(".md") && new.ends_with(".md") {
+                    return Some(DetectedRename {
+                        old_path: old,
+                        new_path: new,
+                    });
+                }
+            }
+            None
+        })
+        .collect();
+
+    Ok(renames)
+}
+
+/// Update wikilinks across the vault for a list of detected renames.
+/// Returns the total number of files updated.
+pub fn update_wikilinks_for_renames(
+    vault_path: &str,
+    renames: &[DetectedRename],
+) -> Result<usize, String> {
+    let vault = Path::new(vault_path);
+    let mut total_updated = 0;
+
+    for rename in renames {
+        let old_stem = rename
+            .old_path
+            .strip_suffix(".md")
+            .unwrap_or(&rename.old_path);
+        let new_stem = rename
+            .new_path
+            .strip_suffix(".md")
+            .unwrap_or(&rename.new_path);
+        let old_filename_stem = old_stem.split('/').next_back().unwrap_or(old_stem);
+        let new_filename_stem = new_stem.split('/').next_back().unwrap_or(new_stem);
+
+        // Build title from filename stem (kebab-case → Title Case)
+        let old_title = super::parsing::slug_to_title(old_filename_stem);
+        let new_title = super::parsing::slug_to_title(new_filename_stem);
+
+        // The new file is the exclude target (don't rewrite wikilinks inside the renamed file itself)
+        let new_file = vault.join(&rename.new_path);
+
+        let updated = update_wikilinks_in_vault(&WikilinkReplacement {
+            vault_path: vault,
+            old_title: &old_title,
+            new_title: &new_title,
+            old_path_stem: old_filename_stem,
+            exclude_path: &new_file,
+        });
+        total_updated += updated;
+    }
+
+    Ok(total_updated)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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,743 @@
+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,
+}
+
+/// Migrate views from `.laputa/views/` to `views/` in the vault root (one-time).
+pub fn migrate_views(vault_path: &Path) {
+    let old_dir = vault_path.join(".laputa").join("views");
+    if !old_dir.is_dir() {
+        return;
+    }
+
+    let entries = match fs::read_dir(&old_dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+
+    let yml_files: Vec<_> = entries
+        .flatten()
+        .filter(|e| e.path().extension().and_then(|ext| ext.to_str()) == Some("yml"))
+        .collect();
+
+    if yml_files.is_empty() {
+        return;
+    }
+
+    let new_dir = vault_path.join("views");
+    if fs::create_dir_all(&new_dir).is_err() {
+        log::warn!("Failed to create views/ directory for migration");
+        return;
+    }
+
+    for entry in yml_files {
+        let src = entry.path();
+        let dst = new_dir.join(entry.file_name());
+        if !dst.exists() {
+            if let Err(e) = fs::rename(&src, &dst) {
+                log::warn!("Failed to migrate view {:?}: {}", src, e);
+            } else {
+                log::info!("Migrated view {:?} → {:?}", src, dst);
+            }
+        }
+    }
+
+    // Clean up old directory if empty
+    if fs::read_dir(&old_dir)
+        .map(|mut d| d.next().is_none())
+        .unwrap_or(false)
+    {
+        let _ = fs::remove_dir(&old_dir);
+    }
+}
+
+/// Scan all `.yml` files from `vault_path/views/` and return parsed views.
+pub fn scan_views(vault_path: &Path) -> Vec<ViewFile> {
+    migrate_views(vault_path);
+    let views_dir = vault_path.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/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("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/views/{filename}`.
+pub fn delete_view(vault_path: &Path, filename: &str) -> Result<(), String> {
+    let path = vault_path.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("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_migrate_views_from_old_location() {
+        let dir = tempfile::TempDir::new().unwrap();
+        let old_dir = dir.path().join(".laputa").join("views");
+        fs::create_dir_all(&old_dir).unwrap();
+
+        let yaml = "name: Migrated\nfilters:\n  all:\n    - field: type\n      op: equals\n      value: Note\n";
+        fs::write(old_dir.join("test.yml"), yaml).unwrap();
+
+        // scan_views should trigger migration and find the view
+        let views = scan_views(dir.path());
+        assert_eq!(views.len(), 1);
+        assert_eq!(views[0].definition.name, "Migrated");
+
+        // File should now be in new location
+        assert!(dir.path().join("views").join("test.yml").exists());
+        // Old file should be gone
+        assert!(!old_dir.join("test.yml").exists());
+    }
+
+    #[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-tauri/tauri.conf.json

@@ -16,11 +16,14 @@
         "title": "Laputa",
         "width": 1400,
         "height": 900,
+        "minWidth": 1200,
+        "minHeight": 400,
         "resizable": true,
         "fullscreen": false,
         "titleBarStyle": "Overlay",
         "hiddenTitle": true,
-        "backgroundColor": "#F7F6F3"
+        "backgroundColor": "#F7F6F3",
+        "dragDropEnabled": false
       }
     ],
     "security": {

src/App.css

@@ -2,8 +2,8 @@
 .app-shell {
   display: flex;
   flex-direction: column;
-  height: 100vh;
-  width: 100vw;
+  height: 100%;
+  width: 100%;
   overflow: hidden;
   box-shadow: inset 0 0 0 1px var(--border-primary);
 }
@@ -16,7 +16,8 @@
 }
 
 .app__sidebar {
-  flex-shrink: 0;
+  flex-shrink: 1;
+  min-width: 180px;
   display: flex;
   flex-direction: column;
 }
@@ -26,7 +27,8 @@
 }
 
 .app__note-list {
-  flex-shrink: 0;
+  flex-shrink: 10;
+  min-width: 220px;
   display: flex;
   flex-direction: column;
 }
@@ -37,11 +39,13 @@
 
 .app__editor {
   flex: 1;
-  min-width: 0;
+  min-width: 400px;
   min-height: 0;
   overflow: hidden;
   display: flex;
   flex-direction: column;
+  container-type: inline-size;
+  container-name: editor;
 }
 
 .app__editor > * {

src/App.test.tsx

@@ -63,11 +63,13 @@ 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'] || '',
   get_file_history: [],
-  get_settings: { anthropic_key: null, openai_key: null, google_key: null, github_token: null, github_username: null, auto_pull_interval_minutes: null, telemetry_consent: true, crash_reporting_enabled: null, analytics_enabled: null, anonymous_id: null, update_channel: null },
+  get_settings: { openai_key: null, google_key: null, github_token: null, github_username: null, auto_pull_interval_minutes: null, telemetry_consent: true, crash_reporting_enabled: null, analytics_enabled: null, anonymous_id: null, update_channel: null },
   git_pull: { status: 'up_to_date', message: 'Already up to date', updatedFiles: [], conflictFiles: [] },
   save_settings: null,
   check_vault_exists: true,

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'
@@ -20,12 +21,12 @@ import { useMcpStatus } from './hooks/useMcpStatus'
 import { useVaultLoader } from './hooks/useVaultLoader'
 import { useSettings } from './hooks/useSettings'
 import { useNoteActions } from './hooks/useNoteActions'
-import { needsRenameOnSave } from './hooks/useNoteRename'
 import { useCommitFlow } from './hooks/useCommitFlow'
 import { useViewMode } from './hooks/useViewMode'
 import { useEntryActions } from './hooks/useEntryActions'
 import { useAppCommands } from './hooks/useAppCommands'
 import { isEmoji } from './utils/emoji'
+import { generateCommitMessage } from './utils/commitMessage'
 import { useDialogs } from './hooks/useDialogs'
 import { useVaultSwitcher } from './hooks/useVaultSwitcher'
 import { useGitHistory } from './hooks/useGitHistory'
@@ -36,25 +37,27 @@ import { useZoom } from './hooks/useZoom'
 import { useVaultConfig } from './hooks/useVaultConfig'
 import { useBuildNumber } from './hooks/useBuildNumber'
 import { useOnboarding } from './hooks/useOnboarding'
-import { useEditorSaveWithLinks } from './hooks/useEditorSaveWithLinks'
 import { useAppNavigation } from './hooks/useAppNavigation'
 import { useAiActivity } from './hooks/useAiActivity'
 import { useBulkActions } from './hooks/useBulkActions'
 import { useDeleteActions } from './hooks/useDeleteActions'
 import { useLayoutPanels } from './hooks/useLayoutPanels'
+import { useConflictFlow } from './hooks/useConflictFlow'
+import { useAppSave } from './hooks/useAppSave'
+import { useVaultBridge } from './hooks/useVaultBridge'
 import { ConflictResolverModal } from './components/ConflictResolverModal'
 import { ConfirmDeleteDialog } from './components/ConfirmDeleteDialog'
 import { UpdateBanner } from './components/UpdateBanner'
-import { FlatVaultMigrationBanner } from './components/FlatVaultMigrationBanner'
-import { useFlatVaultMigration } from './hooks/useFlatVaultMigration'
 import { invoke } from '@tauri-apps/api/core'
 import { isTauri, mockInvoke } from './mock-tauri'
-import type { SidebarSelection, VaultEntry, InboxPeriod } from './types'
+import type { SidebarSelection, InboxPeriod } from './types'
 import type { NoteListItem } from './utils/ai-context'
 import { filterEntries, filterInboxEntries, type NoteListFilter } from './utils/noteListHelpers'
-import { openLocalFile } from './utils/url'
 import { openNoteInNewWindow } from './utils/openNoteWindow'
-import { flushEditorContent } from './utils/autoSave'
+import { isNoteWindow, getNoteWindowParams } from './utils/windowMode'
+import { GitRequiredModal } from './components/GitRequiredModal'
+import { RenameDetectedBanner, type DetectedRename } from './components/RenameDetectedBanner'
+import { trackEvent } from './lib/telemetry'
 import './App.css'
 
 // Type declarations for mock content storage and test overrides
@@ -70,6 +73,7 @@ const DEFAULT_SELECTION: SidebarSelection = { kind: 'filter', filter: 'all' }
 
 /** Wraps useEditorSave to also keep outgoingLinks in sync on save and on content change. */
 function App() {
+  const noteWindowParams = useMemo(() => isNoteWindow() ? getNoteWindowParams() : null, [])
   const [selection, setSelection] = useState<SidebarSelection>(DEFAULT_SELECTION)
   const [noteListFilter, setNoteListFilter] = useState<NoteListFilter>('open')
   const [inboxPeriod, setInboxPeriod] = useState<InboxPeriod>('month')
@@ -77,7 +81,7 @@ function App() {
     setSelection(sel)
     setNoteListFilter('open')
   }, [])
-  const layout = useLayoutPanels()
+  const layout = useLayoutPanels(noteWindowParams ? { initialInspectorCollapsed: true } : undefined)
   const [toastMessage, setToastMessage] = useState<string | null>(null)
   const dialogs = useDialogs()
 
@@ -92,12 +96,37 @@ function App() {
   const onboarding = useOnboarding(vaultSwitcher.vaultPath)
 
   // When onboarding resolves to a different vault path, update the switcher
-  const resolvedPath = onboarding.state.status === 'ready' ? onboarding.state.vaultPath : vaultSwitcher.vaultPath
+  const resolvedPath = noteWindowParams?.vaultPath ?? (onboarding.state.status === 'ready' ? onboarding.state.vaultPath : vaultSwitcher.vaultPath)
+  // Git repo check: 'checking' | 'required' | 'ready'
+  const [gitRepoState, setGitRepoState] = useState<'checking' | 'required' | 'ready'>('checking')
+  useEffect(() => {
+    if (!resolvedPath) return
+    setGitRepoState('checking')
+    const check = isTauri()
+      ? invoke<boolean>('is_git_repo', { vaultPath: resolvedPath })
+      : Promise.resolve(true) // browser mock: assume git
+    check
+      .then(isGit => setGitRepoState(isGit ? 'ready' : 'required'))
+      .catch(() => setGitRepoState('ready')) // fail open
+  }, [resolvedPath])
+
+  const handleInitGitRepo = useCallback(async () => {
+    if (isTauri()) await invoke('init_git_repo', { vaultPath: resolvedPath })
+    setGitRepoState('ready')
+  }, [resolvedPath])
+
   const vault = useVaultLoader(resolvedPath)
   useVaultConfig(resolvedPath)
   const { settings, loaded: settingsLoaded, saveSettings } = useSettings()
   useTelemetry(settings, settingsLoaded)
-  const flatVaultMigration = useFlatVaultMigration(resolvedPath, vault.entries.length > 0, vault.reloadVault)
+
+  const vaultOpenedRef = useRef('')
+  useEffect(() => {
+    if (vault.entries.length > 0 && gitRepoState !== 'checking' && resolvedPath !== vaultOpenedRef.current) {
+      vaultOpenedRef.current = resolvedPath
+      trackEvent('vault_opened', { has_git: gitRepoState === 'ready' ? 1 : 0, note_count: vault.entries.length })
+    }
+  }, [vault.entries.length, gitRepoState, resolvedPath])
   const { mcpStatus, installMcp } = useMcpStatus(resolvedPath, setToastMessage)
 
   const autoSync = useAutoSync({
@@ -111,8 +140,32 @@ function App() {
     onToast: (msg) => setToastMessage(msg),
   })
 
-  // Ref bridges for conflict resolution callbacks (notes declared below)
-  const openConflictFileRef = useRef<(relativePath: string) => void>(() => {})
+  // Detect external file renames on window focus
+  const [detectedRenames, setDetectedRenames] = useState<DetectedRename[]>([])
+  useEffect(() => {
+    if (!isTauri() || !resolvedPath) return
+    const handleFocus = () => {
+      invoke<DetectedRename[]>('detect_renames', { vaultPath: resolvedPath })
+        .then(renames => { if (renames.length > 0) setDetectedRenames(renames) })
+        .catch(() => {}) // ignore errors (e.g., no git)
+    }
+    window.addEventListener('focus', handleFocus)
+    return () => window.removeEventListener('focus', handleFocus)
+  }, [resolvedPath])
+
+  const handleUpdateWikilinks = useCallback(async () => {
+    if (!isTauri()) return
+    try {
+      const count = await invoke<number>('update_wikilinks_for_renames', { vaultPath: resolvedPath, renames: detectedRenames })
+      setDetectedRenames([])
+      vault.reloadVault()
+      setToastMessage(`Updated wikilinks in ${count} file${count !== 1 ? 's' : ''}`)
+    } catch (err) {
+      setToastMessage(`Failed to update wikilinks: ${err}`)
+    }
+  }, [resolvedPath, detectedRenames, vault, setToastMessage])
+
+  const handleDismissRenames = useCallback(() => setDetectedRenames([]), [])
 
   const conflictResolver = useConflictResolver({
     vaultPath: resolvedPath,
@@ -123,70 +176,32 @@ function App() {
       autoSync.triggerSync()
     },
     onToast: (msg) => setToastMessage(msg),
-    onOpenFile: (relativePath) => openConflictFileRef.current(relativePath),
+    onOpenFile: (relativePath) => conflictFlow.openConflictFileRef.current(relativePath),
   })
 
-  const handleOpenConflictResolver = useCallback(async () => {
-    let files = autoSync.conflictFiles
-    // If no cached conflicts, check directly — there may be pre-existing
-    // conflicts from a prior session that the pull flow didn't detect.
-    if (files.length === 0) {
-      try {
-        files = isTauri()
-          ? await invoke<string[]>('get_conflict_files', { vaultPath: resolvedPath })
-          : await mockInvoke<string[]>('get_conflict_files', { vaultPath: resolvedPath })
-      } catch {
-        return
-      }
-      if (files.length === 0) {
-        setToastMessage('No merge conflicts to resolve')
-        return
-      }
+  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => appSave.contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry })
+
+  // Note window: auto-open the note from URL params once vault entries load
+  const noteWindowOpenedRef = useRef(false)
+  useEffect(() => {
+    if (!noteWindowParams || noteWindowOpenedRef.current || vault.entries.length === 0) return
+    const entry = vault.entries.find(e => e.path === noteWindowParams.notePath)
+    if (entry) {
+      noteWindowOpenedRef.current = true
+      notes.handleSelectNote(entry)
     }
-    autoSync.pausePull()
-    conflictResolver.initFiles(files)
-    dialogs.openConflictResolver()
-  }, [autoSync, conflictResolver, dialogs, resolvedPath])
+  }, [vault.entries]) // eslint-disable-line react-hooks/exhaustive-deps -- run when entries load, params are stable
 
-  const handleCloseConflictResolver = useCallback(() => {
-    autoSync.resumePull()
-    dialogs.closeConflictResolver()
-  }, [autoSync, dialogs])
-
-  /** Resolve a single file conflict from the in-editor banner. */
-  const handleResolveConflictInline = useCallback(async (filePath: string, strategy: 'ours' | 'theirs') => {
-    try {
-      const relativePath = filePath.replace(resolvedPath + '/', '')
-      const call = isTauri() ? invoke : mockInvoke
-      await call('git_resolve_conflict', { vaultPath: resolvedPath, file: relativePath, strategy })
-      // Reload the note content to show the resolved version
-      const content = await (isTauri() ? invoke<string> : mockInvoke<string>)('get_note_content', { path: filePath })
-      // Check remaining conflicts
-      const remaining = await (isTauri() ? invoke<string[]> : mockInvoke<string[]>)('get_conflict_files', { vaultPath: resolvedPath })
-      if (remaining.length === 0) {
-        // All resolved — auto-commit the merge and push
-        await (isTauri() ? invoke : mockInvoke)('git_commit_conflict_resolution', { vaultPath: resolvedPath })
-        vault.reloadVault()
-        autoSync.triggerSync()
-        setToastMessage('All conflicts resolved — merge committed')
-      } else {
-        void content // content reload happens via vault reload
-        vault.reloadVault()
-        setToastMessage(`Resolved — ${remaining.length} conflict${remaining.length > 1 ? 's' : ''} remaining`)
-      }
-    } catch (err) {
-      setToastMessage(`Failed to resolve conflict: ${err}`)
-    }
-  }, [resolvedPath, vault, autoSync, setToastMessage])
-
-  const handleKeepMine = useCallback((path: string) => handleResolveConflictInline(path, 'ours'), [handleResolveConflictInline])
-  const handleKeepTheirs = useCallback((path: string) => handleResolveConflictInline(path, 'theirs'), [handleResolveConflictInline])
-
-  // Ref bridges handleContentChange (created after notes) into useNoteActions.
-  // Read at callback time, so it's always current when user presses Cmd+N.
-  const contentChangeRef = useRef<(path: string, content: string) => void>(() => {})
-
-  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry })
+  // Note window: update window title when active note changes
+  useEffect(() => {
+    if (!noteWindowParams) return
+    const activeEntry = notes.tabs.find(t => t.entry.path === notes.activeTabPath)?.entry
+    const title = activeEntry?.title ?? noteWindowParams.noteTitle
+    if (!isTauri()) { document.title = title; return }
+    import('@tauri-apps/api/window').then(({ getCurrentWindow }) => {
+      getCurrentWindow().setTitle(title)
+    }).catch(() => {})
+  }, [noteWindowParams, notes.tabs, notes.activeTabPath])
 
   // Keep note entry in sync with vault entries so banners (trash/archive)
   // and read-only state react immediately without reopening the note.
@@ -211,56 +226,49 @@ function App() {
     onSelectNote: notes.handleSelectNote,
   })
 
-  // MCP UI bridge: react to AI-driven open/highlight/vault-change events
-  const openNoteByPath = useCallback((path: string) => {
-    const entry = entriesByPath.get(path) ?? entriesByPath.get(`${resolvedPath}/${path}`)
-    if (entry) {
-      notes.handleSelectNote(entry)
-    } else {
-      // Entry not yet in vault (just created) — reload then open
-      vault.reloadVault().then(freshEntries => {
-        const fresh = (freshEntries as VaultEntry[]).find(e => e.path === path || e.path === `${resolvedPath}/${path}`)
-        if (fresh) notes.handleSelectNote(fresh)
-      })
-    }
-  }, [entriesByPath, vault, notes, resolvedPath])
+  const vaultBridge = useVaultBridge({
+    entriesByPath, resolvedPath,
+    reloadVault: vault.reloadVault,
+    onSelectNote: notes.handleSelectNote,
+    activeTabPath: notes.activeTabPath,
+  })
+
+  const conflictFlow = useConflictFlow({
+    resolvedPath, entries: vault.entries,
+    conflictFiles: autoSync.conflictFiles,
+    pausePull: autoSync.pausePull, resumePull: autoSync.resumePull,
+    triggerSync: autoSync.triggerSync, reloadVault: vault.reloadVault,
+    initConflictFiles: conflictResolver.initFiles,
+    openConflictResolver: dialogs.openConflictResolver,
+    closeConflictResolver: dialogs.closeConflictResolver,
+    onSelectNote: notes.handleSelectNote,
+    activeTabPath: notes.activeTabPath,
+    setToastMessage,
+  })
+
+  const appSave = useAppSave({
+    updateEntry: vault.updateEntry, setTabs: notes.setTabs, setToastMessage,
+    loadModifiedFiles: vault.loadModifiedFiles,
+    clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths,
+    tabs: notes.tabs, activeTabPath: notes.activeTabPath,
+    handleRenameNote: notes.handleRenameNote,
+    replaceEntry: vault.replaceEntry, resolvedPath,
+  })
 
   const aiActivity = useAiActivity({
-    onOpenNote: openNoteByPath,
-    onOpenTab: openNoteByPath,
+    onOpenNote: vaultBridge.openNoteByPath,
+    onOpenTab: vaultBridge.openNoteByPath,
     onSetFilter: (filterType) => {
       handleSetSelection({ kind: 'sectionGroup', type: filterType })
     },
     onVaultChanged: () => { vault.reloadVault() },
   })
 
-  // Stable callback for Pulse "open note" — never triggers reloadVault.
-  // Pulse files always exist in the vault; if somehow not found, silently skip.
-  const handlePulseOpenNote = useCallback((relativePath: string) => {
-    const fullPath = `${resolvedPath}/${relativePath}`
-    const entry = entriesByPath.get(fullPath) ?? entriesByPath.get(relativePath)
-    if (entry) notes.handleSelectNote(entry)
-  }, [entriesByPath, resolvedPath, notes])
-
-  // Agent file operation handlers: auto-open created notes, live-refresh modified notes
-  const handleAgentFileCreated = useCallback((relativePath: string) => {
-    vault.reloadVault().then(freshEntries => {
-      const entry = (freshEntries as VaultEntry[]).find(e => e.path === relativePath || e.path === `${resolvedPath}/${relativePath}`)
-      if (entry) notes.handleSelectNote(entry)
-    })
-  }, [vault, notes, resolvedPath])
-
-  const handleAgentFileModified = useCallback((relativePath: string) => {
-    const fullPath = `${resolvedPath}/${relativePath}`
-    const currentPath = notes.activeTabPath
-    if (currentPath === relativePath || currentPath === fullPath) {
-      vault.reloadVault()
-    }
-  }, [vault, notes.activeTabPath, resolvedPath])
-
-  const handleAgentVaultChanged = useCallback(() => {
-    vault.reloadVault()
-  }, [vault])
+  const handleInitializeProperties = useCallback(async (path: string) => {
+    const filename = path.split('/').pop()?.replace(/\.md$/, '') ?? 'Untitled'
+    await notes.handleUpdateFrontmatter(path, 'type', 'Note', { silent: true })
+    await notes.handleUpdateFrontmatter(path, 'title', filename)
+  }, [notes])
 
   const handleSetNoteIcon = useCallback(async (path: string, emoji: string) => {
     await notes.handleUpdateFrontmatter(path, 'icon', emoji)
@@ -270,103 +278,39 @@ function App() {
     await notes.handleDeleteProperty(path, 'icon')
   }, [notes])
 
-  /** Command palette: open the emoji picker on the active note's NoteIcon. */
   const handleSetNoteIconCommand = useCallback(() => {
     window.dispatchEvent(new CustomEvent('laputa:open-icon-picker'))
   }, [])
 
-  /** Command palette: remove the active note's emoji icon. */
+  const handleCreateFolder = useCallback(async (name: string) => {
+    try {
+      if (isTauri()) {
+        await invoke('create_vault_folder', { vaultPath: resolvedPath, folderName: name })
+      } else {
+        await mockInvoke('create_vault_folder', { vaultPath: resolvedPath, folderName: name })
+      }
+      await vault.reloadFolders()
+      setToastMessage(`Created folder "${name}"`)
+    } catch (e) {
+      setToastMessage(`Failed to create folder: ${e}`)
+    }
+  }, [resolvedPath, vault, setToastMessage])
+
   const handleRemoveNoteIconCommand = useCallback(() => {
     if (notes.activeTabPath) handleRemoveNoteIcon(notes.activeTabPath)
   }, [notes.activeTabPath, handleRemoveNoteIcon])
 
-  /** Open the active note in a new window (command palette / keyboard shortcut). */
   const handleOpenInNewWindow = useCallback(() => {
     const activeTab = notes.tabs.find(t => t.entry.path === notes.activeTabPath)
     if (activeTab) openNoteInNewWindow(activeTab.entry.path, resolvedPath, activeTab.entry.title)
-  }, [notes.tabs, notes.activeTabPath, resolvedPath]) // eslint-disable-line react-hooks/exhaustive-deps
+  }, [notes.tabs, notes.activeTabPath, resolvedPath])
 
-  /** Open a specific note entry in a new window (Cmd+Shift+Click). */
-  const handleOpenEntryInNewWindow = useCallback((entry: VaultEntry) => {
+  const handleOpenEntryInNewWindow = useCallback((entry: { path: string; title: string }) => {
     openNoteInNewWindow(entry.path, resolvedPath, entry.title)
   }, [resolvedPath])
 
-  const onAfterSave = useCallback(() => {
-    vault.loadModifiedFiles()
-  }, [vault])
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars -- signature required by useEditorSave
-  const onNotePersisted = useCallback((path: string, _content: string) => {
-    vault.clearUnsaved(path)
-  }, [vault])
-
-  const { handleSave: handleSaveRaw, handleContentChange, savePendingForPath, savePending } = useEditorSaveWithLinks({
-    updateEntry: vault.updateEntry,
-    setTabs: notes.setTabs, setToastMessage, onAfterSave,
-    onNotePersisted,
-  })
-  useEffect(() => { contentChangeRef.current = handleContentChange }, [handleContentChange])
-
-  // Refs for stable closure in flushBeforeAction (avoids re-creating on every tab/content change)
-  const tabsRef = useRef(notes.tabs)
-  tabsRef.current = notes.tabs // eslint-disable-line react-hooks/refs -- ref sync pattern
-  const unsavedPathsRef = useRef(vault.unsavedPaths)
-  unsavedPathsRef.current = vault.unsavedPaths // eslint-disable-line react-hooks/refs -- ref sync pattern
-
-  /** Auto-save unsaved editor content before a destructive action (trash/archive). */
-  const { clearUnsaved: vaultClearUnsaved } = vault
-  const flushBeforeAction = useCallback(async (path: string) => {
-    try {
-      await flushEditorContent(path, {
-        savePendingForPath,
-        getTabContent: (p) => tabsRef.current.find(t => t.entry.path === p)?.content,
-        isUnsaved: (p) => unsavedPathsRef.current.has(p),
-        onSaved: (p) => { vaultClearUnsaved(p) },
-      })
-    } catch (err) {
-      setToastMessage(`Auto-save failed: ${err}`)
-      throw err
-    }
-  }, [savePendingForPath, vaultClearUnsaved, setToastMessage])
-
-  // Wire conflict file opener now that notes is available
-  useEffect(() => {
-    openConflictFileRef.current = (relativePath: string) => {
-      const fullPath = `${resolvedPath}/${relativePath}`
-      const entry = vault.entries.find(e => e.path === fullPath)
-      if (entry) {
-        // Markdown note — open inside Laputa editor
-        notes.handleSelectNote(entry)
-        dialogs.closeConflictResolver()
-      } else {
-        // Non-note file (e.g. settings.json) —
-        // open with system default app so the user can inspect/edit it
-        openLocalFile(fullPath)
-      }
-    }
-  }, [resolvedPath, vault.entries, notes, dialogs])
-
-  const handleRenameTab = useCallback(async (path: string, newTitle: string) => {
-    await savePendingForPath(path)
-    await notes.handleRenameNote(path, newTitle, resolvedPath, vault.replaceEntry).then(vault.loadModifiedFiles)
-  }, [notes, resolvedPath, vault, savePendingForPath])
-
-  // Wrap handleSave to also persist unsaved notes that have no pending edits (user pressed Cmd+S without typing)
-  // and trigger file rename when the title slug doesn't match the filename.
-  const handleSave = useCallback(async () => {
-    const activeTab = notes.tabs.find(t => t.entry.path === notes.activeTabPath)
-    const fallback = activeTab && vault.unsavedPaths.has(activeTab.entry.path)
-      ? { path: activeTab.entry.path, content: activeTab.content }
-      : undefined
-    await handleSaveRaw(fallback)
-
-    // After saving, check if filename needs to match the current title
-    if (activeTab && needsRenameOnSave(activeTab.entry.title, activeTab.entry.filename)) {
-      await handleRenameTab(activeTab.entry.path, activeTab.entry.title)
-    }
-  }, [handleSaveRaw, handleRenameTab, notes.tabs, notes.activeTabPath, vault.unsavedPaths])
-
-  const commitFlow = useCommitFlow({ savePending, loadModifiedFiles: vault.loadModifiedFiles, commitAndPush: vault.commitAndPush, setToastMessage, onPushRejected: autoSync.handlePushRejected })
+  const commitFlow = useCommitFlow({ savePending: appSave.savePending, loadModifiedFiles: vault.loadModifiedFiles, commitAndPush: vault.commitAndPush, setToastMessage, onPushRejected: autoSync.handlePushRejected })
+  const suggestedCommitMessage = useMemo(() => generateCommitMessage(vault.modifiedFiles), [vault.modifiedFiles])
 
   const entryActions = useEntryActions({
     entries: vault.entries, updateEntry: vault.updateEntry,
@@ -374,7 +318,7 @@ function App() {
     handleDeleteProperty: notes.handleDeleteProperty, setToastMessage,
     createTypeEntry: notes.createTypeEntrySilent,
     onFrontmatterPersisted: vault.loadModifiedFiles,
-    onBeforeAction: flushBeforeAction,
+    onBeforeAction: appSave.flushBeforeAction,
   })
 
   const deleteActions = useDeleteActions({
@@ -392,13 +336,59 @@ function App() {
     setToastMessage(`Type "${name}" created`)
   }, [notes])
 
-  /** Title field change: save pending content then rename file + update wikilinks (non-blocking). */
-  const handleTitleSync = useCallback((path: string, newTitle: string) => {
-    savePendingForPath(path)
-      .then(() => notes.handleRenameNote(path, newTitle, resolvedPath, vault.replaceEntry))
-      .then(vault.loadModifiedFiles)
-      .catch((err) => console.error('Title rename failed:', err))
-  }, [notes, resolvedPath, vault, savePendingForPath])
+  const handleCreateOrUpdateView = useCallback(async (definition: import('./types').ViewDefinition) => {
+    const editing = dialogs.editingView
+    const filename = editing
+      ? editing.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 })
+    trackEvent(editing ? 'view_updated' : 'view_created')
+    await vault.reloadViews()
+    setToastMessage(editing ? `View "${definition.name}" updated` : `View "${definition.name}" created`)
+    handleSetSelection({ kind: 'view', filename })
+  }, [resolvedPath, vault, handleSetSelection, dialogs.editingView])
+
+  const handleEditView = useCallback((filename: string) => {
+    const view = vault.views.find((v) => v.filename === filename)
+    if (view) dialogs.openEditView(filename, view.definition)
+  }, [vault.views, dialogs])
+
+  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)
 
@@ -407,7 +397,7 @@ function App() {
   // Diff-toggle ref: Editor registers its handleToggleDiff here so the command palette can call it
   const diffToggleRef = useRef<() => void>(() => {})
 
-  const { setViewMode, sidebarVisible, noteListVisible } = useViewMode()
+  const { setViewMode, sidebarVisible, noteListVisible } = useViewMode(noteWindowParams ? 'editor-only' : undefined)
   const zoom = useZoom()
   const buildNumber = useBuildNumber()
 
@@ -428,7 +418,6 @@ function App() {
     } else if (result === 'error') {
       setToastMessage('Could not check for updates')
     }
-    // 'available' → UpdateBanner handles it automatically
   }, [updateActions, updateStatus.state, setToastMessage])
 
   const handleRepairVault = useCallback(async () => {
@@ -454,13 +443,13 @@ function App() {
     onCreateNote: notes.handleCreateNoteImmediate,
     onOpenDailyNote: notes.handleOpenDailyNote,
     onCreateNoteOfType: notes.handleCreateNoteImmediate,
-    onSave: handleSave,
+    onSave: appSave.handleSave,
     onOpenSettings: dialogs.openSettings,
     onTrashNote: entryActions.handleTrashNote, onRestoreNote: entryActions.handleRestoreNote,
     onArchiveNote: entryActions.handleArchiveNote, onUnarchiveNote: entryActions.handleUnarchiveNote,
     onCommitPush: commitFlow.openCommitDialog,
     onPull: autoSync.triggerSync,
-    onResolveConflicts: handleOpenConflictResolver,
+    onResolveConflicts: conflictFlow.handleOpenConflictResolver,
     onSetViewMode: setViewMode,
     onToggleInspector: () => layout.setInspectorCollapsed(c => !c),
     onToggleDiff: () => diffToggleRef.current(),
@@ -495,6 +484,7 @@ function App() {
     noteListFilter,
     onSetNoteListFilter: setNoteListFilter,
     onOpenInNewWindow: handleOpenInNewWindow,
+    onToggleFavorite: entryActions.handleToggleFavorite,
   })
 
   const activeTab = notes.tabs.find((t) => t.entry.path === notes.activeTabPath) ?? null
@@ -503,7 +493,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',
     }))
@@ -515,18 +505,35 @@ function App() {
     return { type: null, query: '' }
   }, [selection])
 
-  // Show welcome/onboarding screen when vault doesn't exist
-  if (onboarding.state.status === 'welcome' || onboarding.state.status === 'vault-missing') {
+  // Show welcome/onboarding screen when vault doesn't exist (skip for note windows — vault path is known)
+  if (!noteWindowParams && (onboarding.state.status === 'welcome' || onboarding.state.status === 'vault-missing')) {
     return <WelcomeView onboarding={onboarding} />
   }
 
-  // Show loading spinner while checking vault
-  if (onboarding.state.status === 'loading') {
+  // Show loading spinner while checking vault (skip for note windows)
+  if (!noteWindowParams && onboarding.state.status === 'loading') {
     return <LoadingView />
   }
 
-  // Show telemetry consent dialog on first launch (or first upgrade with telemetry)
-  if (settingsLoaded && settings.telemetry_consent === null) {
+  // Show git-required modal when vault has no git repo (skip for note windows)
+  if (!noteWindowParams && gitRepoState === 'required') {
+    return (
+      <div className="app-shell">
+        <GitRequiredModal
+          onCreateRepo={handleInitGitRepo}
+          onChooseVault={vaultSwitcher.handleOpenLocalFolder}
+        />
+      </div>
+    )
+  }
+
+  // Show loading spinner while checking git status
+  if (!noteWindowParams && gitRepoState === 'checking' && onboarding.state.status === 'ready') {
+    return <LoadingView />
+  }
+
+  // Show telemetry consent dialog on first launch (skip for note windows)
+  if (!noteWindowParams && settingsLoaded && settings.telemetry_consent === null) {
     return (
       <TelemetryConsentDialog
         onAccept={() => {
@@ -546,7 +553,7 @@ function App() {
         {sidebarVisible && (
           <>
             <div className="app__sidebar" style={{ width: layout.sidebarWidth }}>
-              <Sidebar entries={vault.entries} selection={selection} onSelect={handleSetSelection} onSelectNote={notes.handleSelectNote} onCreateType={notes.handleCreateNoteImmediate} onCreateNewType={dialogs.openCreateType} onCustomizeType={entryActions.handleCustomizeType} onUpdateTypeTemplate={entryActions.handleUpdateTypeTemplate} onReorderSections={entryActions.handleReorderSections} onRenameSection={entryActions.handleRenameSection} onToggleTypeVisibility={entryActions.handleToggleTypeVisibility} modifiedCount={vault.modifiedFiles.length} inboxCount={inboxCount} onCommitPush={commitFlow.openCommitDialog} isGitVault={!vault.modifiedFilesError} />
+              <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} onEditView={handleEditView} onDeleteView={handleDeleteView} inboxCount={inboxCount} />
             </div>
             <ResizeHandle onResize={layout.handleSidebarResize} />
           </>
@@ -555,9 +562,9 @@ function App() {
           <>
             <div className={`app__note-list${aiActivity.highlightElement === 'notelist' ? ' ai-highlight' : ''}`} style={{ width: layout.noteListWidth }}>
               {selection.kind === 'filter' && selection.filter === 'pulse' ? (
-                <PulseView vaultPath={resolvedPath} onOpenNote={handlePulseOpenNote} sidebarCollapsed={!sidebarVisible} onExpandSidebar={() => setViewMode('all')} />
+                <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} />
@@ -584,19 +591,21 @@ function App() {
             onDeleteProperty={notes.handleDeleteProperty}
             onAddProperty={notes.handleAddProperty}
             onCreateAndOpenNote={notes.handleCreateNoteForRelationship}
+            onInitializeProperties={handleInitializeProperties}
             showAIChat={dialogs.showAIChat}
             onToggleAIChat={dialogs.toggleAIChat}
             vaultPath={resolvedPath}
             noteList={aiNoteList}
             noteListFilter={aiNoteListFilter}
+            onToggleFavorite={entryActions.handleToggleFavorite}
             onTrashNote={entryActions.handleTrashNote}
             onRestoreNote={entryActions.handleRestoreNote}
             onDeleteNote={deleteActions.handleDeleteNote}
             onArchiveNote={entryActions.handleArchiveNote}
             onUnarchiveNote={entryActions.handleUnarchiveNote}
-            onContentChange={handleContentChange}
-            onSave={handleSave}
-            onTitleSync={handleTitleSync}
+            onContentChange={appSave.handleContentChange}
+            onSave={appSave.handleSave}
+            onTitleSync={appSave.handleTitleSync}
             rawToggleRef={rawToggleRef}
             diffToggleRef={diffToggleRef}
             canGoBack={canGoBack}
@@ -604,36 +613,27 @@ function App() {
             onGoBack={handleGoBack}
             onGoForward={handleGoForward}
             leftPanelsCollapsed={!sidebarVisible && !noteListVisible}
-            onFileCreated={handleAgentFileCreated}
-            onFileModified={handleAgentFileModified}
-            onVaultChanged={handleAgentVaultChanged}
+            onFileCreated={vaultBridge.handleAgentFileCreated}
+            onFileModified={vaultBridge.handleAgentFileModified}
+            onVaultChanged={vaultBridge.handleAgentVaultChanged}
             onSetNoteIcon={handleSetNoteIcon}
             onRemoveNoteIcon={handleRemoveNoteIcon}
-            isConflicted={!!notes.activeTabPath && autoSync.conflictFiles.some(f => notes.activeTabPath?.endsWith(f))}
-            onKeepMine={handleKeepMine}
-            onKeepTheirs={handleKeepTheirs}
+            isConflicted={conflictFlow.isConflicted}
+            onKeepMine={conflictFlow.handleKeepMine}
+            onKeepTheirs={conflictFlow.handleKeepTheirs}
           />
         </div>
       </div>
-      {flatVaultMigration.needsMigration && (
-        <FlatVaultMigrationBanner
-          strayFileCount={flatVaultMigration.strayFiles.length}
-          isMigrating={flatVaultMigration.isMigrating}
-          onMigrate={async () => {
-            const count = await flatVaultMigration.migrate()
-            setToastMessage(`Migrated ${count} file${count !== 1 ? 's' : ''} to vault root`)
-          }}
-          onDismiss={flatVaultMigration.dismiss}
-        />
-      )}
       <UpdateBanner status={updateStatus} actions={updateActions} />
-      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} remoteStatus={autoSync.remoteStatus} onTriggerSync={autoSync.triggerSync} onPullAndPush={autoSync.pullAndPush} onOpenConflictResolver={handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} />
+      <RenameDetectedBanner renames={detectedRenames} onUpdate={handleUpdateWikilinks} onDismiss={handleDismissRenames} />
+      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={vaultSwitcher.vaultPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onConnectGitHub={dialogs.openGitHubVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} onClickPulse={() => handleSetSelection({ kind: 'filter', filter: 'pulse' })} onCommitPush={commitFlow.openCommitDialog} isGitVault={!vault.modifiedFilesError} hasGitHub={!!settings.github_token} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} lastCommitInfo={autoSync.lastCommitInfo} remoteStatus={autoSync.remoteStatus} onTriggerSync={autoSync.triggerSync} onPullAndPush={autoSync.pullAndPush} onOpenConflictResolver={conflictFlow.handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} />
       <Toast message={toastMessage} onDismiss={() => setToastMessage(null)} />
       <QuickOpenPalette open={dialogs.showQuickOpen} entries={vault.entries} onSelect={notes.handleSelectNote} onClose={dialogs.closeQuickOpen} />
       <CommandPalette open={dialogs.showCommandPalette} commands={commands} onClose={dialogs.closeCommandPalette} />
       <SearchPanel open={dialogs.showSearch} vaultPath={resolvedPath} entries={vault.entries} onSelectNote={notes.handleSelectNote} onClose={dialogs.closeSearch} />
       <CreateTypeDialog open={dialogs.showCreateTypeDialog} onClose={dialogs.closeCreateType} onCreate={handleCreateType} />
-      <CommitDialog open={commitFlow.showCommitDialog} modifiedCount={vault.modifiedFiles.length} onCommit={commitFlow.handleCommitPush} onClose={commitFlow.closeCommitDialog} />
+      <CreateViewDialog open={dialogs.showCreateViewDialog} onClose={dialogs.closeCreateView} onCreate={handleCreateOrUpdateView} availableFields={availableFields} valueSuggestions={valueSuggestionsForField} editingView={dialogs.editingView?.definition ?? null} />
+      <CommitDialog open={commitFlow.showCommitDialog} modifiedCount={vault.modifiedFiles.length} suggestedMessage={suggestedCommitMessage} onCommit={commitFlow.handleCommitPush} onClose={commitFlow.closeCommitDialog} />
       <ConflictResolverModal
         open={dialogs.showConflictResolver}
         fileStates={conflictResolver.fileStates}
@@ -643,7 +643,7 @@ function App() {
         onResolveFile={conflictResolver.resolveFile}
         onOpenInEditor={conflictResolver.openInEditor}
         onCommit={conflictResolver.commitResolution}
-        onClose={handleCloseConflictResolver}
+        onClose={conflictFlow.handleCloseConflictResolver}
       />
       <SettingsPanel open={dialogs.showSettings} settings={settings} onSave={saveSettings} onClose={dialogs.closeSettings} />
       <GitHubVaultModal

src/NoteWindow.tsx

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

src/components/AIChatPanel.tsx

@@ -1,356 +0,0 @@
-import { useState, useRef, useEffect, useMemo } from 'react'
-import type { VaultEntry } from '../types'
-import {
-  X, Plus, PaperPlaneRight, Copy, ArrowClockwise,
-  TextIndent, Sparkle, MagnifyingGlass, Minus,
-} from '@phosphor-icons/react'
-import {
-  type ChatMessage,
-  buildSystemPrompt,
-} from '../utils/ai-chat'
-import { useAIChat } from '../hooks/useAIChat'
-import { MarkdownContent } from './MarkdownContent'
-
-// --- Sub-components ---
-
-interface AIChatPanelProps {
-  entry: VaultEntry | null
-  entries?: VaultEntry[]
-  onClose: () => void
-  onNavigateWikilink?: (target: string) => void
-}
-
-function TypingIndicator() {
-  return (
-    <div className="flex items-start gap-2" style={{ padding: '8px 12px' }}>
-      <div style={{ display: 'flex', gap: 4, padding: '10px 0' }}>
-        <span className="typing-dot" />
-        <span className="typing-dot" style={{ animationDelay: '0.2s' }} />
-        <span className="typing-dot" style={{ animationDelay: '0.4s' }} />
-      </div>
-    </div>
-  )
-}
-
-function ContextPill({ note, onRemove }: { note: VaultEntry; onRemove: () => void }) {
-  return (
-    <span
-      className="flex items-center gap-1"
-      style={{
-        background: 'var(--accent-green-light)',
-        borderRadius: 99, fontSize: 11,
-        padding: '2px 6px 2px 8px', color: 'var(--foreground)', maxWidth: 160,
-      }}
-    >
-      <span className="truncate">{note.title}</span>
-      <button
-        className="flex items-center justify-center shrink-0 border-none bg-transparent p-0 cursor-pointer text-muted-foreground hover:text-foreground"
-        onClick={onRemove} title={`Remove ${note.title}`}
-      >
-        <Minus size={10} weight="bold" />
-      </button>
-    </span>
-  )
-}
-
-function ContextSearchDropdown({
-  entries, contextPaths, onAdd, onClose,
-}: {
-  entries: VaultEntry[]; contextPaths: Set<string>
-  onAdd: (entry: VaultEntry) => void; onClose: () => void
-}) {
-  const [query, setQuery] = useState('')
-  const inputRef = useRef<HTMLInputElement>(null)
-  useEffect(() => { inputRef.current?.focus() }, [])
-
-  const filtered = useMemo(() => {
-    const q = query.toLowerCase()
-    return entries
-      .filter(e => !contextPaths.has(e.path))
-      .filter(e => !q || e.title.toLowerCase().includes(q) || (e.isA ?? '').toLowerCase().includes(q))
-      .slice(0, 8)
-  }, [entries, contextPaths, query])
-
-  return (
-    <div className="absolute left-0 right-0 bg-background border border-border rounded shadow-lg z-10"
-      style={{ top: '100%', maxHeight: 240, overflow: 'hidden' }}>
-      <div className="flex items-center gap-1 border-b border-border" style={{ padding: '4px 8px' }}>
-        <MagnifyingGlass size={12} className="text-muted-foreground shrink-0" />
-        <input ref={inputRef} value={query} onChange={e => setQuery(e.target.value)}
-          onKeyDown={e => e.key === 'Escape' && onClose()} placeholder="Search notes..."
-          className="flex-1 border-none bg-transparent text-foreground outline-none"
-          style={{ fontSize: 12, padding: '2px 0' }} />
-      </div>
-      <div style={{ overflow: 'auto', maxHeight: 200 }}>
-        {filtered.map(entry => (
-          <button key={entry.path}
-            className="flex items-center gap-2 w-full text-left border-none bg-transparent cursor-pointer hover:bg-accent text-foreground"
-            style={{ padding: '6px 10px', fontSize: 12 }}
-            onClick={() => { onAdd(entry); onClose() }}>
-            <span className="text-muted-foreground" style={{ fontSize: 10, minWidth: 60 }}>{entry.isA ?? 'Note'}</span>
-            <span className="truncate">{entry.title}</span>
-          </button>
-        ))}
-        {filtered.length === 0 && (
-          <div className="text-muted-foreground text-center" style={{ padding: 12, fontSize: 12 }}>No matching notes</div>
-        )}
-      </div>
-    </div>
-  )
-}
-
-function AssistantMessage({ msg, onRetry, onNavigateWikilink }: { msg: ChatMessage; onRetry: () => void; onNavigateWikilink?: (target: string) => void }) {
-  return (
-    <div>
-      <MarkdownContent content={msg.content} onWikilinkClick={onNavigateWikilink} />
-      <div className="flex items-center gap-3" style={{ marginTop: 4 }}>
-        <button className="border-none bg-transparent p-0 text-muted-foreground cursor-pointer hover:underline"
-          style={{ fontSize: 11 }} onClick={() => navigator.clipboard.writeText(msg.content)}>
-          <Copy size={12} style={{ marginRight: 3, verticalAlign: 'middle' }} />Copy
-        </button>
-        <button className="border-none bg-transparent p-0 text-muted-foreground cursor-pointer hover:underline"
-          style={{ fontSize: 11 }} onClick={onRetry}>
-          <ArrowClockwise size={12} style={{ marginRight: 3, verticalAlign: 'middle' }} />Retry
-        </button>
-        <button className="border-none bg-transparent p-0 text-muted-foreground cursor-pointer hover:underline"
-          style={{ fontSize: 11 }}>
-          <TextIndent size={12} style={{ marginRight: 3, verticalAlign: 'middle' }} />Insert
-        </button>
-      </div>
-    </div>
-  )
-}
-
-function StreamingContent({ content, onNavigateWikilink }: { content: string; onNavigateWikilink?: (target: string) => void }) {
-  return (
-    <div style={{ marginBottom: 12 }}>
-      <MarkdownContent content={content} onWikilinkClick={onNavigateWikilink} />
-    </div>
-  )
-}
-
-function UserBubble({ content }: { content: string }) {
-  return (
-    <div className="flex justify-end">
-      <div style={{
-        background: 'var(--primary)', color: 'white',
-        borderRadius: '12px 12px 2px 12px', maxWidth: '85%',
-        padding: '8px 12px', fontSize: 13, lineHeight: 1.5, whiteSpace: 'pre-wrap',
-      }}>{content}</div>
-    </div>
-  )
-}
-
-function formatTokens(n: number): string {
-  return n < 1000 ? String(n) : `${(n / 1000).toFixed(1)}k`
-}
-
-const QUICK_ACTIONS = [
-  { label: 'Summarize', message: 'Summarize this note' },
-  { label: 'Expand', message: 'Expand this note with more detail' },
-  { label: 'Fix grammar', message: 'Fix grammar and improve readability' },
-]
-
-// --- Context management hook ---
-
-function useContextNotes(entry: VaultEntry | null) {
-  const [contextNotes, setContextNotes] = useState<VaultEntry[]>([])
-
-  useEffect(() => {
-    if (entry) {
-      // eslint-disable-next-line react-hooks/set-state-in-effect -- sync context when active note changes
-      setContextNotes(prev => prev.some(n => n.path === entry.path) ? prev : [entry, ...prev])
-    }
-  }, [entry?.path]) // eslint-disable-line react-hooks/exhaustive-deps
-
-  const addNote = (note: VaultEntry) => {
-    setContextNotes(prev => prev.some(n => n.path === note.path) ? prev : [...prev, note])
-  }
-  const removeNote = (path: string) => {
-    setContextNotes(prev => prev.filter(n => n.path !== path))
-  }
-  const paths = useMemo(() => new Set(contextNotes.map(n => n.path)), [contextNotes])
-
-  return { contextNotes, addNote, removeNote, paths }
-}
-
-// --- Main component ---
-
-export function AIChatPanel({ entry, entries = [], onClose, onNavigateWikilink }: AIChatPanelProps) {
-  const [input, setInput] = useState('')
-  const [showSearch, setShowSearch] = useState(false)
-  const messagesEndRef = useRef<HTMLDivElement>(null)
-
-  const ctx = useContextNotes(entry)
-  const chat = useAIChat(ctx.contextNotes)
-
-  const contextInfo = useMemo(
-    () => buildSystemPrompt(ctx.contextNotes),
-    [ctx.contextNotes],
-  )
-
-  useEffect(() => {
-    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
-  }, [chat.messages, chat.isStreaming, chat.streamingContent])
-
-  const handleSend = () => { chat.sendMessage(input); setInput('') }
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); handleSend() }
-  }
-
-  return (
-    <aside className="flex flex-1 flex-col overflow-hidden border-l border-border bg-background text-foreground">
-      <PanelHeader onClear={chat.clearConversation} onClose={onClose} />
-
-      <ContextBar
-        notes={ctx.contextNotes} entries={entries} contextPaths={ctx.paths}
-        tokenCount={contextInfo.totalTokens} truncated={contextInfo.truncated}
-        showSearch={showSearch} onToggleSearch={() => setShowSearch(!showSearch)}
-        onAdd={ctx.addNote} onRemove={ctx.removeNote} onCloseSearch={() => setShowSearch(false)}
-      />
-
-      <MessageList
-        messages={chat.messages} isStreaming={chat.isStreaming}
-        streamingContent={chat.streamingContent} onRetry={chat.retryMessage}
-        messagesEndRef={messagesEndRef} onNavigateWikilink={onNavigateWikilink}
-      />
-
-      <QuickActionsBar actions={QUICK_ACTIONS} disabled={chat.isStreaming}
-        onAction={msg => { chat.sendMessage(msg); setInput('') }} />
-
-      <InputArea input={input} onInputChange={setInput}
-        onKeyDown={handleKeyDown} onSend={handleSend} disabled={chat.isStreaming || !input.trim()} />
-
-      <style>{`
-        .typing-dot {
-          width: 6px; height: 6px; border-radius: 50%;
-          background: var(--muted-foreground);
-          animation: typing-bounce 1.2s infinite ease-in-out;
-        }
-        @keyframes typing-bounce {
-          0%, 80%, 100% { opacity: 0.3; transform: scale(0.8); }
-          40% { opacity: 1; transform: scale(1); }
-        }
-      `}</style>
-    </aside>
-  )
-}
-
-// --- Extracted layout sections ---
-
-function PanelHeader({ onClear, onClose }: { onClear: () => void; onClose: () => void }) {
-  return (
-    <div className="flex shrink-0 items-center border-b border-border" style={{ height: 45, padding: '0 12px', gap: 8 }}>
-      <Sparkle size={16} className="shrink-0 text-muted-foreground" />
-      <span className="flex-1 text-muted-foreground" style={{ fontSize: 13, fontWeight: 600 }}>AI Chat</span>
-      <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground transition-colors"
-        onClick={onClear} title="New conversation"><Plus size={16} /></button>
-      <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground transition-colors"
-        onClick={onClose} title="Close AI Chat"><X size={16} /></button>
-    </div>
-  )
-}
-
-function ContextBar({
-  notes, entries, contextPaths, tokenCount, truncated,
-  showSearch, onToggleSearch, onAdd, onRemove, onCloseSearch,
-}: {
-  notes: VaultEntry[]; entries: VaultEntry[]; contextPaths: Set<string>
-  tokenCount: number; truncated: boolean
-  showSearch: boolean; onToggleSearch: () => void
-  onAdd: (note: VaultEntry) => void; onRemove: (path: string) => void; onCloseSearch: () => void
-}) {
-  return (
-    <div className="relative flex shrink-0 flex-wrap items-center gap-1.5 border-b border-border" style={{ padding: '6px 12px' }}>
-      {notes.map(note => (
-        <ContextPill key={note.path} note={note} onRemove={() => onRemove(note.path)} />
-      ))}
-      <button
-        className="flex items-center gap-0.5 border border-dashed border-border bg-transparent text-muted-foreground cursor-pointer hover:text-foreground rounded-full"
-        style={{ fontSize: 11, padding: '2px 8px' }} onClick={onToggleSearch} title="Add note to context">
-        <Plus size={10} weight="bold" /><span>Add</span>
-      </button>
-      {notes.length > 0 && (
-        <span className="text-muted-foreground ml-auto" style={{ fontSize: 10 }}>
-          ~{formatTokens(tokenCount)} tokens{truncated && ' (truncated)'}
-        </span>
-      )}
-      {showSearch && (
-        <ContextSearchDropdown entries={entries} contextPaths={contextPaths} onAdd={onAdd} onClose={onCloseSearch} />
-      )}
-    </div>
-  )
-}
-
-function MessageList({
-  messages, isStreaming, streamingContent, onRetry, messagesEndRef, onNavigateWikilink,
-}: {
-  messages: ChatMessage[]; isStreaming: boolean; streamingContent: string
-  onRetry: (idx: number) => void; messagesEndRef: React.RefObject<HTMLDivElement | null>
-  onNavigateWikilink?: (target: string) => void
-}) {
-  return (
-    <div className="flex-1 overflow-y-auto" style={{ padding: 12 }}>
-      {messages.length === 0 && !isStreaming && (
-        <div className="flex flex-col items-center justify-center text-center text-muted-foreground" style={{ paddingTop: 40 }}>
-          <Sparkle size={24} style={{ marginBottom: 8, opacity: 0.5 }} />
-          <p style={{ fontSize: 13, margin: '0 0 4px' }}>Ask anything about your notes</p>
-          <p style={{ fontSize: 11, margin: 0, opacity: 0.6 }}>Powered by Claude CLI</p>
-        </div>
-      )}
-      {messages.map((msg, idx) => (
-        <div key={msg.id} style={{ marginBottom: 12 }}>
-          {msg.role === 'user'
-            ? <UserBubble content={msg.content} />
-            : <AssistantMessage msg={msg} onRetry={() => onRetry(idx)} onNavigateWikilink={onNavigateWikilink} />}
-        </div>
-      ))}
-      {isStreaming && streamingContent && <StreamingContent content={streamingContent} onNavigateWikilink={onNavigateWikilink} />}
-      {isStreaming && !streamingContent && <TypingIndicator />}
-      <div ref={messagesEndRef} />
-    </div>
-  )
-}
-
-function QuickActionsBar({
-  actions, disabled, onAction,
-}: {
-  actions: { label: string; message: string }[]; disabled: boolean; onAction: (msg: string) => void
-}) {
-  return (
-    <div className="flex shrink-0 flex-wrap items-center gap-1.5 border-t border-border" style={{ padding: '8px 12px' }}>
-      {actions.map(a => (
-        <button key={a.label}
-          className="cursor-pointer bg-transparent text-foreground hover:bg-accent transition-colors"
-          style={{ fontSize: 11, border: '1px solid var(--border)', borderRadius: 99, padding: '3px 10px' }}
-          onClick={() => onAction(a.message)} disabled={disabled}>
-          {a.label}
-        </button>
-      ))}
-    </div>
-  )
-}
-
-function InputArea({
-  input, onInputChange, onKeyDown, onSend, disabled,
-}: {
-  input: string; onInputChange: (v: string) => void
-  onKeyDown: (e: React.KeyboardEvent) => void; onSend: () => void; disabled: boolean
-}) {
-  return (
-    <div className="flex shrink-0 flex-col border-t border-border" style={{ padding: '8px 12px' }}>
-      <div className="flex items-end gap-2">
-        <textarea value={input} onChange={e => onInputChange(e.target.value)} onKeyDown={onKeyDown}
-          placeholder="Ask about your notes..." rows={1}
-          className="flex-1 resize-none border border-border bg-transparent text-foreground"
-          style={{ fontSize: 13, borderRadius: 8, padding: '8px 10px', outline: 'none', lineHeight: 1.4, maxHeight: 100, fontFamily: 'inherit' }} />
-        <button className="shrink-0 flex items-center justify-center border-none cursor-pointer transition-colors"
-          style={{ background: 'var(--primary)', color: 'white', borderRadius: 8, width: 32, height: 34 }}
-          onClick={onSend} disabled={disabled} title="Send message">
-          <PaperPlaneRight size={16} />
-        </button>
-      </div>
-    </div>
-  )
-}

src/components/AiActionCard.tsx

@@ -74,7 +74,7 @@ function DetailBlock({ label, content, isError }: {
     <div style={{ marginTop: 6 }}>
       <div
         className="text-muted-foreground"
-        style={{ fontSize: 10, fontWeight: 600, textTransform: 'uppercase', marginBottom: 2 }}
+        style={{ fontSize: 10, fontWeight: 600, marginBottom: 2 }}
       >
         {label}
       </div>

src/components/AiPanel.tsx

@@ -28,7 +28,7 @@ function PanelHeader({ onClose, onClear }: { onClose: () => void; onClear: () =>
   return (
     <div
       className="flex shrink-0 items-center border-b border-border"
-      style={{ height: 45, padding: '0 12px', gap: 8 }}
+      style={{ height: 52, padding: '0 12px', gap: 8 }}
     >
       <Robot size={16} className="shrink-0 text-muted-foreground" />
       <span className="flex-1 text-muted-foreground" style={{ fontSize: 13, fontWeight: 600 }}>

src/components/BreadcrumbBar.test.tsx

@@ -41,13 +41,20 @@ const trashedEntry: VaultEntry = {
 
 const defaultProps = {
   wordCount: 100,
-  noteStatus: 'clean' as const,
   showDiffToggle: false,
   diffMode: false,
   diffLoading: false,
   onToggleDiff: vi.fn(),
 }
 
+describe('BreadcrumbBar — drag region', () => {
+  it('has data-tauri-drag-region on the container', () => {
+    const { container } = render(<BreadcrumbBar entry={baseEntry} {...defaultProps} />)
+    const bar = container.firstElementChild as HTMLElement
+    expect(bar.dataset.tauriDragRegion).toBeDefined()
+  })
+})
+
 describe('BreadcrumbBar — trash/restore', () => {
   it('shows trash button for non-trashed note', () => {
     render(<BreadcrumbBar entry={baseEntry} {...defaultProps} onTrash={vi.fn()} onRestore={vi.fn()} />)
@@ -76,18 +83,6 @@ describe('BreadcrumbBar — trash/restore', () => {
   })
 })
 
-describe('BreadcrumbBar — pending save indicator', () => {
-  it('shows "Saving…" text when noteStatus is pendingSave', () => {
-    render(<BreadcrumbBar entry={baseEntry} {...defaultProps} noteStatus={'pendingSave'} />)
-    expect(screen.getByText('Saving…')).toBeInTheDocument()
-  })
-
-  it('does not show "Saving…" text for clean status', () => {
-    render(<BreadcrumbBar entry={baseEntry} {...defaultProps} noteStatus={'clean'} />)
-    expect(screen.queryByText('Saving…')).not.toBeInTheDocument()
-  })
-})
-
 describe('BreadcrumbBar — archive/unarchive', () => {
   it('shows archive button for non-archived note', () => {
     render(<BreadcrumbBar entry={baseEntry} {...defaultProps} onArchive={vi.fn()} onUnarchive={vi.fn()} />)
@@ -116,6 +111,50 @@ describe('BreadcrumbBar — archive/unarchive', () => {
   })
 })
 
+describe('BreadcrumbBar — title in breadcrumb (always rendered, CSS-toggled)', () => {
+  it('always renders title elements in the DOM', () => {
+    render(<BreadcrumbBar entry={baseEntry} {...defaultProps} />)
+    expect(screen.getByText('Note')).toBeInTheDocument()
+    expect(screen.getByText('›')).toBeInTheDocument()
+    expect(screen.getByText('Test Note')).toBeInTheDocument()
+  })
+
+  it('shows emoji icon when entry has an emoji icon', () => {
+    const entryWithEmoji = { ...baseEntry, icon: '🚀' }
+    render(<BreadcrumbBar entry={entryWithEmoji} {...defaultProps} />)
+    expect(screen.getByText('🚀')).toBeInTheDocument()
+  })
+
+  it('does not show icon when entry has a non-emoji icon', () => {
+    const entryWithPhosphor = { ...baseEntry, icon: 'cooking-pot' }
+    render(<BreadcrumbBar entry={entryWithPhosphor} {...defaultProps} />)
+    expect(screen.queryByText('cooking-pot')).not.toBeInTheDocument()
+  })
+
+  it('falls back to "Note" when isA is null', () => {
+    const entryNoType = { ...baseEntry, isA: null }
+    render(<BreadcrumbBar entry={entryNoType} {...defaultProps} />)
+    expect(screen.getByText('Note')).toBeInTheDocument()
+  })
+
+  it('shadow is controlled by data-title-hidden attribute via CSS', () => {
+    const { container } = render(<BreadcrumbBar entry={baseEntry} {...defaultProps} />)
+    const bar = container.querySelector('.breadcrumb-bar')!
+    expect(bar).not.toHaveAttribute('data-title-hidden')
+    bar.setAttribute('data-title-hidden', '')
+    expect(bar).toHaveAttribute('data-title-hidden')
+  })
+})
+
+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

@@ -1,7 +1,6 @@
 import { memo } from 'react'
-import type { VaultEntry, NoteStatus } from '../types'
+import type { VaultEntry } from '../types'
 import { cn } from '@/lib/utils'
-import { isEmoji } from '../utils/emoji'
 import {
   MagnifyingGlass,
   GitBranch,
@@ -14,12 +13,12 @@ import {
   ArrowCounterClockwise,
   Archive,
   ArrowUUpLeft,
+  Star,
 } from '@phosphor-icons/react'
 
 interface BreadcrumbBarProps {
   entry: VaultEntry
   wordCount: number
-  noteStatus: NoteStatus
   showDiffToggle: boolean
   diffMode: boolean
   diffLoading: boolean
@@ -30,10 +29,13 @@ interface BreadcrumbBarProps {
   onToggleAIChat?: () => void
   inspectorCollapsed?: boolean
   onToggleInspector?: () => void
+  onToggleFavorite?: () => void
   onTrash?: () => void
   onRestore?: () => void
   onArchive?: () => void
   onUnarchive?: () => void
+  /** Ref for direct DOM manipulation — avoids re-render on scroll. */
+  barRef?: React.Ref<HTMLDivElement>
 }
 
 const DISABLED_ICON_STYLE = { opacity: 0.4, cursor: 'not-allowed' } as const
@@ -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,
-}: Omit<BreadcrumbBarProps, 'wordCount' | 'noteStatus'>) {
+  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"
@@ -146,7 +158,7 @@ function BreadcrumbActions({ entry, showDiffToggle, diffMode, diffLoading, onTog
         <button
           className="flex items-center justify-center border-none bg-transparent p-0 text-muted-foreground cursor-pointer hover:text-foreground transition-colors"
           onClick={onToggleInspector}
-          title="Open Properties"
+          title="Properties (⌘⇧I)"
         >
           <SlidersHorizontal size={16} />
         </button>
@@ -163,50 +175,37 @@ function BreadcrumbActions({ entry, showDiffToggle, diffMode, diffLoading, onTog
   )
 }
 
+function BreadcrumbTitle({ entry }: { entry: VaultEntry }) {
+  const typeLabel = entry.isA ?? 'Note'
+  const icon = entry.icon
+  const emojiIcon = icon && /^\p{Emoji}/u.test(icon) ? icon : null
+  return (
+    <div className="flex items-center gap-1.5 min-w-0 text-sm text-muted-foreground">
+      <span className="shrink-0">{typeLabel}</span>
+      <span className="shrink-0 text-border">›</span>
+      {emojiIcon && <span className="shrink-0">{emojiIcon}</span>}
+      <span className="truncate font-medium text-foreground">{entry.title}</span>
+    </div>
+  )
+}
+
 export const BreadcrumbBar = memo(function BreadcrumbBar({
-  entry, wordCount, noteStatus, ...actionProps
+  entry, barRef, ...actionProps
 }: BreadcrumbBarProps) {
   return (
     <div
-      className="flex shrink-0 items-center justify-between"
+      ref={barRef}
+      data-tauri-drag-region
+      className="breadcrumb-bar flex shrink-0 items-center"
       style={{
-        height: 45,
+        height: 52,
         background: 'var(--background)',
-        borderBottom: '1px solid var(--border)',
         padding: '6px 16px',
       }}
     >
-      {/* Left: breadcrumb */}
-      <div className="flex items-center gap-1 min-w-0 whitespace-nowrap" style={{ fontSize: 12 }}>
-        <span className="shrink-0 text-muted-foreground">{entry.isA || 'Note'}</span>
-        <span className="shrink-0 text-muted-foreground" style={{ margin: '0 2px' }}>&rsaquo;</span>
-        <span className="truncate font-medium text-foreground" style={{ maxWidth: '40vw' }}>
-          {entry.icon && isEmoji(entry.icon) && <span className="mr-1">{entry.icon}</span>}
-          {entry.title}
-        </span>
-        <span className="shrink-0 text-muted-foreground" style={{ margin: '0 4px' }}>&middot;</span>
-        <span className="shrink-0 text-muted-foreground">{wordCount.toLocaleString()} words</span>
-        {noteStatus === 'pendingSave' && (
-          <>
-            <span className="text-muted-foreground" style={{ margin: '0 4px' }}>&middot;</span>
-            <span className="font-semibold tab-status-pulse" style={{ color: 'var(--accent-green)' }}>Saving…</span>
-          </>
-        )}
-        {noteStatus === 'new' && (
-          <>
-            <span className="text-muted-foreground" style={{ margin: '0 4px' }}>&middot;</span>
-            <span className="font-semibold" style={{ color: 'var(--accent-green)' }}>N</span>
-          </>
-        )}
-        {noteStatus === 'modified' && (
-          <>
-            <span className="text-muted-foreground" style={{ margin: '0 4px' }}>&middot;</span>
-            <span className="font-semibold" style={{ color: 'var(--accent-yellow)' }}>M</span>
-          </>
-        )}
+      <div className="breadcrumb-bar__title flex-1 min-w-0">
+        <BreadcrumbTitle entry={entry} />
       </div>
-
-      {/* Right: action icons */}
       <BreadcrumbActions entry={entry} {...actionProps} />
     </div>
   )

src/components/ColorInput.tsx

@@ -99,10 +99,10 @@ export function ColorEditableValue({ value, isEditing, onStartEdit, onSave, onCa
   }
 
   return (
-    <span className="inline-flex min-w-0 items-center gap-1.5">
+    <span className="inline-flex h-6 min-w-0 items-center gap-1.5">
       {showSwatch && <ColorSwatch color={value} onChange={handlePickerChange} />}
       <span
-        className="min-w-0 cursor-pointer truncate rounded px-1 py-0.5 text-right text-[12px] text-secondary-foreground transition-colors hover:bg-muted"
+        className="min-w-0 cursor-pointer truncate rounded px-1 text-right text-[12px] text-secondary-foreground transition-colors hover:bg-muted"
         onClick={onStartEdit}
         title={value || 'Click to edit'}
       >

src/components/CommandPalette.test.tsx

@@ -208,7 +208,8 @@ describe('CommandPalette', () => {
       const groupHeaders = screen.getAllByText(
         (_content, el) =>
           el?.tagName === 'DIV' &&
-          el.classList.contains('uppercase') &&
+          el.classList.contains('text-[11px]') &&
+          el.classList.contains('font-medium') &&
           !!el.textContent,
       ).map(el => el.textContent)
 

src/components/CommandPalette.tsx

@@ -140,7 +140,7 @@ export function CommandPalette({ open, commands, onClose }: CommandPaletteProps)
               runningIndex += items.length
               return (
                 <div key={group}>
-                  <div className="px-4 pb-1 pt-2 text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">
+                  <div className="px-4 pb-1 pt-2 text-[11px] font-medium text-muted-foreground">
                     {group}
                   </div>
                   {items.map((cmd, i) => {

src/components/CommitDialog.test.tsx

@@ -78,4 +78,30 @@ describe('CommitDialog', () => {
     const { container } = render(<CommitDialog open={false} modifiedCount={3} onCommit={onCommit} onClose={onClose} />)
     expect(container.querySelector('textarea')).toBeNull()
   })
+
+  it('pre-populates message with suggestedMessage', () => {
+    render(<CommitDialog open={true} modifiedCount={3} suggestedMessage="Update alpha, beta" onCommit={onCommit} onClose={onClose} />)
+    const textarea = screen.getByPlaceholderText('Commit message...')
+    expect(textarea).toHaveValue('Update alpha, beta')
+  })
+
+  it('enables Commit button when suggestedMessage is provided', () => {
+    render(<CommitDialog open={true} modifiedCount={3} suggestedMessage="Update alpha" onCommit={onCommit} onClose={onClose} />)
+    expect(getCommitButton()).not.toBeDisabled()
+  })
+
+  it('submits suggestedMessage on Cmd+Enter without user edits', () => {
+    render(<CommitDialog open={true} modifiedCount={3} suggestedMessage="Update alpha" onCommit={onCommit} onClose={onClose} />)
+    const textarea = screen.getByPlaceholderText('Commit message...')
+    fireEvent.keyDown(textarea, { key: 'Enter', metaKey: true })
+    expect(onCommit).toHaveBeenCalledWith('Update alpha')
+  })
+
+  it('allows user to edit the suggested message', () => {
+    render(<CommitDialog open={true} modifiedCount={3} suggestedMessage="Update alpha" onCommit={onCommit} onClose={onClose} />)
+    const textarea = screen.getByPlaceholderText('Commit message...')
+    fireEvent.change(textarea, { target: { value: 'fix: corrected typo in alpha' } })
+    fireEvent.click(getCommitButton())
+    expect(onCommit).toHaveBeenCalledWith('fix: corrected typo in alpha')
+  })
 })

src/components/CommitDialog.tsx

@@ -6,20 +6,21 @@ import { Badge } from '@/components/ui/badge'
 interface CommitDialogProps {
   open: boolean
   modifiedCount: number
+  suggestedMessage?: string
   onCommit: (message: string) => void
   onClose: () => void
 }
 
-export function CommitDialog({ open, modifiedCount, onCommit, onClose }: CommitDialogProps) {
+export function CommitDialog({ open, modifiedCount, suggestedMessage, onCommit, onClose }: CommitDialogProps) {
   const [message, setMessage] = useState('')
   const inputRef = useRef<HTMLTextAreaElement>(null)
 
   useEffect(() => {
     if (open) {
-      setMessage('') // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
+      setMessage(suggestedMessage ?? '') // eslint-disable-line react-hooks/set-state-in-effect -- reset on dialog open
       setTimeout(() => inputRef.current?.focus(), 50)
     }
-  }, [open])
+  }, [open]) // eslint-disable-line react-hooks/exhaustive-deps -- only reset when dialog opens
 
   const handleSubmit = () => {
     const trimmed = message.trim()

src/components/CreateNoteDialog.tsx

@@ -55,7 +55,7 @@ export function CreateNoteDialog({ open, onClose, onCreate, defaultType, customT
         </DialogHeader>
         <form onSubmit={handleSubmit} className="space-y-4">
           <div className="space-y-1.5">
-            <label className="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+            <label className="text-xs font-medium text-muted-foreground">
               Title
             </label>
             <Input
@@ -66,7 +66,7 @@ export function CreateNoteDialog({ open, onClose, onCreate, defaultType, customT
             />
           </div>
           <div className="space-y-1.5">
-            <label className="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+            <label className="text-xs font-medium text-muted-foreground">
               Type
             </label>
             <div className="flex flex-wrap gap-1.5">

src/components/CreateTypeDialog.tsx

@@ -36,7 +36,7 @@ export function CreateTypeDialog({ open, onClose, onCreate }: CreateTypeDialogPr
         </DialogHeader>
         <form onSubmit={handleSubmit} className="space-y-4">
           <div className="space-y-1.5">
-            <label className="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+            <label className="text-xs font-medium text-muted-foreground">
               Type Name
             </label>
             <Input

src/components/CreateViewDialog.test.tsx

@@ -0,0 +1,45 @@
+import { render, screen } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import { CreateViewDialog } from './CreateViewDialog'
+import type { ViewDefinition } from '../types'
+
+describe('CreateViewDialog', () => {
+  const defaultProps = {
+    open: true,
+    onClose: vi.fn(),
+    onCreate: vi.fn(),
+    availableFields: ['type', 'status', 'title'],
+  }
+
+  it('shows "Create View" title in create mode', () => {
+    render(<CreateViewDialog {...defaultProps} />)
+    expect(screen.getByText('Create View')).toBeInTheDocument()
+    expect(screen.getByText('Create')).toBeInTheDocument()
+  })
+
+  it('shows "Edit View" title when editingView is provided', () => {
+    const editingView: ViewDefinition = {
+      name: 'Active Projects',
+      icon: '🚀',
+      color: null,
+      sort: null,
+      filters: { all: [{ field: 'type', op: 'equals', value: 'Project' }] },
+    }
+    render(<CreateViewDialog {...defaultProps} editingView={editingView} />)
+    expect(screen.getByText('Edit View')).toBeInTheDocument()
+    expect(screen.getByText('Save')).toBeInTheDocument()
+  })
+
+  it('pre-populates name field in edit mode', () => {
+    const editingView: ViewDefinition = {
+      name: 'Active Projects',
+      icon: '🚀',
+      color: null,
+      sort: null,
+      filters: { all: [{ field: 'type', op: 'equals', value: 'Project' }] },
+    }
+    render(<CreateViewDialog {...defaultProps} editingView={editingView} />)
+    const input = screen.getByPlaceholderText(/Active Projects|Reading List/i)
+    expect(input).toHaveValue('Active Projects')
+  })
+})

src/components/CreateViewDialog.tsx

@@ -0,0 +1,119 @@
+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[]
+  /** When provided, the dialog operates in edit mode with pre-populated fields. */
+  editingView?: ViewDefinition | null
+}
+
+export function CreateViewDialog({ open, onClose, onCreate, availableFields, valueSuggestions, editingView }: 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)
+  const isEditing = !!editingView
+
+  useEffect(() => {
+    if (open) {
+      if (editingView) {
+        setName(editingView.name) // eslint-disable-line react-hooks/set-state-in-effect -- populate on dialog open
+        setIcon(editingView.icon ?? '') // eslint-disable-line react-hooks/set-state-in-effect -- populate on dialog open
+        setFilters(editingView.filters) // eslint-disable-line react-hooks/set-state-in-effect -- populate on dialog open
+      } else {
+        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
+        setFilters({ all: [{ field: availableFields[0] ?? 'type', op: 'equals', value: '' }] }) // 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
+      setTimeout(() => inputRef.current?.focus(), 50)
+    }
+  }, [open, availableFields, editingView])
+
+  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="flex max-h-[80vh] flex-col sm:max-w-[600px]">
+        <DialogHeader>
+          <DialogTitle>{isEditing ? 'Edit View' : 'Create View'}</DialogTitle>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className="flex min-h-0 flex-1 flex-col gap-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="min-h-0 flex-1 space-y-1.5 overflow-y-auto">
+            <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()}>{isEditing ? 'Save' : 'Create'}</Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}

src/components/DynamicPropertiesPanel.test.tsx

@@ -112,8 +112,8 @@ describe('DynamicPropertiesPanel', () => {
         frontmatter={{ Status: 'Active' }}
       />
     )
-    // Status rendered with CSS text-transform: uppercase, DOM text is still "Active"
-    expect(screen.getByTitle('Active')).toBeInTheDocument()
+    // Status rendered as sentence case
+    expect(screen.getByTestId('status-badge')).toBeInTheDocument()
   })
 
   it('renders properties from frontmatter', () => {
@@ -124,9 +124,9 @@ describe('DynamicPropertiesPanel', () => {
         frontmatter={{ cadence: 'Weekly', owner: 'Luca' }}
       />
     )
-    expect(screen.getByText('cadence')).toBeInTheDocument()
+    expect(screen.getByText('Cadence')).toBeInTheDocument()
     expect(screen.getByText('Weekly')).toBeInTheDocument()
-    expect(screen.getByText('owner')).toBeInTheDocument()
+    expect(screen.getByText('Owner')).toBeInTheDocument()
     expect(screen.getByText('Luca')).toBeInTheDocument()
   })
 
@@ -162,7 +162,7 @@ describe('DynamicPropertiesPanel', () => {
         frontmatter={{ notion_id: 'abc-123-def' }}
       />
     )
-    expect(screen.getByText('notion_id')).toBeInTheDocument()
+    expect(screen.getByText('Notion id')).toBeInTheDocument()
     expect(screen.getByText('abc-123-def')).toBeInTheDocument()
   })
 
@@ -177,7 +177,7 @@ describe('DynamicPropertiesPanel', () => {
     // aliases skipped (in SKIP_KEYS); 'Belongs to' skipped (has wikilinks)
     expect(screen.queryByText('aliases')).not.toBeInTheDocument()
     expect(screen.queryByText('Belongs to')).not.toBeInTheDocument()
-    expect(screen.getByText('cadence')).toBeInTheDocument()
+    expect(screen.getByText('Cadence')).toBeInTheDocument()
   })
 
   it('shows former relationship key with plain text value in Properties', () => {
@@ -219,7 +219,7 @@ describe('DynamicPropertiesPanel', () => {
     const typeLabels = screen.getAllByText('Type')
     // Only the TypeRow label should exist, not a property row
     expect(typeLabels).toHaveLength(1)
-    expect(screen.getByTitle('Active')).toBeInTheDocument()
+    expect(screen.getByTestId('status-badge')).toBeInTheDocument()
   })
 
   it('renders boolean property as toggle', () => {
@@ -232,7 +232,7 @@ describe('DynamicPropertiesPanel', () => {
       />
     )
     // Boolean should show as Yes/No toggle
-    const toggleBtn = screen.getByText('\u2717 No')
+    const toggleBtn = screen.getByText('No')
     fireEvent.click(toggleBtn)
     expect(onUpdateProperty).toHaveBeenCalledWith('published', true)
   })
@@ -260,7 +260,7 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    expect(screen.getByText('+ Add property')).toBeInTheDocument()
+    expect(screen.getByText('Add property')).toBeInTheDocument()
   })
 
   it('opens add property form when button clicked', () => {
@@ -272,7 +272,7 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     expect(screen.getByPlaceholderText('Property name')).toBeInTheDocument()
     expect(screen.getByPlaceholderText('Value')).toBeInTheDocument()
     expect(screen.getByTestId('add-property-type-trigger')).toBeInTheDocument()
@@ -287,7 +287,7 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     const keyInput = screen.getByPlaceholderText('Property name')
     const valueInput = screen.getByPlaceholderText('Value')
     fireEvent.change(keyInput, { target: { value: 'priority' } })
@@ -412,7 +412,7 @@ describe('DynamicPropertiesPanel', () => {
       />
     )
     // Click status pill to open dropdown
-    fireEvent.click(screen.getByTitle('Active'))
+    fireEvent.click(screen.getByTestId('status-badge'))
     // Should show dropdown with search input
     expect(screen.getByTestId('status-dropdown')).toBeInTheDocument()
     expect(screen.getByTestId('status-search-input')).toBeInTheDocument()
@@ -478,11 +478,11 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     const keyInput = screen.getByPlaceholderText('Property name')
     fireEvent.keyDown(keyInput, { key: 'Escape' })
     // Form should be hidden, button should reappear
-    expect(screen.getByText('+ Add property')).toBeInTheDocument()
+    expect(screen.getByText('Add property')).toBeInTheDocument()
   })
 
   it('adds property on Enter in form', () => {
@@ -494,7 +494,7 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     const keyInput = screen.getByPlaceholderText('Property name')
     const valueInput = screen.getByPlaceholderText('Value')
     fireEvent.change(keyInput, { target: { value: 'key' } })
@@ -512,7 +512,7 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     const keyInput = screen.getByPlaceholderText('Property name')
     const valueInput = screen.getByPlaceholderText('Value')
     fireEvent.change(keyInput, { target: { value: 'tags' } })
@@ -530,9 +530,9 @@ describe('DynamicPropertiesPanel', () => {
         onAddProperty={onAddProperty}
       />
     )
-    fireEvent.click(screen.getByText('+ Add property'))
+    fireEvent.click(screen.getByText('Add property'))
     fireEvent.click(screen.getByTestId('add-property-cancel'))
-    expect(screen.getByText('+ Add property')).toBeInTheDocument()
+    expect(screen.getByText('Add property')).toBeInTheDocument()
   })
 
   describe('editable vs read-only distinction', () => {
@@ -775,7 +775,7 @@ describe('DynamicPropertiesPanel', () => {
       expect(screen.getByText('Mar 31, 2026')).toBeInTheDocument()
     })
 
-    it('renders calendar icon in date trigger button', () => {
+    it('renders date trigger button', () => {
       render(
         <DynamicPropertiesPanel
           entry={makeEntry()}
@@ -786,7 +786,6 @@ describe('DynamicPropertiesPanel', () => {
       )
       const trigger = screen.getByTestId('date-display')
       expect(trigger.tagName).toBe('BUTTON')
-      expect(trigger.querySelector('svg')).toBeInTheDocument()
     })
 
     it('opens calendar popover when date button clicked', () => {
@@ -841,7 +840,7 @@ describe('DynamicPropertiesPanel', () => {
           onUpdateProperty={onUpdateProperty}
         />
       )
-      fireEvent.click(screen.getByTitle('Active'))
+      fireEvent.click(screen.getByTestId('status-badge'))
       expect(screen.getByTestId('status-dropdown')).toBeInTheDocument()
       fireEvent.keyDown(screen.getByTestId('status-search-input'), { key: 'Escape' })
       expect(screen.queryByTestId('status-dropdown')).not.toBeInTheDocument()
@@ -857,7 +856,7 @@ describe('DynamicPropertiesPanel', () => {
           onUpdateProperty={onUpdateProperty}
         />
       )
-      fireEvent.click(screen.getByTitle('Active'))
+      fireEvent.click(screen.getByTestId('status-badge'))
       fireEvent.click(screen.getByTestId('status-dropdown-backdrop'))
       expect(screen.queryByTestId('status-dropdown')).not.toBeInTheDocument()
       expect(onUpdateProperty).not.toHaveBeenCalled()
@@ -872,7 +871,7 @@ describe('DynamicPropertiesPanel', () => {
           onUpdateProperty={onUpdateProperty}
         />
       )
-      fireEvent.click(screen.getByTitle('Active'))
+      fireEvent.click(screen.getByTestId('status-badge'))
       const input = screen.getByTestId('status-search-input')
       fireEvent.change(input, { target: { value: 'Needs Review' } })
       fireEvent.keyDown(input, { key: 'Enter' })
@@ -893,7 +892,7 @@ describe('DynamicPropertiesPanel', () => {
           onUpdateProperty={onUpdateProperty}
         />
       )
-      fireEvent.click(screen.getByTitle('Active'))
+      fireEvent.click(screen.getByTestId('status-badge'))
       expect(screen.getByTestId('status-option-Reviewing')).toBeInTheDocument()
       expect(screen.getByTestId('status-option-Shipped')).toBeInTheDocument()
     })
@@ -910,7 +909,7 @@ describe('DynamicPropertiesPanel', () => {
         />
       )
       expect(screen.getByTestId('boolean-toggle')).toBeInTheDocument()
-      expect(screen.getByText('\u2713 Yes')).toBeInTheDocument()
+      expect(screen.getByText('Yes')).toBeInTheDocument()
     })
 
     it('renders boolean toggle for false values', () => {
@@ -923,7 +922,7 @@ describe('DynamicPropertiesPanel', () => {
         />
       )
       expect(screen.getByTestId('boolean-toggle')).toBeInTheDocument()
-      expect(screen.getByText('\u2717 No')).toBeInTheDocument()
+      expect(screen.getByText('No')).toBeInTheDocument()
     })
   })
 
@@ -937,13 +936,13 @@ describe('DynamicPropertiesPanel', () => {
           onUpdateProperty={onUpdateProperty}
         />
       )
-      expect(screen.queryByText('trashed')).not.toBeInTheDocument()
-      expect(screen.queryByText('trashed_at')).not.toBeInTheDocument()
-      expect(screen.queryByText('archived')).not.toBeInTheDocument()
-      expect(screen.queryByText('archived_at')).not.toBeInTheDocument()
-      expect(screen.queryByText('icon')).not.toBeInTheDocument()
+      expect(screen.queryByText('Trashed')).not.toBeInTheDocument()
+      expect(screen.queryByText('Trashed at')).not.toBeInTheDocument()
+      expect(screen.queryByText('Archived')).not.toBeInTheDocument()
+      expect(screen.queryByText('Archived at')).not.toBeInTheDocument()
+      expect(screen.queryByText('Icon')).not.toBeInTheDocument()
       // Custom property still visible
-      expect(screen.getByText('cadence')).toBeInTheDocument()
+      expect(screen.getByText('Cadence')).toBeInTheDocument()
     })
 
     it('filters system properties case-insensitively', () => {
@@ -958,7 +957,7 @@ describe('DynamicPropertiesPanel', () => {
       expect(screen.queryByText('Trashed')).not.toBeInTheDocument()
       expect(screen.queryByText('Archived')).not.toBeInTheDocument()
       expect(screen.queryByText('Icon')).not.toBeInTheDocument()
-      expect(screen.getByText('cadence')).toBeInTheDocument()
+      expect(screen.getByText('Cadence')).toBeInTheDocument()
     })
 
     it('does not filter similar but non-matching property names', () => {
@@ -971,7 +970,7 @@ describe('DynamicPropertiesPanel', () => {
         />
       )
       expect(screen.getByText('Is Trashed')).toBeInTheDocument()
-      expect(screen.getByText('archive_date')).toBeInTheDocument()
+      expect(screen.getByText('Archive date')).toBeInTheDocument()
     })
   })
 
@@ -1055,7 +1054,7 @@ describe('DynamicPropertiesPanel', () => {
         />
       )
       expect(screen.getByTestId('boolean-toggle')).toBeInTheDocument()
-      expect(screen.getByText('\u2713 Yes')).toBeInTheDocument()
+      expect(screen.getByText('Yes')).toBeInTheDocument()
     })
 
     it('renders boolean toggle for string "false" when boolean mode overridden', () => {
@@ -1069,7 +1068,7 @@ describe('DynamicPropertiesPanel', () => {
         />
       )
       expect(screen.getByTestId('boolean-toggle')).toBeInTheDocument()
-      expect(screen.getByText('\u2717 No')).toBeInTheDocument()
+      expect(screen.getByText('No')).toBeInTheDocument()
     })
 
     it('toggles string boolean from false to true', () => {
@@ -1124,7 +1123,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       // Switch type to boolean
       fireEvent.pointerDown(screen.getByTestId('add-property-type-trigger'), { button: 0, pointerType: 'mouse' })
       fireEvent.click(screen.getByRole('option', { name: /Boolean/ }))
@@ -1141,7 +1140,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       fireEvent.pointerDown(screen.getByTestId('add-property-type-trigger'), { button: 0, pointerType: 'mouse' })
       fireEvent.click(screen.getByRole('option', { name: /Boolean/ }))
       // Toggle from No to Yes
@@ -1158,7 +1157,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       const keyInput = screen.getByPlaceholderText('Property name')
       fireEvent.change(keyInput, { target: { value: 'published' } })
       // Switch to boolean type
@@ -1180,7 +1179,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       fireEvent.pointerDown(screen.getByTestId('add-property-type-trigger'), { button: 0, pointerType: 'mouse' })
       fireEvent.click(screen.getByRole('option', { name: /Date/ }))
       expect(screen.getByTestId('add-property-date-trigger')).toBeInTheDocument()
@@ -1196,7 +1195,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       fireEvent.pointerDown(screen.getByTestId('add-property-type-trigger'), { button: 0, pointerType: 'mouse' })
       fireEvent.click(screen.getByRole('option', { name: /Status/ }))
       expect(screen.getByTestId('add-property-status-trigger')).toBeInTheDocument()
@@ -1211,7 +1210,7 @@ describe('DynamicPropertiesPanel', () => {
           onAddProperty={onAddProperty}
         />
       )
-      fireEvent.click(screen.getByText('+ Add property'))
+      fireEvent.click(screen.getByText('Add property'))
       // Default mode is text
       expect(screen.getByPlaceholderText('Value')).toBeInTheDocument()
     })

src/components/DynamicPropertiesPanel.tsx

@@ -9,6 +9,12 @@ import { AddPropertyForm } from './AddPropertyForm'
 import { countWords } from '../utils/wikilinks'
 import type { PropertyDisplayMode } from '../utils/propertyTypes'
 
+function toSentenceCase(key: string): string {
+  const spaced = key.replace(/[_-]/g, ' ')
+  if (!spaced) return spaced
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1)
+}
+
 // eslint-disable-next-line react-refresh/only-export-components -- utility co-located with component
 export function containsWikilinks(value: FrontmatterValue): boolean {
   if (typeof value === 'string') return /^\[\[.*\]\]$/.test(value)
@@ -47,9 +53,9 @@ function PropertyRow({ propKey, value, editingKey, displayMode, autoMode, vaultS
   }
 
   return (
-    <div className="group/prop grid min-w-0 grid-cols-2 items-center gap-2 rounded px-1.5 outline-none transition-colors hover:bg-muted focus:bg-muted focus:ring-1 focus:ring-primary" tabIndex={0} onKeyDown={handleKeyDown} data-testid="editable-property">
-      <span className="font-mono-overline flex min-w-0 items-center gap-1 text-muted-foreground">
-        <span className="truncate">{propKey}</span>
+    <div className="group/prop grid min-h-7 min-w-0 grid-cols-2 items-center gap-2 rounded px-1.5 outline-none transition-colors hover:bg-muted focus:bg-muted focus:ring-1 focus:ring-primary" tabIndex={0} onKeyDown={handleKeyDown} data-testid="editable-property">
+      <span className="flex min-w-0 items-center gap-1 text-[12px] text-muted-foreground">
+        <span className="truncate">{toSentenceCase(propKey)}</span>
         {onDelete && (
           <button className="border-none bg-transparent p-0 text-sm leading-none text-muted-foreground opacity-0 transition-all hover:text-destructive group-hover/prop:opacity-100" onClick={() => onDelete(propKey)} title="Delete property">&times;</button>
         )}
@@ -65,7 +71,7 @@ function PropertyRow({ propKey, value, editingKey, displayMode, autoMode, vaultS
 function InfoRow({ label, value }: { label: string; value: string }) {
   return (
     <div className="grid min-w-0 grid-cols-2 items-center gap-2 px-1.5" data-testid="readonly-property">
-      <span className="font-mono-overline min-w-0 truncate" style={{ color: 'var(--text-muted)' }}>{label}</span>
+      <span className="min-w-0 truncate text-[12px] text-muted-foreground">{label}</span>
       <span className="min-w-0 truncate text-right text-[12px]" style={{ color: 'var(--text-muted)' }}>{value}</span>
     </div>
   )
@@ -74,10 +80,12 @@ function InfoRow({ label, value }: { label: string; value: string }) {
 function AddPropertyButton({ onClick, disabled }: { onClick: () => void; disabled: boolean }) {
   return (
     <button
-      className="mt-3 w-full cursor-pointer border border-border bg-transparent text-center text-muted-foreground transition-colors hover:border-primary hover:text-primary disabled:cursor-not-allowed disabled:opacity-50"
-      style={{ borderRadius: 6, padding: '6px 12px', fontSize: 12 }}
+      className="mt-1 flex w-full cursor-pointer items-center gap-1 border-none bg-transparent px-1.5 text-[12px] text-muted-foreground opacity-50 transition-opacity hover:opacity-100 disabled:cursor-not-allowed"
       onClick={onClick} disabled={disabled}
-    >+ Add property</button>
+    >
+      <span className="text-[12px] leading-none">+</span>
+      Add property
+    </button>
   )
 }
 

src/components/EditableValue.tsx

@@ -1,5 +1,6 @@
 import { useState, useCallback, useRef } from 'react'
 import { normalizeUrl, openExternalUrl } from '../utils/url'
+import { getTagStyle } from '../utils/tagStyles'
 
 export function UrlValue({
   value,
@@ -63,9 +64,9 @@ export function UrlValue({
   }
 
   return (
-    <span className="group/url inline-flex min-w-0 items-center gap-1">
+    <span className="group/url flex min-w-0 max-w-full items-center gap-1">
       <span
-        className="min-w-0 cursor-pointer truncate rounded px-1 py-0.5 text-right text-[12px] text-secondary-foreground transition-colors hover:text-primary hover:underline"
+        className="inline-flex h-6 min-w-0 cursor-pointer items-center truncate rounded-md px-2 text-right text-[12px] text-[var(--accent-blue)] underline decoration-[var(--accent-blue)]/40 transition-colors hover:decoration-[var(--accent-blue)]"
         onClick={handleOpen}
         title={value}
         data-testid="url-link"
@@ -124,7 +125,7 @@ export function EditableValue({
 
   return (
     <span
-      className="min-w-0 cursor-pointer truncate rounded px-1 py-0.5 text-right text-[12px] text-secondary-foreground transition-colors hover:bg-muted"
+      className="inline-flex h-6 min-w-0 max-w-full cursor-pointer items-center truncate rounded-md px-2 text-right text-[12px] text-secondary-foreground transition-colors hover:bg-muted"
       onClick={onStartEdit}
       title={value || 'Click to edit'}
     >
@@ -211,11 +212,12 @@ export function TagPillList({
         ) : (
           <span
             key={idx}
-            className="group/pill relative inline-flex cursor-pointer items-center rounded-full px-2 py-0.5 transition-colors"
+            className="group/pill relative inline-flex h-6 cursor-pointer items-center rounded-md transition-colors"
             style={{
-              backgroundColor: 'var(--accent-blue-light)',
-              color: 'var(--accent-blue)',
-              fontSize: 11,
+              ...getTagStyle(item),
+              backgroundColor: getTagStyle(item).bg,
+              padding: '0 8px',
+              fontSize: 12,
               fontWeight: 500,
             }}
             onClick={() => handleStartEdit(idx)}
@@ -223,8 +225,8 @@ export function TagPillList({
           >
             {item}
             <button
-              className="absolute right-0.5 top-1/2 flex h-3.5 w-3.5 -translate-y-1/2 items-center justify-center rounded-full border-none p-0 text-[10px] leading-none opacity-0 shadow-[-6px_0_4px_-2px_var(--accent-blue-light)] transition-all hover:bg-[var(--accent-red-light)] hover:text-[var(--accent-red)] group-hover/pill:opacity-100"
-              style={{ color: 'var(--accent-blue)', backgroundColor: 'var(--accent-blue-light)' }}
+              className="absolute right-0.5 top-1/2 flex h-3.5 w-3.5 -translate-y-1/2 items-center justify-center rounded-full border-none p-0 text-[10px] leading-none opacity-0 transition-all hover:bg-[var(--accent-red-light)] hover:text-[var(--accent-red)] group-hover/pill:opacity-100"
+              style={{ color: getTagStyle(item).color, backgroundColor: getTagStyle(item).bg }}
               onClick={(e) => {
                 e.stopPropagation()
                 handleDeleteItem(idx)
@@ -253,7 +255,8 @@ export function TagPillList({
         />
       ) : (
         <button
-          className="inline-flex h-5 w-5 items-center justify-center rounded-full border border-dashed border-[var(--accent-blue)] bg-transparent p-0 text-[12px] leading-none text-[var(--accent-blue)] transition-colors hover:bg-[var(--accent-blue-light)]"
+          className="inline-flex h-6 items-center justify-center rounded-md border-none bg-muted px-2 text-[12px] font-medium leading-none text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+          style={{ padding: '0 8px' }}
           onClick={() => setIsAddingNew(true)}
           title={`Add ${label.toLowerCase()}`}
         >

src/components/Editor.css

@@ -23,6 +23,24 @@
   opacity: 0.55;
 }
 
+/* Breadcrumb bar: title + shadow toggled via data attribute (no React re-render) */
+.breadcrumb-bar {
+  transition: box-shadow 0.2s ease;
+  box-shadow: none;
+}
+
+.breadcrumb-bar[data-title-hidden] {
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
+}
+
+.breadcrumb-bar__title {
+  display: none;
+}
+
+.breadcrumb-bar[data-title-hidden] .breadcrumb-bar__title {
+  display: flex;
+}
+
 /* Scroll area wrapping title + editor — single scroll context for alignment */
 .editor-scroll-area {
   flex: 1;
@@ -179,14 +197,39 @@
   flex-shrink: 0;
 }
 
+.title-section__add-icon {
+  /* "Add icon" button above the title when no emoji — Notion-style */
+  padding-top: 24px;
+  margin-left: 8px;
+  min-height: 28px;
+}
+
+.title-section__row {
+  display: flex;
+  flex-direction: row;
+  align-items: flex-start;
+  padding-top: 8px;
+  margin-left: 8px;
+}
+
+/* No emoji: title aligns flush left (no indent for icon area) */
+.title-section__row--no-icon {
+  margin-left: 0;
+}
+
+/* When emoji is present, restore top padding to the row itself */
+.title-section__row:has(.note-icon-button--active) {
+  padding-top: 32px;
+}
+
 .title-section__separator {
   border-bottom: 1px solid var(--border-primary, rgba(0, 0, 0, 0.08));
   margin-top: 12px;
+  margin-left: 8px;
 }
 
 /* --- Note Icon Area --- */
 .note-icon-area {
-  padding: 16px 0 0;
   flex-shrink: 0;
 }
 
@@ -203,8 +246,10 @@
 }
 
 .note-icon-button--active {
-  font-size: 40px;
+  font-size: 36px;
+  line-height: 1;
   transition: transform 0.1s;
+  margin-right: 10px;
 }
 
 .note-icon-button--active:hover:not(:disabled) {
@@ -221,7 +266,7 @@
   transition: opacity 0.15s;
 }
 
-.note-icon-area:hover .note-icon-button--add,
+.title-section:hover .note-icon-button--add,
 .note-icon-button--add:focus-visible {
   opacity: 1;
 }
@@ -272,8 +317,8 @@
 
 /* --- Title Field --- */
 .title-field {
-  padding: 4px 0 0;
-  flex-shrink: 0;
+  flex: 1;
+  min-width: 0;
 }
 
 .title-field__input {
@@ -282,13 +327,16 @@
   border: none;
   outline: none;
   background: transparent;
-  font-size: var(--headings-h1-font-size);
-  font-weight: var(--headings-h1-font-weight);
-  line-height: var(--headings-h1-line-height);
-  letter-spacing: var(--headings-h1-letter-spacing);
+  font-size: var(--headings-h1-font-size, 32px);
+  font-weight: var(--headings-h1-font-weight, 700);
+  line-height: var(--headings-h1-line-height, 1.2);
+  letter-spacing: var(--headings-h1-letter-spacing, -0.015em);
   color: var(--foreground);
   padding: 0;
-  margin-left: 8px;
+  resize: none;
+  overflow: hidden;
+  font-family: inherit;
+  field-sizing: content;
 }
 
 .title-field__input::placeholder {
@@ -315,3 +363,13 @@
 .editor__blocknote-container [data-node-type="blockContainer"]:first-child:has([data-content-type="heading"][data-level="1"]) {
   display: none;
 }
+
+/* Reduce padding at narrow editor widths so content isn't cramped */
+@container editor (max-width: 600px) {
+  .editor__blocknote-container .bn-editor {
+    padding: 12px 16px;
+  }
+  .title-section {
+    padding: 0 16px;
+  }
+}

src/components/Editor.test.tsx

@@ -124,10 +124,11 @@ describe('Editor', () => {
         activeTabPath={mockEntry.path}
       />
     )
-    expect(screen.getAllByText('Test Project').length).toBeGreaterThan(0)
+    // Tab bar renders when a tab is active
+    expect(screen.getByTestId('blocknote-view')).toBeInTheDocument()
   })
 
-  it('renders breadcrumb bar with note info', () => {
+  it('renders breadcrumb bar with action buttons', () => {
     render(
       <Editor
         {...defaultProps}
@@ -135,10 +136,8 @@ describe('Editor', () => {
         activeTabPath={mockEntry.path}
       />
     )
-    // Breadcrumb shows type and title
-    expect(screen.getByText('Project')).toBeInTheDocument()
-    // Word count shown
-    expect(screen.getByText(/words/)).toBeInTheDocument()
+    // Breadcrumb bar shows action buttons (e.g. search, archive)
+    expect(screen.getByTitle('Search in file')).toBeInTheDocument()
   })
 
   it('shows BlockNote editor when a tab is active', () => {
@@ -152,7 +151,7 @@ describe('Editor', () => {
     expect(screen.getByTestId('blocknote-view')).toBeInTheDocument()
   })
 
-  it('shows modified indicator when file is modified', () => {
+  it('renders editor for modified file without breadcrumb status', () => {
     render(
       <Editor
         {...defaultProps}
@@ -161,11 +160,11 @@ describe('Editor', () => {
         getNoteStatus={() => 'modified'}
       />
     )
-    // Modified indicator shows "M" in the breadcrumb
-    expect(screen.getByText('M')).toBeInTheDocument()
+    // Editor still renders; breadcrumb bar no longer shows status indicators
+    expect(screen.getByTestId('blocknote-view')).toBeInTheDocument()
   })
 
-  it('shows new indicator when file is new', () => {
+  it('renders editor for new file without breadcrumb status', () => {
     render(
       <Editor
         {...defaultProps}
@@ -174,8 +173,8 @@ describe('Editor', () => {
         getNoteStatus={() => 'new'}
       />
     )
-    // New indicator shows "N" in the breadcrumb
-    expect(screen.getByText('N')).toBeInTheDocument()
+    // Editor still renders; breadcrumb bar no longer shows status indicators
+    expect(screen.getByTestId('blocknote-view')).toBeInTheDocument()
   })
 
   it('renders diff toggle button when file is modified', () => {
@@ -468,7 +467,7 @@ describe('wikilink autocomplete', () => {
     expect(items.length).toBeGreaterThan(0)
     items[0].onItemClick()
     expect(mockEditor.insertInlineContent).toHaveBeenCalledWith([
-      { type: 'wikilink', props: { target: 'Alpha Project' } },
+      { type: 'wikilink', props: { target: 'vault/project/test|Alpha Project' } },
       ' ',
     ])
   })
@@ -621,7 +620,7 @@ describe('person @mention autocomplete', () => {
     expect(items.length).toBeGreaterThan(0)
     items[0].onItemClick()
     expect(mockEditor.insertInlineContent).toHaveBeenCalledWith([
-      { type: 'wikilink', props: { target: 'Matteo Cellini' } },
+      { type: 'wikilink', props: { target: 'vault/person/matteo-cellini|Matteo Cellini' } },
       ' ',
     ])
   })

src/components/Editor.tsx

@@ -41,11 +41,13 @@ interface EditorProps {
   onDeleteProperty?: (path: string, key: string) => Promise<void>
   onAddProperty?: (path: string, key: string, value: FrontmatterValue) => Promise<void>
   onCreateAndOpenNote?: (title: string) => Promise<boolean>
+  onInitializeProperties?: (path: string) => void
   showAIChat?: boolean
   onToggleAIChat?: () => void
   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
@@ -202,10 +204,10 @@ export const Editor = memo(function Editor(props: EditorProps) {
     getNoteStatus,
     inspectorCollapsed, onToggleInspector, inspectorWidth, onInspectorResize,
     inspectorEntry, inspectorContent, gitHistory,
-    onUpdateFrontmatter, onDeleteProperty, onAddProperty, onCreateAndOpenNote,
+    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,
@@ -251,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}
@@ -286,6 +289,8 @@ export const Editor = memo(function Editor(props: EditorProps) {
           onDeleteProperty={onDeleteProperty}
           onAddProperty={onAddProperty}
           onCreateAndOpenNote={onCreateAndOpenNote}
+          onInitializeProperties={onInitializeProperties}
+          onToggleRawEditor={handleToggleRawExclusive}
           onOpenNote={onNavigateWikilink}
           onFileCreated={onFileCreated}
           onFileModified={onFileModified}

src/components/EditorContent.tsx

@@ -1,5 +1,5 @@
 import type React from 'react'
-import { useCallback } from 'react'
+import { useCallback, useRef, useEffect } from 'react'
 import type { VaultEntry, NoteStatus } from '../types'
 import type { useCreateBlockNote } from '@blocknote/react'
 import { DiffView } from './DiffView'
@@ -13,6 +13,7 @@ import { RawEditorView } from './RawEditorView'
 import { countWords } from '../utils/wikilinks'
 import { SingleEditorView } from './SingleEditorView'
 import { isEmoji } from '../utils/emoji'
+import { useEditorTheme } from '../hooks/useTheme'
 
 interface Tab {
   entry: VaultEntry
@@ -40,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
@@ -91,7 +93,7 @@ function DiffModeView({ diffContent, onToggleDiff }: { diffContent: string | nul
 }
 
 function RawModeEditorSection({
-  rawMode, activeTab, entries, onContentChange, onSave, latestContentRef,
+  rawMode, activeTab, entries, onContentChange, onSave, latestContentRef, vaultPath,
 }: {
   rawMode: boolean
   activeTab: Tab | null
@@ -99,6 +101,7 @@ function RawModeEditorSection({
   onContentChange?: (path: string, content: string) => void
   onSave?: () => void
   latestContentRef?: React.MutableRefObject<string | null>
+  vaultPath?: string
 }) {
   if (!rawMode || !activeTab) return null
   return (
@@ -110,6 +113,7 @@ function RawModeEditorSection({
       onContentChange={onContentChange ?? (() => {})}
       onSave={onSave ?? (() => {})}
       latestContentRef={latestContentRef}
+      vaultPath={vaultPath}
     />
   )
 }
@@ -119,8 +123,9 @@ function bindPath(cb: ((path: string) => void) | undefined, path: string) {
   return cb ? () => cb(path) : undefined
 }
 
-function ActiveTabBreadcrumb({ activeTab, props }: {
+function ActiveTabBreadcrumb({ activeTab, barRef, props }: {
   activeTab: Tab
+  barRef: React.RefObject<HTMLDivElement | null>
   props: Omit<EditorContentProps, 'activeTab' | 'isLoadingNewTab' | 'entries' | 'editor' | 'onNavigateWikilink' | 'onEditorChange' | 'onRawContentChange' | 'onSave' | 'onDeleteNote'>
 }) {
   const wordCount = countWords(activeTab.content)
@@ -129,7 +134,7 @@ function ActiveTabBreadcrumb({ activeTab, props }: {
     <BreadcrumbBar
       entry={activeTab.entry}
       wordCount={wordCount}
-      noteStatus={props.activeStatus}
+      barRef={barRef}
       showDiffToggle={props.showDiffToggle}
       diffMode={props.diffMode}
       diffLoading={props.diffLoading}
@@ -140,6 +145,7 @@ function ActiveTabBreadcrumb({ activeTab, 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)}
@@ -160,13 +166,35 @@ export function EditorContent({
 }: EditorContentProps) {
   // Look up trashed/archived from the latest vault entries, not the tab snapshot,
   // so the banner appears regardless of navigation context.
+  const { cssVars } = useEditorTheme()
   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
 
+  const titleSectionRef = useRef<HTMLDivElement | null>(null)
+  const breadcrumbBarRef = useRef<HTMLDivElement | null>(null)
+
+  useEffect(() => {
+    const el = titleSectionRef.current
+    const bar = breadcrumbBarRef.current
+    if (!el || !bar) return
+    const observer = new IntersectionObserver(
+      ([e]) => {
+        if (e.isIntersecting) bar.removeAttribute('data-title-hidden')
+        else bar.setAttribute('data-title-hidden', '')
+      },
+      { threshold: 0 },
+    )
+    observer.observe(el)
+    return () => { observer.disconnect(); bar.removeAttribute('data-title-hidden') }
+  }, [activeTab?.entry.path, showEditor])
+
   const handleSetIcon = useCallback((emoji: string) => {
     if (activeTab) onSetNoteIcon?.(activeTab.entry.path, emoji)
   }, [activeTab, onSetNoteIcon])
@@ -180,7 +208,8 @@ export function EditorContent({
       {activeTab && (
         <ActiveTabBreadcrumb
           activeTab={activeTab}
-          props={{ diffMode, diffContent, onToggleDiff, rawMode, onToggleRaw, ...breadcrumbProps }}
+          barRef={breadcrumbBarRef}
+          props={{ diffMode, diffContent, onToggleDiff, rawMode: effectiveRawMode, onToggleRaw, ...breadcrumbProps }}
         />
       )}
       {activeTab && isTrashed && (
@@ -199,22 +228,38 @@ export function EditorContent({
         />
       )}
       {diffMode && <DiffModeView diffContent={diffContent} onToggleDiff={onToggleDiff} />}
-      <RawModeEditorSection rawMode={rawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} latestContentRef={rawLatestContentRef} />
+      <RawModeEditorSection rawMode={effectiveRawMode} activeTab={activeTab} entries={entries} onContentChange={onRawContentChange} onSave={onSave} latestContentRef={rawLatestContentRef} vaultPath={vaultPath} />
       {showEditor && activeTab && (
-        <div className="editor-scroll-area">
-          <div className="title-section">
-            <NoteIcon
-              icon={emojiIcon}
-              editable={!isTrashed}
-              onSetIcon={handleSetIcon}
-              onRemoveIcon={handleRemoveIcon}
-            />
-            <TitleField
-              title={activeTab.entry.title}
-              filename={activeTab.entry.filename}
-              editable={!isTrashed}
-              onTitleChange={(newTitle) => onTitleChange?.(activeTab.entry.path, newTitle)}
-            />
+        <div className="editor-scroll-area" style={cssVars as React.CSSProperties}>
+          <div ref={titleSectionRef} className="title-section">
+            {!emojiIcon && (
+              <div className="title-section__add-icon">
+                <NoteIcon
+                  icon={null}
+                  editable={!isTrashed}
+                  onSetIcon={handleSetIcon}
+                  onRemoveIcon={handleRemoveIcon}
+                />
+              </div>
+            )}
+            <div className={`title-section__row${emojiIcon ? '' : ' title-section__row--no-icon'}`}>
+              {emojiIcon && (
+                <NoteIcon
+                  icon={emojiIcon}
+                  editable={!isTrashed}
+                  onSetIcon={handleSetIcon}
+                  onRemoveIcon={handleRemoveIcon}
+                />
+              )}
+              <TitleField
+                title={activeTab.entry.title}
+                filename={activeTab.entry.filename}
+                editable={!isTrashed}
+                notePath={activeTab.entry.path}
+                vaultPath={vaultPath}
+                onTitleChange={(newTitle) => onTitleChange?.(activeTab.entry.path, newTitle)}
+              />
+            </div>
             <div className="title-section__separator" />
           </div>
           <SingleEditorView editor={editor} entries={entries} onNavigateWikilink={onNavigateWikilink} onChange={onEditorChange} vaultPath={vaultPath} editable={!isTrashed} />

src/components/EditorRightPanel.tsx

@@ -22,6 +22,8 @@ interface EditorRightPanelProps {
   onDeleteProperty?: (path: string, key: string) => Promise<void>
   onAddProperty?: (path: string, key: string, value: FrontmatterValue) => Promise<void>
   onCreateAndOpenNote?: (title: string) => Promise<boolean>
+  onInitializeProperties?: (path: string) => void
+  onToggleRawEditor?: () => void
   onOpenNote?: (path: string) => void
   onFileCreated?: (relativePath: string) => void
   onFileModified?: (relativePath: string) => void
@@ -33,14 +35,14 @@ export function EditorRightPanel({
   inspectorEntry, inspectorContent, entries, gitHistory, vaultPath,
   noteList, noteListFilter,
   onToggleInspector, onToggleAIChat, onNavigateWikilink, onViewCommitDiff,
-  onUpdateFrontmatter, onDeleteProperty, onAddProperty, onCreateAndOpenNote, onOpenNote,
+  onUpdateFrontmatter, onDeleteProperty, onAddProperty, onCreateAndOpenNote, onInitializeProperties, onToggleRawEditor, onOpenNote,
   onFileCreated, onFileModified, onVaultChanged,
 }: EditorRightPanelProps) {
   if (showAIChat) {
     return (
       <div
         className="shrink-0 flex flex-col min-h-0"
-        style={{ width: inspectorWidth, height: '100%' }}
+        style={{ width: inspectorWidth, minWidth: 240, height: '100%' }}
       >
         <AiPanel
           onClose={() => onToggleAIChat?.()}
@@ -79,6 +81,8 @@ export function EditorRightPanel({
         onDeleteProperty={onDeleteProperty}
         onAddProperty={onAddProperty}
         onCreateAndOpenNote={onCreateAndOpenNote}
+        onInitializeProperties={onInitializeProperties}
+        onToggleRawEditor={onToggleRawEditor}
       />
     </div>
   )

src/components/EmojiPicker.tsx

@@ -1,5 +1,5 @@
 import { useState, useRef, useEffect, useCallback } from 'react'
-import { EMOJI_GROUPS, EMOJIS_BY_GROUP, GROUP_ICONS, GROUP_SHORT_LABELS, searchEmojis } from '../utils/emoji'
+import { EMOJI_GROUPS, EMOJIS_BY_GROUP, GROUP_SHORT_LABELS, searchEmojis } from '../utils/emoji'
 
 interface EmojiPickerProps {
   onSelect: (emoji: string) => void
@@ -11,7 +11,6 @@ export function EmojiPicker({ onSelect, onClose }: EmojiPickerProps) {
   const inputRef = useRef<HTMLInputElement>(null)
   const containerRef = useRef<HTMLDivElement>(null)
   const scrollRef = useRef<HTMLDivElement>(null)
-  const groupRefs = useRef<Map<string, HTMLDivElement>>(new Map())
 
   useEffect(() => {
     setTimeout(() => inputRef.current?.focus(), 50)
@@ -45,13 +44,6 @@ export function EmojiPicker({ onSelect, onClose }: EmojiPickerProps) {
     onClose()
   }, [onSelect, onClose])
 
-  const scrollToGroup = useCallback((group: string) => {
-    const el = groupRefs.current.get(group)
-    if (el && scrollRef.current) {
-      el.scrollIntoView({ behavior: 'smooth', block: 'start' })
-    }
-  }, [])
-
   const searchResults = search.trim() ? searchEmojis(search) : null
   const isSearching = searchResults !== null
 
@@ -73,20 +65,6 @@ export function EmojiPicker({ onSelect, onClose }: EmojiPickerProps) {
           data-testid="emoji-picker-search"
         />
       </div>
-      {!isSearching && (
-        <div className="flex gap-0.5 border-b border-border px-2 py-1.5 overflow-x-auto">
-          {EMOJI_GROUPS.map(group => (
-            <button
-              key={group}
-              className="shrink-0 rounded px-1.5 py-1 text-base transition-colors hover:bg-secondary"
-              onClick={() => scrollToGroup(group)}
-              title={GROUP_SHORT_LABELS[group]}
-            >
-              {GROUP_ICONS[group]}
-            </button>
-          ))}
-        </div>
-      )}
       <div ref={scrollRef} className="max-h-[300px] overflow-y-auto p-2" data-testid="emoji-picker-grid">
         {isSearching ? (
           searchResults.length > 0 ? (
@@ -113,10 +91,7 @@ export function EmojiPicker({ onSelect, onClose }: EmojiPickerProps) {
             const emojis = EMOJIS_BY_GROUP.get(group)
             if (!emojis?.length) return null
             return (
-              <div
-                key={group}
-                ref={el => { if (el) groupRefs.current.set(group, el) }}
-              >
+              <div key={group}>
                 <div className="sticky top-0 z-10 bg-popover px-1 pb-1 pt-2 text-[11px] font-medium text-muted-foreground">
                   {GROUP_SHORT_LABELS[group]}
                 </div>

src/components/FilterBuilder.tsx

@@ -0,0 +1,294 @@
+import { Plus, X } from '@phosphor-icons/react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+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'])
+const DATE_OPS = new Set<FilterOp>(['before', 'after'])
+
+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 }
+}
+
+function FieldSelect({ value, fields, onChange }: {
+  value: string
+  fields: string[]
+  onChange: (v: string) => void
+}) {
+  const isCustom = value !== '' && !fields.includes(value)
+  return (
+    <Select value={value} onValueChange={onChange}>
+      <SelectTrigger
+        size="sm"
+        className="h-8 min-w-[100px] flex-1 gap-1 border-input bg-background px-2 text-sm shadow-none"
+      >
+        <SelectValue placeholder="field" />
+      </SelectTrigger>
+      <SelectContent position="popper">
+        {isCustom && <SelectItem value={value}>{value}</SelectItem>}
+        {fields.map((f) => (
+          <SelectItem key={f} value={f}>{f}</SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  )
+}
+
+function OperatorSelect({ value, onChange }: {
+  value: FilterOp
+  onChange: (v: FilterOp) => void
+}) {
+  return (
+    <Select value={value} onValueChange={(v) => onChange(v as FilterOp)}>
+      <SelectTrigger
+        size="sm"
+        className="h-8 shrink-0 gap-1 border-input bg-background px-2 text-sm shadow-none"
+        style={{ minWidth: 120 }}
+      >
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent position="popper">
+        {OPERATORS.map((o) => (
+          <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  )
+}
+
+function ValueInput({ value, suggestions, isDateOp, onChange }: {
+  value: string
+  suggestions: string[]
+  isDateOp: boolean
+  onChange: (v: string) => void
+}) {
+  if (isDateOp) {
+    return (
+      <Input
+        type="date"
+        className="h-8 flex-1 min-w-0 text-sm"
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+      />
+    )
+  }
+
+  if (suggestions.length > 0) {
+    return (
+      <Select value={value} onValueChange={onChange}>
+        <SelectTrigger
+          size="sm"
+          className="h-8 flex-1 min-w-0 gap-1 border-input bg-background px-2 text-sm shadow-none"
+        >
+          <SelectValue placeholder="value" />
+        </SelectTrigger>
+        <SelectContent position="popper">
+          {value !== '' && !suggestions.includes(value) && (
+            <SelectItem value={value}>{value}</SelectItem>
+          )}
+          {suggestions.map((s) => (
+            <SelectItem key={s} value={s}>{s}</SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    )
+  }
+
+  return (
+    <Input
+      className="h-8 flex-1 min-w-0 text-sm"
+      placeholder="value"
+      value={value}
+      onChange={(e) => onChange(e.target.value)}
+    />
+  )
+}
+
+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)
+  const isDateOp = DATE_OPS.has(condition.op)
+  return (
+    <div className="flex items-center gap-1.5">
+      <FieldSelect
+        value={condition.field}
+        fields={fields}
+        onChange={(v) => onUpdate({ ...condition, field: v })}
+      />
+      <OperatorSelect
+        value={condition.op}
+        onChange={(op) => onUpdate({ ...condition, op })}
+      />
+      {!NO_VALUE_OPS.has(condition.op) && (
+        <ValueInput
+          value={String(condition.value ?? '')}
+          suggestions={suggestions}
+          isDateOp={isDateOp}
+          onChange={(v) => onUpdate({ ...condition, value: v })}
+        />
+      )}
+      <Button
+        type="button"
+        variant="ghost"
+        size="sm"
+        className="h-8 w-8 shrink-0 p-0 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"
+          variant="outline"
+          size="sm"
+          className="h-6 rounded-full px-2.5 text-[11px] font-medium"
+          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"
+            variant="ghost"
+            size="sm"
+            className="ml-auto h-6 w-6 p-0 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/FlatVaultMigrationBanner.tsx

@@ -1,37 +0,0 @@
-interface FlatVaultMigrationBannerProps {
-  strayFileCount: number
-  isMigrating: boolean
-  onMigrate: () => void
-  onDismiss: () => void
-}
-
-/**
- * Banner shown when the vault has files in non-protected subfolders.
- * Offers to flatten them to the vault root.
- */
-export function FlatVaultMigrationBanner({ strayFileCount, isMigrating, onMigrate, onDismiss }: FlatVaultMigrationBannerProps) {
-  return (
-    <div className="flex items-center gap-3 px-4 py-2 bg-amber-50 dark:bg-amber-950 border-b border-amber-200 dark:border-amber-800 text-sm" data-testid="migration-banner">
-      <span className="flex-1 text-amber-800 dark:text-amber-200">
-        {strayFileCount} note{strayFileCount !== 1 ? 's' : ''} found in subfolders.
-        Flatten to vault root for consistent scanning.
-      </span>
-      <button
-        className="px-3 py-1 text-xs font-medium rounded bg-amber-600 text-white hover:bg-amber-700 disabled:opacity-50"
-        onClick={onMigrate}
-        disabled={isMigrating}
-        data-testid="migration-flatten-btn"
-      >
-        {isMigrating ? 'Migrating...' : 'Flatten Now'}
-      </button>
-      <button
-        className="px-2 py-1 text-xs text-amber-600 dark:text-amber-400 hover:underline"
-        onClick={onDismiss}
-        disabled={isMigrating}
-        data-testid="migration-dismiss-btn"
-      >
-        Dismiss
-      </button>
-    </div>
-  )
-}

src/components/FolderTree.test.tsx

@@ -0,0 +1,70 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import { FolderTree } from './FolderTree'
+import type { FolderNode, SidebarSelection } from '../types'
+
+const mockFolders: FolderNode[] = [
+  {
+    name: 'projects',
+    path: 'projects',
+    children: [
+      { name: 'laputa', path: 'projects/laputa', children: [] },
+      { name: 'portfolio', path: 'projects/portfolio', children: [] },
+    ],
+  },
+  { name: 'areas', path: 'areas', children: [] },
+  { name: 'journal', path: 'journal', children: [] },
+]
+
+const defaultSelection: SidebarSelection = { kind: 'filter', filter: 'all' }
+
+describe('FolderTree', () => {
+  it('renders nothing when folders is empty', () => {
+    const { container } = render(
+      <FolderTree folders={[]} selection={defaultSelection} onSelect={vi.fn()} />,
+    )
+    expect(container.firstChild).toBeNull()
+  })
+
+  it('renders FOLDERS header and top-level folders', () => {
+    render(<FolderTree folders={mockFolders} selection={defaultSelection} onSelect={vi.fn()} />)
+    expect(screen.getByText('FOLDERS')).toBeInTheDocument()
+    expect(screen.getByText('projects')).toBeInTheDocument()
+    expect(screen.getByText('areas')).toBeInTheDocument()
+    expect(screen.getByText('journal')).toBeInTheDocument()
+  })
+
+  it('does not show children initially', () => {
+    render(<FolderTree folders={mockFolders} selection={defaultSelection} onSelect={vi.fn()} />)
+    expect(screen.queryByText('laputa')).not.toBeInTheDocument()
+  })
+
+  it('calls onSelect with folder kind when clicking a folder', () => {
+    const onSelect = vi.fn()
+    render(<FolderTree folders={mockFolders} selection={defaultSelection} onSelect={onSelect} />)
+    fireEvent.click(screen.getByText('projects'))
+    expect(onSelect).toHaveBeenCalledWith({ kind: 'folder', path: 'projects' })
+  })
+
+  it('expands children when clicking a folder with children', () => {
+    const onSelect = vi.fn()
+    render(<FolderTree folders={mockFolders} selection={defaultSelection} onSelect={onSelect} />)
+    fireEvent.click(screen.getByText('projects'))
+    expect(screen.getByText('laputa')).toBeInTheDocument()
+    expect(screen.getByText('portfolio')).toBeInTheDocument()
+  })
+
+  it('collapses section when clicking FOLDERS header', () => {
+    render(<FolderTree folders={mockFolders} selection={defaultSelection} onSelect={vi.fn()} />)
+    expect(screen.getByText('projects')).toBeInTheDocument()
+    fireEvent.click(screen.getByText('FOLDERS'))
+    expect(screen.queryByText('projects')).not.toBeInTheDocument()
+  })
+
+  it('highlights selected folder', () => {
+    const sel: SidebarSelection = { kind: 'folder', path: 'areas' }
+    render(<FolderTree folders={mockFolders} selection={sel} onSelect={vi.fn()} />)
+    const btn = screen.getByText('areas').closest('button')!
+    expect(btn.className).toContain('text-primary')
+  })
+})

src/components/FolderTree.tsx

@@ -0,0 +1,162 @@
+import { useState, useCallback, useRef, useEffect, memo } from 'react'
+import { Folder, FolderOpen, CaretDown, CaretRight, Plus } from '@phosphor-icons/react'
+import type { FolderNode, SidebarSelection } from '../types'
+import { cn } from '@/lib/utils'
+
+interface FolderTreeProps {
+  folders: FolderNode[]
+  selection: SidebarSelection
+  onSelect: (selection: SidebarSelection) => void
+  onCreateFolder?: (name: string) => void
+  collapsed?: boolean
+  onToggle?: () => void
+}
+
+function FolderItem({
+  node, depth, selection, expanded, onToggle, onSelect,
+}: {
+  node: FolderNode
+  depth: number
+  selection: SidebarSelection
+  expanded: Record<string, boolean>
+  onToggle: (path: string) => void
+  onSelect: (selection: SidebarSelection) => void
+}) {
+  const isSelected = selection.kind === 'folder' && selection.path === node.path
+  const isExpanded = expanded[node.path] ?? false
+  const hasChildren = node.children.length > 0
+
+  const handleClick = () => {
+    onSelect({ kind: 'folder', path: node.path })
+    if (hasChildren) onToggle(node.path)
+  }
+
+  return (
+    <>
+      <button
+        className={cn(
+          'flex w-full items-center gap-2 rounded-[5px] border-none bg-transparent cursor-pointer text-left transition-colors',
+          isSelected
+            ? 'bg-[var(--accent-blue-light,rgba(0,100,255,0.08))] text-primary'
+            : 'text-foreground hover:bg-accent',
+        )}
+        style={{ padding: '5px 8px', paddingLeft: 8 + depth * 16, fontSize: 13 }}
+        onClick={handleClick}
+        title={node.path}
+      >
+        {isSelected || isExpanded ? (
+          <FolderOpen size={18} weight="fill" className="shrink-0" />
+        ) : (
+          <Folder size={18} className="shrink-0" />
+        )}
+        <span className={cn('truncate', isSelected && 'font-medium')}>{node.name}</span>
+      </button>
+      {isExpanded && hasChildren && (
+        <div className="relative" style={{ paddingLeft: 15 }}>
+          <div
+            className="absolute top-0 bottom-0 bg-border"
+            style={{ left: 15 + depth * 16, width: 1, opacity: 0.3 }}
+          />
+          {node.children.map((child) => (
+            <FolderItem
+              key={child.path}
+              node={child}
+              depth={depth + 1}
+              selection={selection}
+              expanded={expanded}
+              onToggle={onToggle}
+              onSelect={onSelect}
+            />
+          ))}
+        </div>
+      )}
+    </>
+  )
+}
+
+export const FolderTree = memo(function FolderTree({ folders, selection, onSelect, onCreateFolder, collapsed: externalCollapsed, onToggle }: FolderTreeProps) {
+  const [internalCollapsed, setInternalCollapsed] = useState(false)
+  const sectionCollapsed = externalCollapsed ?? internalCollapsed
+  const [expanded, setExpanded] = useState<Record<string, boolean>>({})
+  const [isCreating, setIsCreating] = useState(false)
+  const [newFolderName, setNewFolderName] = useState('')
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  const toggleFolder = useCallback((path: string) => {
+    setExpanded((prev) => ({ ...prev, [path]: !prev[path] }))
+  }, [])
+
+  useEffect(() => {
+    if (isCreating) inputRef.current?.focus()
+  }, [isCreating])
+
+  const handleCreateFolder = () => {
+    const name = newFolderName.trim()
+    if (name && onCreateFolder) {
+      onCreateFolder(name)
+    }
+    setIsCreating(false)
+    setNewFolderName('')
+  }
+
+  if (folders.length === 0 && !isCreating) return null
+
+  return (
+    <div style={{ padding: '4px 6px' }}>
+      {/* Header */}
+      <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={() => onToggle ? onToggle() : setInternalCollapsed((v) => !v)}
+      >
+        <div className="flex items-center gap-1">
+          {sectionCollapsed ? <CaretRight size={12} /> : <CaretDown size={12} />}
+          <span className="text-[10px] font-semibold" style={{ letterSpacing: 0.5 }}>FOLDERS</span>
+        </div>
+        {onCreateFolder && (
+          <Plus
+            size={12}
+            className="text-muted-foreground hover:text-foreground"
+            onClick={(e) => { e.stopPropagation(); setIsCreating(true); if (sectionCollapsed && onToggle) onToggle(); else if (sectionCollapsed) setInternalCollapsed(false) }}
+            data-testid="create-folder-btn"
+          />
+        )}
+      </button>
+
+      {/* Tree */}
+      {!sectionCollapsed && (
+        <div className="flex flex-col gap-0.5" style={{ padding: '2px 6px 8px 14px' }}>
+          {folders.map((node) => (
+            <FolderItem
+              key={node.path}
+              node={node}
+              depth={0}
+              selection={selection}
+              expanded={expanded}
+              onToggle={toggleFolder}
+              onSelect={onSelect}
+            />
+          ))}
+          {isCreating && (
+            <div className="flex items-center gap-2" style={{ padding: '4px 8px' }}>
+              <Folder size={18} className="shrink-0 text-muted-foreground" />
+              <input
+                ref={inputRef}
+                className="flex-1 border border-border rounded bg-background px-1.5 py-0.5 text-[13px] text-foreground outline-none focus:border-primary"
+                value={newFolderName}
+                onChange={(e) => setNewFolderName(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter') handleCreateFolder()
+                  if (e.key === 'Escape') { setIsCreating(false); setNewFolderName('') }
+                }}
+                onBlur={handleCreateFolder}
+                placeholder="Folder name"
+                data-testid="new-folder-input"
+              />
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+})

src/components/GitRequiredModal.test.tsx

@@ -0,0 +1,51 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import { GitRequiredModal } from './GitRequiredModal'
+
+describe('GitRequiredModal', () => {
+  it('renders title and explanation', () => {
+    render(<GitRequiredModal onCreateRepo={vi.fn()} onChooseVault={vi.fn()} />)
+    expect(screen.getByText('Git repository required')).toBeInTheDocument()
+    expect(screen.getByText(/track changes/)).toBeInTheDocument()
+  })
+
+  it('renders both action buttons', () => {
+    render(<GitRequiredModal onCreateRepo={vi.fn()} onChooseVault={vi.fn()} />)
+    expect(screen.getByText('Create repository')).toBeInTheDocument()
+    expect(screen.getByText('Choose another vault')).toBeInTheDocument()
+  })
+
+  it('calls onCreateRepo when primary button clicked', async () => {
+    const onCreateRepo = vi.fn().mockResolvedValue(undefined)
+    render(<GitRequiredModal onCreateRepo={onCreateRepo} onChooseVault={vi.fn()} />)
+    fireEvent.click(screen.getByText('Create repository'))
+    expect(onCreateRepo).toHaveBeenCalledOnce()
+  })
+
+  it('calls onChooseVault when secondary button clicked', () => {
+    const onChooseVault = vi.fn()
+    render(<GitRequiredModal onCreateRepo={vi.fn()} onChooseVault={onChooseVault} />)
+    fireEvent.click(screen.getByText('Choose another vault'))
+    expect(onChooseVault).toHaveBeenCalledOnce()
+  })
+
+  it('disables buttons and shows spinner while creating', async () => {
+    let resolve: () => void
+    const onCreateRepo = vi.fn().mockReturnValue(new Promise<void>(r => { resolve = r }))
+    render(<GitRequiredModal onCreateRepo={onCreateRepo} onChooseVault={vi.fn()} />)
+    fireEvent.click(screen.getByText('Create repository'))
+    await waitFor(() => {
+      expect(screen.getByText('Creating…')).toBeInTheDocument()
+    })
+    resolve!()
+  })
+
+  it('shows error message when creation fails', async () => {
+    const onCreateRepo = vi.fn().mockRejectedValue(new Error('Permission denied'))
+    render(<GitRequiredModal onCreateRepo={onCreateRepo} onChooseVault={vi.fn()} />)
+    fireEvent.click(screen.getByText('Create repository'))
+    await waitFor(() => {
+      expect(screen.getByText(/Permission denied/)).toBeInTheDocument()
+    })
+  })
+})

src/components/GitRequiredModal.tsx

@@ -0,0 +1,57 @@
+import { useState } from 'react'
+import { GitBranch } from '@phosphor-icons/react'
+
+interface GitRequiredModalProps {
+  onCreateRepo: () => Promise<void>
+  onChooseVault: () => void
+}
+
+export function GitRequiredModal({ onCreateRepo, onChooseVault }: GitRequiredModalProps) {
+  const [creating, setCreating] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleCreate = async () => {
+    setCreating(true)
+    setError(null)
+    try {
+      await onCreateRepo()
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err))
+      setCreating(false)
+    }
+  }
+
+  return (
+    <div className="flex h-full w-full items-center justify-center" style={{ background: 'var(--sidebar)' }}>
+      <div className="flex max-w-sm flex-col items-center gap-5 rounded-xl border border-border bg-background p-8 shadow-lg">
+        <GitBranch size={36} className="text-muted-foreground" />
+        <h2 className="m-0 text-lg font-semibold text-foreground">Git repository required</h2>
+        <p className="m-0 text-center text-[13px] leading-relaxed text-muted-foreground">
+          Laputa uses a git repository to track changes, detect moved files, and keep your vault safe.
+          We'll create a local repo — no remote needed.
+        </p>
+        {error && (
+          <p className="m-0 rounded-md bg-destructive/10 px-3 py-2 text-center text-[12px] text-destructive">
+            {error}
+          </p>
+        )}
+        <div className="flex w-full flex-col gap-2">
+          <button
+            className="w-full cursor-pointer rounded-md bg-primary px-4 py-2 text-[13px] font-medium text-primary-foreground transition-colors hover:bg-primary/90 disabled:cursor-not-allowed disabled:opacity-50"
+            onClick={handleCreate}
+            disabled={creating}
+          >
+            {creating ? 'Creating…' : 'Create repository'}
+          </button>
+          <button
+            className="w-full cursor-pointer rounded-md border border-border bg-transparent px-4 py-2 text-[13px] font-medium text-foreground transition-colors hover:bg-muted disabled:cursor-not-allowed disabled:opacity-50"
+            onClick={onChooseVault}
+            disabled={creating}
+          >
+            Choose another vault
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}

src/components/Inspector.test.tsx

@@ -122,11 +122,11 @@ describe('Inspector', () => {
     expect(screen.getByText('Words')).toBeInTheDocument()
   })
 
-  it('renders status as a colored pill', () => {
+  it('renders status as a colored badge with dot indicator', () => {
     render(<Inspector {...defaultProps} entry={mockEntry} content={mockContent} />)
-    const pill = screen.getByText('Active')
-    // Status is rendered as an inline pill with CSS variable-based styles
-    expect(pill).toHaveStyle({ borderRadius: '16px' })
+    const badge = screen.getByTestId('status-badge')
+    expect(badge).toHaveTextContent('Active')
+    expect(badge.className).toContain('rounded')
   })
 
   it('computes word count from content minus frontmatter and title', () => {
@@ -137,7 +137,7 @@ describe('Inspector', () => {
 
   it('shows "Add property" button as disabled placeholder', () => {
     render(<Inspector {...defaultProps} entry={mockEntry} content={mockContent} />)
-    const btn = screen.getByText('+ Add property')
+    const btn = screen.getByText('Add property')
     expect(btn).toBeDisabled()
   })
 
@@ -188,10 +188,7 @@ This is a test note with some words to count.
         entries={[mockEntry, referrerEntry]}
       />
     )
-    // Backlinks section is collapsed by default, but header with count is visible
-    expect(screen.getByText('Backlinks (1)')).toBeInTheDocument()
-    // Expand to see the backlink entry
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    expect(screen.getByText('Backlinks')).toBeInTheDocument()
     expect(screen.getByText('Referrer Note')).toBeInTheDocument()
   })
 
@@ -204,10 +201,8 @@ This is a test note with some words to count.
         entries={[mockEntry, { ...referrerEntry, outgoingLinks: [] }]}
       />
     )
-    // Initially no backlinks — section is hidden entirely
-    expect(screen.queryByTestId('backlinks-toggle')).not.toBeInTheDocument()
+    expect(screen.queryByText('Backlinks')).not.toBeInTheDocument()
 
-    // Rerender with updated outgoingLinks (simulates adding [[Test Project]] to referrer)
     rerender(
       <Inspector
         {...defaultProps}
@@ -216,8 +211,7 @@ This is a test note with some words to count.
         entries={[mockEntry, { ...referrerEntry, outgoingLinks: ['Test Project'] }]}
       />
     )
-    expect(screen.getByText('Backlinks (1)')).toBeInTheDocument()
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    expect(screen.getByText('Backlinks')).toBeInTheDocument()
     expect(screen.getByText('Referrer Note')).toBeInTheDocument()
   })
 
@@ -230,7 +224,7 @@ This is a test note with some words to count.
         entries={[mockEntry]}
       />
     )
-    expect(screen.queryByTestId('backlinks-toggle')).not.toBeInTheDocument()
+    expect(screen.queryByText('Backlinks')).not.toBeInTheDocument()
   })
 
   it('navigates when a backlink is clicked', () => {
@@ -244,7 +238,6 @@ This is a test note with some words to count.
         onNavigate={onNavigate}
       />
     )
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
     fireEvent.click(screen.getByText('Referrer Note'))
     expect(onNavigate).toHaveBeenCalledWith('Referrer Note')
   })
@@ -260,12 +253,11 @@ This is a test note with some words to count.
     )
     expect(screen.getByText('History')).toBeInTheDocument()
     expect(screen.getByText('a1b2c3d')).toBeInTheDocument()
-    expect(screen.getByText('Update test with latest changes')).toBeInTheDocument()
     expect(screen.getByText('e4f5g6h')).toBeInTheDocument()
     expect(screen.getByText('i7j8k9l')).toBeInTheDocument()
   })
 
-  it('renders commit hashes as clickable buttons', () => {
+  it('renders commit entries as clickable buttons', () => {
     const onViewCommitDiff = vi.fn()
     render(
       <Inspector
@@ -277,25 +269,13 @@ This is a test note with some words to count.
       />
     )
     const hashBtn = screen.getByText('a1b2c3d')
-    expect(hashBtn.tagName).toBe('BUTTON')
-    hashBtn.click()
+    const button = hashBtn.closest('button')!
+    expect(button.tagName).toBe('BUTTON')
+    button.click()
     expect(onViewCommitDiff).toHaveBeenCalledWith('a1b2c3d4e5f6a7b8')
   })
 
-  it('shows author name in commit rows', () => {
-    render(
-      <Inspector
-        {...defaultProps}
-        entry={mockEntry}
-        content={mockContent}
-        gitHistory={mockGitHistory}
-      />
-    )
-    const authors = screen.getAllByText('Luca Rossi')
-    expect(authors.length).toBeGreaterThan(0)
-  })
-
-  it('shows "No revision history" when no commits', () => {
+  it('hides history section when no commits', () => {
     render(
       <Inspector
         {...defaultProps}
@@ -304,7 +284,7 @@ This is a test note with some words to count.
         gitHistory={[]}
       />
     )
-    expect(screen.getByText('No revision history')).toBeInTheDocument()
+    expect(screen.queryByText('History')).not.toBeInTheDocument()
   })
 
   it('shows separate Info section with read-only metadata', () => {
@@ -639,4 +619,96 @@ Status: Active
       expect(screen.queryByText('Referenced by')).not.toBeInTheDocument()
     })
   })
+
+  describe('frontmatter state handling', () => {
+    const noFrontmatterEntry: VaultEntry = {
+      ...mockEntry,
+      path: '/vault/plain-note.md',
+      filename: 'plain-note.md',
+      title: 'plain-note',
+      isA: null,
+    }
+
+    it('shows "Initialize properties" button when note has no frontmatter', () => {
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content="# Just a plain note\n\nNo frontmatter here."
+          onInitializeProperties={vi.fn()}
+        />
+      )
+      expect(screen.getByText('Initialize properties')).toBeInTheDocument()
+      expect(screen.queryByText('Type')).not.toBeInTheDocument()
+    })
+
+    it('shows "Initialize properties" button when frontmatter is empty', () => {
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content="---\n---\n# Note with empty frontmatter"
+          onInitializeProperties={vi.fn()}
+        />
+      )
+      expect(screen.getByText('Initialize properties')).toBeInTheDocument()
+    })
+
+    it('calls onInitializeProperties when button is clicked', () => {
+      const onInit = vi.fn()
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content="# Plain note"
+          onInitializeProperties={onInit}
+        />
+      )
+      fireEvent.click(screen.getByText('Initialize properties'))
+      expect(onInit).toHaveBeenCalledWith('/vault/plain-note.md')
+    })
+
+    it('shows invalid frontmatter notice with fix button', () => {
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content={'---\n{broken yaml\n---\nBody'}
+          onToggleRawEditor={vi.fn()}
+        />
+      )
+      expect(screen.getByText('Invalid properties')).toBeInTheDocument()
+      expect(screen.getByText('Fix in editor')).toBeInTheDocument()
+    })
+
+    it('calls onToggleRawEditor when fix button is clicked', () => {
+      const onToggle = vi.fn()
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content={'---\n{broken yaml\n---\nBody'}
+          onToggleRawEditor={onToggle}
+        />
+      )
+      fireEvent.click(screen.getByText('Fix in editor'))
+      expect(onToggle).toHaveBeenCalledOnce()
+    })
+
+    it('still shows backlinks and history for notes without frontmatter', () => {
+      render(
+        <Inspector
+          {...defaultProps}
+          entry={noFrontmatterEntry}
+          content="# Plain note"
+          entries={[noFrontmatterEntry, { ...referrerEntry, outgoingLinks: ['plain-note'] }]}
+          gitHistory={mockGitHistory}
+          onInitializeProperties={vi.fn()}
+        />
+      )
+      expect(screen.getByText('Initialize properties')).toBeInTheDocument()
+      expect(screen.getByText('Backlinks')).toBeInTheDocument()
+      expect(screen.getByText('History')).toBeInTheDocument()
+    })
+  })
 })

src/components/Inspector.tsx

@@ -2,8 +2,9 @@ import { useMemo, useCallback } from 'react'
 import { useDragRegion } from '../hooks/useDragRegion'
 import type { VaultEntry, GitCommit } from '../types'
 import { cn } from '@/lib/utils'
-import { SlidersHorizontal, X } from '@phosphor-icons/react'
-import { parseFrontmatter } from '../utils/frontmatter'
+import { SlidersHorizontal, X, Sparkle, WarningCircle, PencilSimple } from '@phosphor-icons/react'
+import { Separator } from './ui/separator'
+import { parseFrontmatter, detectFrontmatterState } from '../utils/frontmatter'
 import { DynamicPropertiesPanel } from './DynamicPropertiesPanel'
 import { DynamicRelationshipsPanel, BacklinksPanel, ReferencedByPanel, GitHistoryPanel, InstancesPanel } from './InspectorPanels'
 import { wikilinkTarget } from '../utils/wikilink'
@@ -24,6 +25,17 @@ interface InspectorProps {
   onDeleteProperty?: (path: string, key: string) => Promise<void>
   onAddProperty?: (path: string, key: string, value: FrontmatterValue) => Promise<void>
   onCreateAndOpenNote?: (title: string) => Promise<boolean>
+  onInitializeProperties?: (path: string) => void
+  onToggleRawEditor?: () => void
+}
+
+function targetMatchesEntry(target: string, entryPath: string, matchTargets: Set<string>): boolean {
+  if (matchTargets.has(target)) return true
+  const lastSegment = target.split('/').pop() ?? ''
+  if (matchTargets.has(lastSegment)) return true
+  // Path-suffix match: "projects/alpha" matches entry path ending with "/projects/alpha.md"
+  if (target.includes('/') && entryPath.toLowerCase().endsWith('/' + target.toLowerCase() + '.md')) return true
+  return false
 }
 
 function useBacklinks(
@@ -36,7 +48,6 @@ function useBacklinks(
     const matchTargets = new Set([
       entry.title, ...entry.aliases,
       entry.filename.replace(/\.md$/, ''),
-      entry.path.replace(/^.*\/Laputa\//, '').replace(/\.md$/, ''),
     ])
 
     const referencedByPaths = new Set(referencedBy.map((item) => item.entry.path))
@@ -45,9 +56,7 @@ function useBacklinks(
       .filter((e) => {
         if (e.path === entry.path) return false
         if (referencedByPaths.has(e.path)) return false
-        return e.outgoingLinks.some((target) =>
-          matchTargets.has(target) || matchTargets.has(target.split('/').pop() ?? '')
-        )
+        return e.outgoingLinks.some((target) => targetMatchesEntry(target, entry.path, matchTargets))
       })
       .map((e) => ({
         entry: e,
@@ -67,9 +76,8 @@ function useReferencedBy(entry: VaultEntry | null, entries: VaultEntry[]): Refer
   return useMemo(() => {
     if (!entry) return []
 
-    const pathStem = entry.path.replace(/^.*\/Laputa\//, '').replace(/\.md$/, '')
     const filenameStem = entry.filename.replace(/\.md$/, '')
-    const matchTargets = new Set([pathStem, filenameStem, entry.title, ...entry.aliases])
+    const matchTargets = new Set([filenameStem, entry.title, ...entry.aliases])
 
     const results: ReferencedByItem[] = []
 
@@ -89,16 +97,16 @@ function useReferencedBy(entry: VaultEntry | null, entries: VaultEntry[]): Refer
 function InspectorHeader({ collapsed, onToggle }: { collapsed: boolean; onToggle: () => void }) {
   const { onMouseDown } = useDragRegion()
   return (
-    <div className="flex shrink-0 items-center border-b border-border" style={{ height: 45, padding: '6px 12px', gap: 8, cursor: 'default' }} onMouseDown={onMouseDown}>
+    <div className="flex shrink-0 items-center border-b border-border" style={{ height: 52, padding: '6px 12px', gap: 8, cursor: 'default' }} onMouseDown={onMouseDown}>
       {collapsed ? (
-        <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground" onClick={onToggle}>
+        <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground" onClick={onToggle} title="Properties (⌘⇧I)">
           <SlidersHorizontal size={16} />
         </button>
       ) : (
         <>
           <SlidersHorizontal size={16} className="shrink-0 text-muted-foreground" />
           <span className="flex-1 text-muted-foreground" style={{ fontSize: 13, fontWeight: 600 }}>Properties</span>
-          <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground" onClick={onToggle}>
+          <button className="shrink-0 border-none bg-transparent p-1 text-muted-foreground cursor-pointer hover:text-foreground" onClick={onToggle} title="Close Properties (⌘⇧I)">
             <X size={16} />
           </button>
         </>
@@ -113,13 +121,46 @@ function EmptyInspector() {
   )
 }
 
+function InitializePropertiesPrompt({ onClick }: { onClick: () => void }) {
+  return (
+    <div className="flex flex-col items-center gap-3 rounded-lg border border-dashed border-border px-4 py-6">
+      <Sparkle size={24} className="text-muted-foreground" />
+      <p className="m-0 text-center text-[13px] text-muted-foreground">This note has no properties yet</p>
+      <button
+        className="inline-flex cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-3 py-1.5 text-[13px] font-medium text-foreground transition-colors hover:bg-muted"
+        onClick={onClick}
+      >
+        Initialize properties
+      </button>
+    </div>
+  )
+}
+
+function InvalidFrontmatterNotice({ onFix }: { onFix: () => void }) {
+  return (
+    <div className="flex flex-col items-center gap-3 rounded-lg border border-dashed border-destructive/40 bg-destructive/5 px-4 py-6">
+      <WarningCircle size={24} className="text-destructive" />
+      <p className="m-0 text-center text-[13px] text-muted-foreground">Invalid properties</p>
+      <button
+        className="inline-flex cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-3 py-1.5 text-[13px] font-medium text-foreground transition-colors hover:bg-muted"
+        onClick={onFix}
+      >
+        <PencilSimple size={14} />
+        Fix in editor
+      </button>
+    </div>
+  )
+}
+
 export function Inspector({
   collapsed, onToggle, entry, content, entries, gitHistory, onNavigate,
   onViewCommitDiff, onUpdateFrontmatter, onDeleteProperty, onAddProperty, onCreateAndOpenNote,
+  onInitializeProperties, onToggleRawEditor,
 }: InspectorProps) {
   const referencedBy = useReferencedBy(entry, entries)
   const backlinks = useBacklinks(entry, entries, referencedBy)
   const frontmatter = useMemo(() => parseFrontmatter(content), [content])
+  const fmState = useMemo(() => detectFrontmatterState(content), [content])
   const typeEntryMap = useMemo(() => {
     const map: Record<string, VaultEntry> = {}
     for (const e of entries) { if (e.isA === 'Type') map[e.title] = e }
@@ -145,24 +186,34 @@ export function Inspector({
         <div className="flex flex-1 flex-col gap-4 overflow-y-auto p-3">
           {entry ? (
             <>
-              <DynamicPropertiesPanel
-                entry={entry} content={content} frontmatter={frontmatter}
-                entries={entries}
-                onUpdateProperty={onUpdateFrontmatter ? handleUpdateProperty : undefined}
-                onDeleteProperty={onDeleteProperty ? handleDeleteProperty : undefined}
-                onAddProperty={onAddProperty ? handleAddProperty : undefined}
-                onNavigate={onNavigate}
-              />
-              <DynamicRelationshipsPanel
-                frontmatter={frontmatter} entries={entries} typeEntryMap={typeEntryMap} onNavigate={onNavigate}
-                onAddProperty={onAddProperty ? handleAddProperty : undefined}
-                onUpdateProperty={onUpdateFrontmatter ? handleUpdateProperty : undefined}
-                onDeleteProperty={onDeleteProperty ? handleDeleteProperty : undefined}
-                onCreateAndOpenNote={onCreateAndOpenNote}
-              />
-              <InstancesPanel entry={entry} entries={entries} typeEntryMap={typeEntryMap} onNavigate={onNavigate} />
-              <ReferencedByPanel items={referencedBy} typeEntryMap={typeEntryMap} onNavigate={onNavigate} />
-              <BacklinksPanel backlinks={backlinks} typeEntryMap={typeEntryMap} onNavigate={onNavigate} />
+              {fmState === 'valid' ? (
+                <>
+                  <DynamicPropertiesPanel
+                    entry={entry} content={content} frontmatter={frontmatter}
+                    entries={entries}
+                    onUpdateProperty={onUpdateFrontmatter ? handleUpdateProperty : undefined}
+                    onDeleteProperty={onDeleteProperty ? handleDeleteProperty : undefined}
+                    onAddProperty={onAddProperty ? handleAddProperty : undefined}
+                    onNavigate={onNavigate}
+                  />
+                  <DynamicRelationshipsPanel
+                    frontmatter={frontmatter} entries={entries} typeEntryMap={typeEntryMap} onNavigate={onNavigate}
+                    onAddProperty={onAddProperty ? handleAddProperty : undefined}
+                    onUpdateProperty={onUpdateFrontmatter ? handleUpdateProperty : undefined}
+                    onDeleteProperty={onDeleteProperty ? handleDeleteProperty : undefined}
+                    onCreateAndOpenNote={onCreateAndOpenNote}
+                  />
+                  <InstancesPanel entry={entry} entries={entries} typeEntryMap={typeEntryMap} onNavigate={onNavigate} />
+                  <ReferencedByPanel items={referencedBy} typeEntryMap={typeEntryMap} onNavigate={onNavigate} />
+                </>
+              ) : fmState === 'invalid' ? (
+                onToggleRawEditor && <InvalidFrontmatterNotice onFix={onToggleRawEditor} />
+              ) : (
+                onInitializeProperties && <InitializePropertiesPrompt onClick={() => onInitializeProperties(entry.path)} />
+              )}
+              {backlinks.length > 0 && <Separator />}
+              <BacklinksPanel backlinks={backlinks} onNavigate={onNavigate} />
+              {gitHistory.length > 0 && <Separator />}
               <GitHistoryPanel commits={gitHistory} onViewCommitDiff={onViewCommitDiff} />
             </>
           ) : (

src/components/InspectorPanels.test.tsx

@@ -632,7 +632,7 @@ describe('BacklinksPanel', () => {
   })
 
   it('renders nothing when empty', () => {
-    const { container } = render(<BacklinksPanel typeEntryMap={{}} backlinks={[]} onNavigate={onNavigate} />)
+    const { container } = render(<BacklinksPanel backlinks={[]} onNavigate={onNavigate} />)
     expect(container.innerHTML).toBe('')
   })
 
@@ -641,23 +641,16 @@ describe('BacklinksPanel', () => {
     { entry: makeEntry({ title: 'Another Note', isA: 'Project', path: '/vault/project/another.md' }), context: null },
   ]
 
-  it('renders collapsed by default with count badge', () => {
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={twoBacklinks} onNavigate={onNavigate} />)
-    expect(screen.getByText('Backlinks (2)')).toBeInTheDocument()
-    expect(screen.queryByText('Referencing Note')).not.toBeInTheDocument()
-  })
-
-  it('expands to show backlink entries when toggle clicked', () => {
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={twoBacklinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+  it('renders header and all backlinks immediately (no collapse)', () => {
+    render(<BacklinksPanel backlinks={twoBacklinks} onNavigate={onNavigate} />)
+    expect(screen.getByText('Backlinks')).toBeInTheDocument()
     expect(screen.getByText('Referencing Note')).toBeInTheDocument()
     expect(screen.getByText('Another Note')).toBeInTheDocument()
   })
 
   it('navigates when clicking backlink', () => {
     const backlinks = [{ entry: makeEntry({ title: 'Reference' }), context: null }]
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    render(<BacklinksPanel backlinks={backlinks} onNavigate={onNavigate} />)
     fireEvent.click(screen.getByText('Reference'))
     expect(onNavigate).toHaveBeenCalledWith('Reference')
   })
@@ -666,39 +659,26 @@ describe('BacklinksPanel', () => {
     const backlinks = [
       { entry: makeEntry({ title: 'Referencing Note' }), context: 'This references [[My Note]] in context.' },
     ]
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    render(<BacklinksPanel backlinks={backlinks} onNavigate={onNavigate} />)
     expect(screen.getByText('This references [[My Note]] in context.')).toBeInTheDocument()
   })
 
-  it('collapses when toggle clicked twice', () => {
-    const backlinks = [{ entry: makeEntry({ title: 'Note A' }), context: null }]
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
-    expect(screen.getByText('Note A')).toBeInTheDocument()
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
-    expect(screen.queryByText('Note A')).not.toBeInTheDocument()
-  })
-
   it('shows emoji icon before backlink title when entry has an emoji', () => {
     const backlinks = [{
       entry: makeEntry({ title: 'Starred Note', icon: '⭐' }),
       context: null,
     }]
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    render(<BacklinksPanel backlinks={backlinks} onNavigate={onNavigate} />)
     expect(screen.getByText('⭐')).toBeInTheDocument()
     expect(screen.getByText('Starred Note')).toBeInTheDocument()
   })
 
   it('does not show emoji when backlink entry has no icon', () => {
     const backlinks = [{ entry: makeEntry({ title: 'Plain Note' }), context: null }]
-    render(<BacklinksPanel typeEntryMap={{}} backlinks={backlinks} onNavigate={onNavigate} />)
-    fireEvent.click(screen.getByTestId('backlinks-toggle'))
+    render(<BacklinksPanel backlinks={backlinks} onNavigate={onNavigate} />)
     expect(screen.getByText('Plain Note')).toBeInTheDocument()
     const btn = screen.getByText('Plain Note').closest('button')
     const spans = btn?.querySelectorAll('span.shrink-0')
-    // No emoji span should exist (only possible shrink-0 spans are trash icon, not emoji)
     const emojiSpans = Array.from(spans ?? []).filter(s => /[\p{Emoji_Presentation}]/u.test(s.textContent ?? ''))
     expect(emojiSpans).toHaveLength(0)
   })
@@ -764,12 +744,12 @@ describe('GitHistoryPanel', () => {
     vi.clearAllMocks()
   })
 
-  it('shows "No revision history" when empty', () => {
-    render(<GitHistoryPanel commits={[]} />)
-    expect(screen.getByText('No revision history')).toBeInTheDocument()
+  it('renders nothing when empty', () => {
+    const { container } = render(<GitHistoryPanel commits={[]} />)
+    expect(container.innerHTML).toBe('')
   })
 
-  it('renders commit entries', () => {
+  it('renders commit entries with hash and message', () => {
     const commits: GitCommit[] = [
       { hash: 'abc1234567890', shortHash: 'abc1234', message: 'Initial commit', author: 'luca', date: Math.floor(Date.now() / 1000) - 3600 },
       { hash: 'def4567890123', shortHash: 'def4567', message: 'Fix bug', author: 'jane', date: Math.floor(Date.now() / 1000) - 86400 * 2 },
@@ -777,13 +757,9 @@ describe('GitHistoryPanel', () => {
     render(<GitHistoryPanel commits={commits} onViewCommitDiff={onViewCommitDiff} />)
     expect(screen.getByText('abc1234')).toBeInTheDocument()
     expect(screen.getByText('def4567')).toBeInTheDocument()
-    expect(screen.getByText('Initial commit')).toBeInTheDocument()
-    expect(screen.getByText('Fix bug')).toBeInTheDocument()
-    expect(screen.getByText('luca')).toBeInTheDocument()
-    expect(screen.getByText('jane')).toBeInTheDocument()
   })
 
-  it('calls onViewCommitDiff when clicking commit hash', () => {
+  it('calls onViewCommitDiff when clicking commit entry', () => {
     const commits: GitCommit[] = [
       { hash: 'abc1234567890', shortHash: 'abc1234', message: 'test', author: '', date: Math.floor(Date.now() / 1000) },
     ]

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,44 +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>
       </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'
@@ -208,6 +209,20 @@ describe('NoteList', () => {
     expect(screen.queryByText('Matteo Cellini')).not.toBeInTheDocument()
   })
 
+  it('passes selected type when creating note from type section', () => {
+    const onCreate = vi.fn()
+    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={{ kind: 'sectionGroup', type: 'Project' }} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={onCreate} />)
+    fireEvent.click(screen.getByTitle('Create new note'))
+    expect(onCreate).toHaveBeenCalledWith('Project')
+  })
+
+  it('passes undefined type when creating note from All Notes', () => {
+    const onCreate = vi.fn()
+    render(<NoteList {...defaultFilterProps} entries={mockEntries} selection={allSelection} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={onCreate} />)
+    fireEvent.click(screen.getByTitle('Create new note'))
+    expect(onCreate).toHaveBeenCalledWith(undefined)
+  })
+
   it('shows entity pinned at top with grouped children', () => {
     render(
       <NoteList {...defaultFilterProps} entries={mockEntries} selection={{ kind: 'entity', entry: mockEntries[0] }} selectedNote={null} onSelectNote={noopSelect} onReplaceActiveTab={noopReplace} onCreateNote={vi.fn()} />
@@ -867,7 +882,7 @@ describe('NoteList — virtual list with large datasets', () => {
     expect(screen.getByText('Note 499')).toBeInTheDocument()
   })
 
-  it('search filters large dataset correctly', () => {
+  it('search filters large dataset correctly', { timeout: 15000 }, () => {
     const entries = [
       makeIndexedEntry(0, { title: 'Alpha Strategy' }),
       ...Array.from({ length: 998 }, (_, i) => makeIndexedEntry(i + 1, { title: `Filler Note ${i + 1}` })),
@@ -1439,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'
@@ -32,7 +32,7 @@ interface NoteListProps {
   sidebarCollapsed?: boolean
   onSelectNote: (entry: VaultEntry) => void
   onReplaceActiveTab: (entry: VaultEntry) => void
-  onCreateNote: () => void
+  onCreateNote: (type?: string) => void
   onBulkArchive?: (paths: string[]) => void
   onBulkTrash?: (paths: string[]) => void
   onBulkRestore?: (paths: string[]) => void
@@ -41,20 +41,22 @@ 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'
+  const isFolderView = selection.kind === 'folder'
   const isInboxView = selection.kind === 'filter' && selection.filter === 'inbox'
   const isAllNotesView = selection.kind === 'filter' && selection.filter === 'all'
-  const showFilterPills = isSectionGroup || isAllNotesView
+  const showFilterPills = isSectionGroup || isFolderView || isAllNotesView
   const subFilter = showFilterPills ? noteListFilter : undefined
 
   const filterCounts = useMemo(
-    () => isSectionGroup ? countByFilter(entries, selection.type) : isAllNotesView ? countAllByFilter(entries) : { open: 0, archived: 0, trashed: 0 },
-    [entries, isSectionGroup, isAllNotesView, selection],
+    () => isSectionGroup ? countByFilter(entries, selection.type) : (isAllNotesView || isFolderView) ? countAllByFilter(entries) : { open: 0, archived: 0, trashed: 0 },
+    [entries, isSectionGroup, isAllNotesView, isFolderView, selection],
   )
 
   const inboxCounts = useMemo(
@@ -67,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,
@@ -96,15 +98,16 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
     <NoteItem key={entry.path} entry={entry} isSelected={selectedNote?.path === entry.path} isMultiSelected={multiSelect.selectedPaths.has(entry.path)} isHighlighted={entry.path === noteListKeyboard.highlightedPath} noteStatus={resolvedGetNoteStatus(entry.path)} typeEntryMap={typeEntryMap} onClickNote={handleClickNote} onPrefetch={prefetchNoteContent} />
   ), [selectedNote?.path, handleClickNote, typeEntryMap, resolvedGetNoteStatus, multiSelect.selectedPaths, noteListKeyboard.highlightedPath])
 
+  const handleCreateNote = useCallback(() => {
+    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%' }}>
-      <NoteListHeader title={title} typeDocument={typeDocument} isEntityView={isEntityView} isTrashView={isTrashView} trashCount={searched.length} listSort={listSort} listDirection={listDirection} customProperties={customProperties} sidebarCollapsed={sidebarCollapsed} searchVisible={searchVisible} search={search} onSortChange={handleSortChange} onCreateNote={onCreateNote} onOpenType={onReplaceActiveTab} onToggleSearch={toggleSearch} onSearchChange={setSearch} onEmptyTrash={onEmptyTrash} />
-      {showFilterPills && <FilterPills active={noteListFilter} counts={filterCounts} onChange={onNoteListFilterChange} />}
-      {isInboxView && onInboxPeriodChange && <InboxFilterPills active={inboxPeriod} counts={inboxCounts} onChange={onInboxPeriodChange} />}
-      <div className="flex flex-1 flex-col overflow-hidden outline-none" style={{ minHeight: 0 }} tabIndex={0} onKeyDown={noteListKeyboard.handleKeyDown} onFocus={noteListKeyboard.handleFocus} data-testid="note-list-container">
+      <NoteListHeader title={title} typeDocument={typeDocument} isEntityView={isEntityView} isTrashView={isTrashView} trashCount={searched.length} listSort={listSort} listDirection={listDirection} customProperties={customProperties} sidebarCollapsed={sidebarCollapsed} searchVisible={searchVisible} search={search} onSortChange={handleSortChange} onCreateNote={handleCreateNote} onOpenType={onReplaceActiveTab} onToggleSearch={toggleSearch} onSearchChange={setSearch} onEmptyTrash={onEmptyTrash} />
+      <div className="relative flex flex-1 flex-col overflow-hidden outline-none" style={{ minHeight: 0 }} tabIndex={0} onKeyDown={noteListKeyboard.handleKeyDown} onFocus={noteListKeyboard.handleFocus} data-testid="note-list-container">
         <div className="flex-1 overflow-hidden" style={{ minHeight: 0 }}>
           {entitySelection ? (
             <EntityView entity={entitySelection.entry} groups={searchedGroups} query={query} collapsedGroups={collapsedGroups} sortPrefs={sortPrefs} onToggleGroup={toggleGroup} onSortChange={handleSortChange} renderItem={renderItem} typeEntryMap={typeEntryMap} onClickNote={handleClickNote} />
@@ -113,6 +116,8 @@ function NoteListInner({ entries, selection, selectedNote, noteListFilter, onNot
           )}
         </div>
         {isChangesView && deletedCount > 0 && <DeletedNotesBanner count={deletedCount} />}
+        {showFilterPills && <FilterPills active={noteListFilter} counts={filterCounts} onChange={onNoteListFilterChange} position="bottom" />}
+        {isInboxView && onInboxPeriodChange && <InboxFilterPills active={inboxPeriod} counts={inboxCounts} onChange={onInboxPeriodChange} position="bottom" />}
       </div>
       {multiSelect.isMultiSelecting && (
         <BulkActionBar count={multiSelect.selectedPaths.size} isTrashView={isTrashView} isArchivedView={isArchivedView} onArchive={handleBulkArchive} onTrash={handleBulkTrash} onRestore={handleBulkRestore} onDeletePermanently={handleBulkDeletePermanently} onUnarchive={handleBulkUnarchive} onClear={multiSelect.clear} />

src/components/PropertyValueCells.tsx

@@ -5,7 +5,7 @@ import { EditableValue, TagPillList, UrlValue } from './EditableValue'
 import { isUrlValue } from '../utils/url'
 import { Calendar } from '@/components/ui/calendar'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
-import { CalendarIcon, XIcon } from 'lucide-react'
+import { XIcon } from 'lucide-react'
 import { isValidCssColor } from '../utils/colorUtils'
 import {
   type PropertyDisplayMode,
@@ -14,7 +14,8 @@ import {
   DISPLAY_MODE_OPTIONS,
   DISPLAY_MODE_ICONS,
 } from '../utils/propertyTypes'
-import { StatusPill, StatusDropdown } from './StatusDropdown'
+import { StatusDropdown } from './StatusDropdown'
+import { getStatusStyle } from '../utils/statusStyles'
 import { TagsDropdown } from './TagsDropdown'
 import { getTagStyle } from '../utils/tagStyles'
 import { ColorEditableValue } from './ColorInput'
@@ -37,14 +38,17 @@ function StatusValue({ propKey, value, isEditing, vaultStatuses, onSave, onStart
   onSave: (key: string, value: string) => void; onStartEdit: (key: string | null) => void
 }) {
   const statusStr = String(value)
+  const style = getStatusStyle(statusStr)
   return (
     <span className="relative inline-flex min-w-0 items-center">
       <span
-        className="cursor-pointer transition-opacity hover:opacity-80"
+        className="inline-flex h-6 cursor-pointer items-center gap-1.5 rounded-md px-2 text-[12px] font-medium transition-opacity hover:opacity-80"
+        style={{ backgroundColor: style.bg, color: style.color }}
         onClick={() => onStartEdit(propKey)}
         data-testid="status-badge"
       >
-        <StatusPill status={statusStr} />
+        <span className="inline-block size-1.5 shrink-0 rounded-full" style={{ backgroundColor: style.color }} />
+        {statusStr}
       </span>
       {isEditing && (
         <StatusDropdown
@@ -79,18 +83,15 @@ function TagsValue({ propKey, value, isEditing, vaultTags, onSave, onStartEdit }
         return (
           <span
             key={tag}
-            className="group/tag relative inline-flex items-center overflow-hidden rounded-full"
-            style={{ backgroundColor: style.bg, padding: '1px 6px', maxWidth: 120 }}
+            className="group/tag relative inline-flex h-6 items-center overflow-hidden rounded-md"
+            style={{ backgroundColor: style.bg, padding: '0 8px', maxWidth: 120 }}
           >
             <span
               className="transition-[max-width] duration-150 group-hover/tag:[mask-image:linear-gradient(to_right,black_60%,transparent_100%)]"
               style={{
                 color: style.color,
-                fontFamily: "'IBM Plex Mono', monospace",
-                fontSize: 10,
-                fontWeight: 600,
-                letterSpacing: '0',
-                textTransform: 'uppercase' as const,
+                fontSize: 12,
+                fontWeight: 500,
                 overflow: 'hidden',
                 whiteSpace: 'nowrap' as const,
               }}
@@ -99,7 +100,7 @@ function TagsValue({ propKey, value, isEditing, vaultTags, onSave, onStartEdit }
             </span>
             <button
               className="ml-0.5 max-w-0 overflow-hidden border-none bg-transparent p-0 leading-none opacity-0 transition-all duration-150 group-hover/tag:max-w-[14px] group-hover/tag:opacity-100"
-              style={{ color: style.color, fontSize: 10, flexShrink: 0 }}
+              style={{ color: style.color, fontSize: 11, flexShrink: 0 }}
               onClick={() => handleRemove(tag)}
               title={`Remove ${tag}`}
             >
@@ -109,7 +110,8 @@ function TagsValue({ propKey, value, isEditing, vaultTags, onSave, onStartEdit }
         )
       })}
       <button
-        className="inline-flex size-5 shrink-0 items-center justify-center rounded-full border border-dashed border-muted-foreground bg-transparent text-[10px] text-muted-foreground transition-colors hover:border-foreground hover:text-foreground"
+        className="inline-flex h-6 shrink-0 items-center justify-center rounded-md border-none bg-muted text-[12px] font-medium text-muted-foreground transition-colors hover:bg-accent hover:text-foreground"
+        style={{ padding: '0 8px' }}
         onClick={() => onStartEdit(propKey)}
         title="Add tag"
         data-testid="tags-add-button"
@@ -128,13 +130,15 @@ function TagsValue({ propKey, value, isEditing, vaultTags, onSave, onStartEdit }
 
 function BooleanToggle({ value, onToggle }: { value: boolean; onToggle: () => void }) {
   return (
-    <button
-      className="rounded border border-border bg-transparent px-2 py-0.5 text-xs text-secondary-foreground transition-colors hover:bg-muted"
-      onClick={onToggle}
-      data-testid="boolean-toggle"
-    >
-      {value ? '\u2713 Yes' : '\u2717 No'}
-    </button>
+    <label className="inline-flex h-6 cursor-pointer items-center gap-1.5" data-testid="boolean-toggle">
+      <input
+        type="checkbox"
+        checked={value}
+        onChange={onToggle}
+        className="size-3.5 cursor-pointer accent-primary"
+      />
+      <span className="text-[12px] text-secondary-foreground">{value ? 'Yes' : 'No'}</span>
+    </label>
   )
 }
 
@@ -160,11 +164,10 @@ function DateValue({ value, onSave }: {
     <Popover open={open} onOpenChange={setOpen}>
       <PopoverTrigger asChild>
         <button
-          className="inline-flex min-w-0 cursor-pointer items-center gap-1 rounded border-none bg-transparent px-1 py-0.5 text-right text-[12px] text-secondary-foreground transition-colors hover:bg-muted"
+          className={`inline-flex h-6 min-w-0 cursor-pointer items-center gap-1 border-none px-2 text-right text-[12px] font-medium transition-colors hover:opacity-80${formatted ? ' rounded-md bg-muted text-accent-foreground' : ' bg-transparent text-muted-foreground'}`}
           title={value}
           data-testid="date-display"
         >
-          <CalendarIcon className="size-3 shrink-0 text-muted-foreground" />
           <span className={`min-w-0 truncate${!formatted ? ' text-muted-foreground' : ''}`}>{formatted || 'Pick a date\u2026'}</span>
         </button>
       </PopoverTrigger>

src/components/PulseView.tsx

@@ -167,7 +167,7 @@ function DayGroup({ label, commits, onOpenNote }: {
         onClick={() => setCollapsed((v) => !v)}
       >
         <Chevron size={12} className="text-muted-foreground" />
-        <span className="text-[11px] font-semibold uppercase tracking-wider text-muted-foreground">
+        <span className="text-[11px] font-medium text-muted-foreground">
           {label}
         </span>
         <span className="text-[11px] text-muted-foreground">

src/components/RawEditorView.tsx

@@ -1,4 +1,5 @@
 import { useRef, useState, useCallback, useEffect, useMemo } from 'react'
+import { trackEvent } from '../lib/telemetry'
 import type { EditorView } from '@codemirror/view'
 import { preFilterWikilinks, deduplicateByPath, MIN_QUERY_LENGTH } from '../utils/wikilinkSuggestions'
 import { attachClickHandlers, enrichSuggestionItems } from '../utils/suggestionEnrichment'
@@ -21,6 +22,7 @@ export interface RawEditorViewProps {
   path: string
   entries: VaultEntry[]
   onContentChange: (path: string, content: string) => void
+  vaultPath?: string
   onSave: () => void
   /** Mutable ref updated on every keystroke with the latest doc string.
    *  Allows the parent to flush debounced content before unmount. */
@@ -37,7 +39,7 @@ function getCursorCoords(view: EditorView): { top: number; left: number } | null
   return { top: coords.bottom, left: coords.left }
 }
 
-export function RawEditorView({ content, path, entries, onContentChange, onSave, latestContentRef }: RawEditorViewProps) {
+export function RawEditorView({ content, path, entries, onContentChange, onSave, latestContentRef, vaultPath }: RawEditorViewProps) {
   const containerRef = useRef<HTMLDivElement>(null)
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const pathRef = useRef(path)
@@ -92,10 +94,10 @@ export function RawEditorView({ content, path, entries, onContentChange, onSave,
     const coords = getCursorCoords(view)
     if (!coords) { setAutocomplete(null); return }
     const candidates = preFilterWikilinks(baseItems, query)
-    const withHandlers = attachClickHandlers(candidates, (title: string) => insertWikilinkRef.current(title))
+    const withHandlers = attachClickHandlers(candidates, (title: string) => insertWikilinkRef.current(title), vaultPath ?? '')
     const items = enrichSuggestionItems(withHandlers, query, typeEntryMap)
     setAutocomplete({ caretTop: coords.top, caretLeft: coords.left, selectedIndex: 0, items })
-  }, [baseItems, typeEntryMap])
+  }, [baseItems, typeEntryMap, vaultPath])
 
   const handleSave = useCallback(() => {
     if (debounceRef.current) {
@@ -135,6 +137,7 @@ export function RawEditorView({ content, path, entries, onContentChange, onSave,
       changes: { from: 0, to: doc.length, insert: newText },
       selection: { anchor: newCursor },
     })
+    trackEvent('wikilink_inserted')
     setAutocomplete(null)
 
     if (debounceRef.current) clearTimeout(debounceRef.current)

src/components/RenameDetectedBanner.test.tsx

@@ -0,0 +1,41 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import { RenameDetectedBanner } from './RenameDetectedBanner'
+
+describe('RenameDetectedBanner', () => {
+  const renames = [
+    { old_path: 'old-note.md', new_path: 'new-note.md' },
+    { old_path: 'folder/draft.md', new_path: 'folder/published.md' },
+  ]
+
+  it('renders nothing when renames is empty', () => {
+    const { container } = render(
+      <RenameDetectedBanner renames={[]} onUpdate={vi.fn()} onDismiss={vi.fn()} />
+    )
+    expect(container.firstChild).toBeNull()
+  })
+
+  it('shows banner with rename count', () => {
+    render(<RenameDetectedBanner renames={renames} onUpdate={vi.fn()} onDismiss={vi.fn()} />)
+    expect(screen.getByText(/2 files? renamed/i)).toBeInTheDocument()
+  })
+
+  it('shows Update wikilinks button', () => {
+    render(<RenameDetectedBanner renames={renames} onUpdate={vi.fn()} onDismiss={vi.fn()} />)
+    expect(screen.getByText('Update wikilinks')).toBeInTheDocument()
+  })
+
+  it('calls onUpdate when Update button clicked', () => {
+    const onUpdate = vi.fn()
+    render(<RenameDetectedBanner renames={renames} onUpdate={onUpdate} onDismiss={vi.fn()} />)
+    fireEvent.click(screen.getByText('Update wikilinks'))
+    expect(onUpdate).toHaveBeenCalledOnce()
+  })
+
+  it('calls onDismiss when Ignore button clicked', () => {
+    const onDismiss = vi.fn()
+    render(<RenameDetectedBanner renames={renames} onUpdate={vi.fn()} onDismiss={onDismiss} />)
+    fireEvent.click(screen.getByText('Ignore'))
+    expect(onDismiss).toHaveBeenCalledOnce()
+  })
+})

src/components/RenameDetectedBanner.tsx

@@ -0,0 +1,38 @@
+import { ArrowsClockwise } from '@phosphor-icons/react'
+
+export interface DetectedRename {
+  old_path: string
+  new_path: string
+}
+
+interface RenameDetectedBannerProps {
+  renames: DetectedRename[]
+  onUpdate: () => void
+  onDismiss: () => void
+}
+
+export function RenameDetectedBanner({ renames, onUpdate, onDismiss }: RenameDetectedBannerProps) {
+  if (renames.length === 0) return null
+
+  const count = renames.length
+  return (
+    <div className="flex items-center gap-3 border-b border-border bg-accent/50 px-4 py-2 text-[13px]">
+      <ArrowsClockwise size={16} className="shrink-0 text-accent-foreground" />
+      <span className="flex-1 text-foreground">
+        {count} file{count !== 1 ? 's' : ''} renamed outside Laputa. Update wikilinks?
+      </span>
+      <button
+        className="shrink-0 cursor-pointer rounded-md bg-primary px-3 py-1 text-[12px] font-medium text-primary-foreground transition-colors hover:bg-primary/90"
+        onClick={onUpdate}
+      >
+        Update wikilinks
+      </button>
+      <button
+        className="shrink-0 cursor-pointer rounded-md border border-border bg-transparent px-3 py-1 text-[12px] font-medium text-muted-foreground transition-colors hover:bg-muted"
+        onClick={onDismiss}
+      >
+        Ignore
+      </button>
+    </div>
+  )
+}

src/components/ResizeHandle.tsx

@@ -67,7 +67,7 @@ export function ResizeHandle({ onResize }: ResizeHandleProps) {
 
   return (
     <div
-      className="-ml-1 w-1 shrink-0 cursor-col-resize bg-transparent transition-colors hover:bg-[var(--border)]"
+      className="relative z-10 -ml-1 w-1 shrink-0 self-stretch cursor-col-resize bg-transparent transition-colors hover:bg-[var(--border)]"
       onMouseDown={handleMouseDown}
     />
   )