diff --git a/docs/superpowers/plans/2026-08-05-mcp-server-overhaul.md b/docs/superpowers/plans/2026-08-05-mcp-server-overhaul.md
new file mode 100644
index 0000000..3da6a85
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-05-mcp-server-overhaul.md
@@ -0,0 +1,1630 @@
+# MCP Server Overhaul Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Turn Notefix's MCP server into a Markdown-native, group-aware notes API with a full note lifecycle (create/append/update/archive/trash/restore, create/list groups), JSON responses, and a Rust Markdown↔HTML converter that preserves Tiptap task lists.
+
+**Architecture:** Three layers inside `src-tauri/src/`. (1) A new pure `mdconv` module does Markdown↔HTML conversion with no knowledge of storage or MCP. (2) A redesigned `NoteStore` trait is the test seam: a real `StoreAccess` impl backed by SQLite + a `Fake` in-memory impl for tests. (3) The `call_tool` handler in `mcp.rs` orchestrates conversion, group resolution, status filtering, and JSON building on top of the trait. Content crosses the MCP boundary as Markdown; every list/get/search response is a JSON string in the tool's text block.
+
+**Tech Stack:** Rust (edition 2021), axum JSON-RPC, rusqlite (SQLite), serde_json. New crates: `comrak` (Markdown→HTML, GFM) and `htmd` (HTML→Markdown). Frontend unchanged (TypeScript/React/Tiptap).
+
+## Global Constraints
+
+- Rust edition **2021**; crate is `notefix_lib` under `src-tauri/`.
+- Rust tests run with: `cd src-tauri && cargo test`. A single test: `cargo test <name>`.
+- Formatting/lint gates: `cd src-tauri && cargo fmt` and `cargo clippy --all-targets -- -D warnings` must pass.
+- Frontend gates must stay green: from repo root `npx tsc --noEmit` and `npx vitest run`.
+- The MCP server is **desktop-only** and already hidden on mobile — do not add mobile UI or gating; no frontend changes are expected in this plan.
+- Notes are stored as **Tiptap HTML** in SQLite. There is **no** `content_type`/`format`/`isMarkdown` column and this plan adds none (no DB migration).
+- Tiptap task-list HTML format (canonical round-trip target, matches `src/markdown.ts`):
+  `<ul data-type="taskList"><li data-type="taskItem" data-checked="true|false">…</li></ul>`.
+- Note status is **derived**, never a column: `deleted_at.is_some()` → `"trashed"`; else `archived` → `"archived"`; else `"active"`.
+- `Store::save_note` upserts, but on an **existing** row its `ON CONFLICT` updates only `content`, `updated_at`, `dirty`. To change folder/archived/deleted you MUST use the dedicated methods (`set_folder`, `set_archived`, `trash_note`, `restore_note`). Never try to move/archive/trash a note by mutating a `Note` and calling `save_note`.
+- All JSON responses are returned as the tool result's `content[0].text` (a serialized JSON string), preserving the existing `{ "content": [{ "type": "text", "text": … }] }` envelope. Errors keep the existing `isError: true` text-content shape.
+- Response field names are **camelCase** (matches serde `rename_all = "camelCase"` and the TS types).
+
+---
+
+## File Structure
+
+- **Create** `src-tauri/src/mdconv.rs` — pure Markdown↔HTML conversion + helpers. One responsibility: format conversion. No storage/MCP imports.
+- **Modify** `src-tauri/src/mcp.rs` — redesigned `NoteStore` trait, rewritten `call_tool` handler, JSON builders, `StoreAccess` impl, `tool_defs`, resources handlers, and `#[cfg(test)]` module (`Fake` + handler tests).
+- **Modify** `src-tauri/src/lib.rs` — add `mod mdconv;` (single line; verify `apply(...)` call is unaffected).
+- **Modify** `src-tauri/Cargo.toml` — add `comrak` and `htmd` dependencies.
+- **Unchanged** `storage.rs`, `folders.rs`, `migrate.rs`, `commands.rs` (we consume their existing APIs), and all of `src/` (frontend).
+
+---
+
+## Task 1: Add Markdown conversion dependencies
+
+**Files:**
+- Modify: `src-tauri/Cargo.toml:20-43` (`[dependencies]`)
+
+**Interfaces:**
+- Produces: `comrak` and `htmd` crates available to the build.
+
+- [ ] **Step 1: Add the crates**
+
+Run from `src-tauri/`:
+
+```bash
+cargo add comrak htmd
+```
+
+This appends latest-compatible versions under `[dependencies]` and updates `Cargo.lock`.
+
+- [ ] **Step 2: Verify the project still builds**
+
+Run: `cd src-tauri && cargo build`
+Expected: builds successfully (downloads `comrak`/`htmd` and transitive deps).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src-tauri/Cargo.toml src-tauri/Cargo.lock
+git commit -m "build: add comrak + htmd for MCP markdown conversion"
+```
+
+---
+
+## Task 2: `mdconv` — core Markdown → HTML
+
+**Files:**
+- Create: `src-tauri/src/mdconv.rs`
+- Modify: `src-tauri/src/lib.rs` (add `mod mdconv;` next to the other `mod` declarations)
+
+**Interfaces:**
+- Produces: `pub fn md_to_html(md: &str) -> String` — GFM Markdown → HTML. Task-list post-processing is added in Task 3; this task covers headings, emphasis, lists, code, blockquotes, tables, links, and hard line breaks.
+
+- [ ] **Step 1: Register the module**
+
+In `src-tauri/src/lib.rs`, add alongside the existing module declarations:
+
+```rust
+mod mdconv;
+```
+
+- [ ] **Step 2: Write the failing tests**
+
+Create `src-tauri/src/mdconv.rs` with:
+
+```rust
+//! Pure Markdown <-> HTML conversion for the MCP boundary. Notes are stored as
+//! Tiptap HTML; MCP speaks Markdown. Task-list handling mirrors `src/markdown.ts`
+//! so notes created via MCP are indistinguishable from app-created ones.
+
+use comrak::{markdown_to_html, ComrakOptions};
+
+/// Markdown (GFM) -> HTML. Hard line breaks on (matches the frontend's
+/// `marked` `breaks: true`), tables/strikethrough/autolinks/task items enabled.
+pub fn md_to_html(md: &str) -> String {
+    let mut opts = ComrakOptions::default();
+    opts.extension.table = true;
+    opts.extension.strikethrough = true;
+    opts.extension.tasklist = true;
+    opts.extension.autolink = true;
+    opts.render.hardbreaks = true;
+    let html = markdown_to_html(md, &opts);
+    html.trim().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn headings_and_emphasis() {
+        let h = md_to_html("# Title\n\nsome **bold** and *italic*");
+        assert!(h.contains("<h1>Title</h1>"), "got: {h}");
+        assert!(h.contains("<strong>bold</strong>"), "got: {h}");
+        assert!(h.contains("<em>italic</em>"), "got: {h}");
+    }
+
+    #[test]
+    fn bullet_and_ordered_lists() {
+        let h = md_to_html("- a\n- b");
+        assert!(h.contains("<ul>") && h.contains("<li>a</li>"), "got: {h}");
+        let o = md_to_html("1. one\n2. two");
+        assert!(o.contains("<ol>") && o.contains("<li>one</li>"), "got: {o}");
+    }
+
+    #[test]
+    fn code_and_tables() {
+        let c = md_to_html("`inline` and\n\n```\nblock\n```");
+        assert!(c.contains("<code>inline</code>"), "got: {c}");
+        assert!(c.contains("<pre>"), "got: {c}");
+        let t = md_to_html("| a | b |\n|---|---|\n| 1 | 2 |");
+        assert!(t.contains("<table>") && t.contains("<td>1</td>"), "got: {t}");
+    }
+}
+```
+
+- [ ] **Step 3: Run tests to verify they fail (then compile)**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests`
+Expected: the module fails to compile until `comrak` is wired (Task 1 done) — once it compiles, the three tests PASS. If any assertion fails on exact tag text, adjust the `assert!` substring to comrak's actual output (inspect the `got:` panic message); do NOT loosen a check to always-true.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests`
+Expected: PASS (3 tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src-tauri/src/mdconv.rs src-tauri/src/lib.rs
+git commit -m "feat(mcp): add mdconv module with core markdown->html"
+```
+
+---
+
+## Task 3: `mdconv` task-list fidelity (Markdown → HTML)
+
+**Files:**
+- Modify: `src-tauri/src/mdconv.rs`
+
+**Interfaces:**
+- Consumes: `md_to_html` (Task 2).
+- Produces: `md_to_html` output where GFM task items become Tiptap task lists — `comrak` emits `<li><input type="checkbox" ... /> text</li>` inside `<ul>`, which a private `tiptap_task_lists(html: &str) -> String` rewrites to `<ul data-type="taskList">` / `<li data-type="taskItem" data-checked="true|false">…</li>` with the `<input>` removed.
+
+- [ ] **Step 1: Write the failing test**
+
+Add to the `tests` module in `src-tauri/src/mdconv.rs`:
+
+```rust
+    #[test]
+    fn task_list_becomes_tiptap_structure() {
+        let h = md_to_html("- [ ] todo\n- [x] done");
+        // Tiptap task-list markers present:
+        assert!(h.contains(r#"data-type="taskList""#), "got: {h}");
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="false""#),
+            "got: {h}"
+        );
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="true""#),
+            "got: {h}"
+        );
+        // The raw checkbox <input> must be gone (Tiptap renders its own):
+        assert!(!h.contains("<input"), "input not stripped: {h}");
+        // Item text survives:
+        assert!(h.contains("todo") && h.contains("done"), "got: {h}");
+    }
+
+    #[test]
+    fn plain_list_is_not_marked_as_tasklist() {
+        let h = md_to_html("- a\n- b");
+        assert!(!h.contains("taskList"), "plain list wrongly tagged: {h}");
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests::task_list_becomes_tiptap_structure`
+Expected: FAIL (comrak output still has `<input>` and no `data-type`).
+
+- [ ] **Step 3: Implement the task-list rewrite**
+
+In `src-tauri/src/mdconv.rs`, add the helper and call it from `md_to_html` (replace the `let html = …; html.trim()…` tail):
+
+```rust
+use regex::Regex;
+use std::sync::OnceLock;
+
+/// Rewrite comrak's GFM checkbox output into Tiptap's task-list structure,
+/// mirroring `fixTaskLists` in `src/markdown.ts`. comrak emits, per item:
+///   <li><input type="checkbox" disabled="" /> text</li>   (unchecked)
+///   <li><input type="checkbox" checked="" disabled="" /> text</li> (checked)
+/// A <ul> containing any such <li> becomes data-type="taskList".
+fn tiptap_task_lists(html: &str) -> String {
+    static ITEM: OnceLock<Regex> = OnceLock::new();
+    // Capture optional `checked` and the remaining item body.
+    let item = ITEM.get_or_init(|| {
+        Regex::new(r#"(?is)<li>\s*<input([^>]*?)type="checkbox"([^>]*?)/?>\s*(.*?)</li>"#).unwrap()
+    });
+    let mut out = html.to_string();
+    // Only bother if there is at least one checkbox item.
+    if !out.contains(r#"type="checkbox""#) {
+        return out;
+    }
+    out = item
+        .replace_all(&out, |c: &regex::Captures| {
+            let attrs = format!("{}{}", &c[1], &c[2]);
+            let checked = attrs.contains("checked");
+            format!(
+                r#"<li data-type="taskItem" data-checked="{}">{}</li>"#,
+                if checked { "true" } else { "false" },
+                c[3].trim()
+            )
+        })
+        .to_string();
+    // Tag any <ul> that now contains a taskItem. comrak groups consecutive task
+    // items into one <ul>; mark every <ul> whose first item is a taskItem.
+    static LIST: OnceLock<Regex> = OnceLock::new();
+    let list = LIST.get_or_init(|| {
+        Regex::new(r#"(?is)<ul>(\s*<li data-type="taskItem")"#).unwrap()
+    });
+    out = list
+        .replace_all(&out, r#"<ul data-type="taskList">$1"#)
+        .to_string();
+    out
+}
+```
+
+Then change the end of `md_to_html` to post-process:
+
+```rust
+    let html = markdown_to_html(md, &opts);
+    tiptap_task_lists(&html).trim().to_string()
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests`
+Expected: PASS (all mdconv tests, incl. the two new ones). If the item regex misses due to comrak attribute ordering/whitespace, inspect the `got:` output and adjust the regex — the transformation, not the assertions, must change.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src-tauri/src/mdconv.rs
+git commit -m "feat(mcp): convert markdown task lists to Tiptap structure"
+```
+
+---
+
+## Task 4: `mdconv` — HTML → Markdown (incl. task items)
+
+**Files:**
+- Modify: `src-tauri/src/mdconv.rs`
+
+**Interfaces:**
+- Produces: `pub fn html_to_md(html: &str) -> String` — Tiptap HTML → GFM Markdown. Task items (`<li data-checked="…">`) become `- [x]` / `- [ ]`; other content (headings, emphasis, lists, code, links, tables) uses `htmd`. A private `pre_tasks(html)` converts Tiptap task items into GFM checkbox `<li>`s so `htmd`/GFM emits the right markers; if `htmd`'s installed version doesn't emit `- [ ]` from `<input type=checkbox>`, use the string fallback shown.
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to the `tests` module:
+
+```rust
+    #[test]
+    fn html_to_md_basic() {
+        let m = html_to_md("<h1>Title</h1><p>a <strong>b</strong></p>");
+        assert!(m.contains("# Title"), "got: {m}");
+        assert!(m.contains("**b**"), "got: {m}");
+    }
+
+    #[test]
+    fn html_to_md_task_items() {
+        let html = r#"<ul data-type="taskList"><li data-type="taskItem" data-checked="false">todo</li><li data-type="taskItem" data-checked="true">done</li></ul>"#;
+        let m = html_to_md(html);
+        assert!(m.contains("- [ ] todo"), "got: {m}");
+        assert!(m.contains("- [x] done"), "got: {m}");
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests::html_to_md_task_items`
+Expected: FAIL (`html_to_md` undefined).
+
+- [ ] **Step 3: Implement `html_to_md`**
+
+Add to `src-tauri/src/mdconv.rs`:
+
+```rust
+/// Rewrite Tiptap task items into GFM checkbox list items so the generic
+/// HTML->Markdown pass emits `- [ ]` / `- [x]`. Inverse of `tiptap_task_lists`.
+fn pre_tasks(html: &str) -> String {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    let re = RE.get_or_init(|| {
+        Regex::new(r#"(?is)<li[^>]*data-checked="(true|false)"[^>]*>(.*?)</li>"#).unwrap()
+    });
+    re.replace_all(html, |c: &regex::Captures| {
+        let mark = if &c[1] == "true" { "x" } else { " " };
+        format!(r#"<li><input type="checkbox"{}/> {}</li>"#,
+            if &c[1] == "true" { " checked=\"\"" } else { "" },
+            c[2].trim())
+    })
+    .to_string()
+    .replace("<ul data-type=\"taskList\">", "<ul>")
+}
+
+/// Tiptap HTML -> GFM Markdown.
+pub fn html_to_md(html: &str) -> String {
+    let prepared = pre_tasks(html);
+    htmd::convert(&prepared).unwrap_or_default().trim().to_string()
+}
+```
+
+Note: this task's tests are the contract. `htmd::convert` is the expected entry point; if the installed `htmd` version exposes a builder/options API instead, adapt this one function to call it (e.g. `HtmlToMarkdown::builder().build().convert(&prepared)`). If the installed `htmd`/GFM does NOT render `<input type=checkbox>` into `- [ ]`/`- [x]`, replace the body of `html_to_md` with a direct pre-pass that turns each task `<li>` into a literal line, e.g. map `data-checked="true"` → `- [x] {text}` and `"false"` → `- [ ] {text}` before converting the rest — the two `html_to_md_task_items` assertions must pass either way.
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests`
+Expected: PASS (all mdconv tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src-tauri/src/mdconv.rs
+git commit -m "feat(mcp): add html->markdown with task-item fidelity"
+```
+
+---
+
+## Task 5: `mdconv` round-trip + boundary helpers
+
+**Files:**
+- Modify: `src-tauri/src/mdconv.rs`
+
+**Interfaces:**
+- Consumes: `md_to_html`, `html_to_md`.
+- Produces:
+  - `pub fn title_from_html(html: &str) -> String` — first non-empty text line (for the `title` field).
+  - `pub fn wrap_plaintext(text: &str) -> String` — each line wrapped in `<p>…</p>` with HTML-escaping (for `format:"text"` writes; replaces the old `text_to_html`).
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to the `tests` module:
+
+```rust
+    #[test]
+    fn round_trip_preserves_structure() {
+        let md = "# Groceries\n\n- [ ] milk\n- [x] eggs";
+        let back = html_to_md(&md_to_html(md));
+        assert!(back.contains("# Groceries"), "got: {back}");
+        assert!(back.contains("- [ ] milk"), "got: {back}");
+        assert!(back.contains("- [x] eggs"), "got: {back}");
+    }
+
+    #[test]
+    fn title_from_html_takes_first_line() {
+        assert_eq!(title_from_html("<h1>Hello</h1><p>world</p>"), "Hello");
+        assert_eq!(title_from_html("<p></p><p>Second</p>"), "Second");
+        assert_eq!(title_from_html(""), "");
+    }
+
+    #[test]
+    fn wrap_plaintext_escapes_and_wraps() {
+        assert_eq!(wrap_plaintext("a\nb"), "<p>a</p><p>b</p>");
+        assert_eq!(wrap_plaintext("<b>&"), "<p>&lt;b&gt;&amp;</p>");
+        assert_eq!(wrap_plaintext(""), "<p></p>");
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests::title_from_html_takes_first_line`
+Expected: FAIL (`title_from_html` undefined).
+
+- [ ] **Step 3: Implement the helpers**
+
+Add to `src-tauri/src/mdconv.rs`:
+
+```rust
+/// First non-empty text line of an HTML fragment — used as a note's title.
+pub fn title_from_html(html: &str) -> String {
+    html_to_md(html)
+        .lines()
+        .map(|l| l.trim_start_matches(['#', '-', '*', '>', ' ']).trim())
+        .find(|l| !l.is_empty())
+        .unwrap_or("")
+        .to_string()
+}
+
+/// Wrap literal text as HTML paragraphs, escaping markup. For `format:"text"`.
+pub fn wrap_plaintext(text: &str) -> String {
+    if text.is_empty() {
+        return "<p></p>".to_string();
+    }
+    text.lines()
+        .map(|l| {
+            format!(
+                "<p>{}</p>",
+                l.replace('&', "&amp;")
+                    .replace('<', "&lt;")
+                    .replace('>', "&gt;")
+            )
+        })
+        .collect()
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mdconv::tests`
+Expected: PASS (all mdconv tests). If `title_from_html` returns a stray markdown marker for some input, tighten the `trim_start_matches` set — the assertions define correct output.
+
+- [ ] **Step 5: Run fmt + commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mdconv.rs
+git commit -m "feat(mcp): add title + plaintext helpers and round-trip tests"
+```
+
+---
+
+## Task 6: Redesign the `NoteStore` trait (+ `Fake` + `StoreAccess`)
+
+This task replaces the old `NoteAccess` trait (5 text-only methods) with a data-oriented `NoteStore` trait that returns `Note`/`Folder` structs and exposes the exact mutation primitives the handler needs. It updates the real `StoreAccess` impl and the test `Fake`. The `call_tool`/`handle_rpc` rewrite happens in Tasks 8–11; to keep this task compiling, `call_tool` is temporarily rewired to the new trait with its existing behavior preserved only enough to build (the read tools are reimplemented in Task 8).
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (trait at `:5-11`, `StoreAccess` at `:170-262`, `Fake` at `:358-406`)
+
+**Interfaces:**
+- Produces the trait:
+
+```rust
+use crate::folders::Folder;
+use crate::storage::Note;
+
+pub trait NoteStore: Send + Sync {
+    /// All notes incl. archived and trashed (like `load_all_notes`).
+    fn all_notes(&self) -> Result<Vec<Note>, String>;
+    fn get_note(&self, id: &str) -> Result<Option<Note>, String>;
+    /// Upsert. On an existing row only content/updated_at change (see Global
+    /// Constraints) — used for create (insert), append, and content replace.
+    fn save(&self, note: &Note) -> Result<(), String>;
+    fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String>;
+    fn set_archived(&self, id: &str, archived: bool) -> Result<(), String>;
+    fn trash(&self, id: &str, ts: i64) -> Result<(), String>;
+    /// Clear the trash tombstone (does not touch `archived`).
+    fn untrash(&self, id: &str) -> Result<(), String>;
+    fn list_folders(&self) -> Result<Vec<Folder>, String>;
+    /// Create a folder with a fresh id; returns the created `Folder`.
+    fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String>;
+    fn now_ms(&self) -> i64;
+    fn new_id(&self) -> String;
+    fn emit_changed(&self);
+}
+```
+
+- [ ] **Step 1: Replace the trait definition**
+
+In `src-tauri/src/mcp.rs`, replace the old `pub trait NoteAccess { … }` (lines 5-11) with the `NoteStore` trait above. Keep the `html_to_text`/`text_to_html` helpers for now (removed in Task 11).
+
+- [ ] **Step 2: Rewrite `StoreAccess` to implement `NoteStore`**
+
+Replace the entire `impl NoteAccess for StoreAccess { … }` block (lines 174-262) with:
+
+```rust
+impl NoteStore for StoreAccess {
+    fn all_notes(&self) -> Result<Vec<Note>, String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.load_all_notes().map_err(|e| e.to_string())
+    }
+    fn get_note(&self, id: &str) -> Result<Option<Note>, String> {
+        Ok(self.all_notes()?.into_iter().find(|n| n.id == id))
+    }
+    fn save(&self, note: &Note) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        {
+            let store = st.lock().unwrap();
+            store.save_note(note).map_err(|e| e.to_string())?;
+        }
+        Ok(())
+    }
+    fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.set_folder(id, folder_id).map_err(|e| e.to_string())
+    }
+    fn set_archived(&self, id: &str, archived: bool) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.set_archived(id, archived).map_err(|e| e.to_string())
+    }
+    fn trash(&self, id: &str, ts: i64) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.trash_note(id, ts).map_err(|e| e.to_string())
+    }
+    fn untrash(&self, id: &str) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.restore_note(id).map_err(|e| e.to_string())
+    }
+    fn list_folders(&self) -> Result<Vec<Folder>, String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        crate::folders::load_folders(&store.conn).map_err(|e| e.to_string())
+    }
+    fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String> {
+        let id = self.new_id();
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        {
+            let store = st.lock().unwrap();
+            crate::folders::create_folder(&store.conn, &id, name, parent_id)
+                .map_err(|e| e.to_string())?;
+        }
+        // Read the created row back so position/defaults are accurate.
+        self.list_folders()?
+            .into_iter()
+            .find(|f| f.id == id)
+            .ok_or_else(|| "folder creation failed".to_string())
+    }
+    fn now_ms(&self) -> i64 {
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_millis() as i64)
+            .unwrap_or(0)
+    }
+    fn new_id(&self) -> String {
+        uuid::Uuid::new_v4().to_string()
+    }
+    fn emit_changed(&self) {
+        let _ = self.app.emit("notes-changed", ());
+    }
+}
+```
+
+- [ ] **Step 3: Rewrite the test `Fake` to implement `NoteStore`**
+
+Replace the `Fake` struct and its `impl` (lines 358-406) with an in-memory implementation:
+
+```rust
+    use crate::folders::Folder;
+    use crate::storage::Note;
+
+    struct Fake {
+        notes: std::sync::Mutex<Vec<Note>>,
+        folders: std::sync::Mutex<Vec<Folder>>,
+        seq: std::sync::Mutex<u64>,
+    }
+    impl NoteStore for Fake {
+        fn all_notes(&self) -> Result<Vec<Note>, String> {
+            Ok(self.notes.lock().unwrap().clone())
+        }
+        fn get_note(&self, id: &str) -> Result<Option<Note>, String> {
+            Ok(self.notes.lock().unwrap().iter().find(|n| n.id == id).cloned())
+        }
+        fn save(&self, note: &Note) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            match v.iter_mut().find(|n| n.id == note.id) {
+                // mirror save_note: only content/updated_at change on update
+                Some(existing) => {
+                    existing.content = note.content.clone();
+                    existing.updated_at = note.updated_at;
+                }
+                None => v.push(note.clone()),
+            }
+            Ok(())
+        }
+        fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.folder_id = folder_id.map(|s| s.to_string());
+            Ok(())
+        }
+        fn set_archived(&self, id: &str, archived: bool) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.archived = archived;
+            Ok(())
+        }
+        fn trash(&self, id: &str, ts: i64) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.deleted_at = Some(ts);
+            Ok(())
+        }
+        fn untrash(&self, id: &str) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.deleted_at = None;
+            Ok(())
+        }
+        fn list_folders(&self) -> Result<Vec<Folder>, String> {
+            Ok(self.folders.lock().unwrap().clone())
+        }
+        fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String> {
+            let id = self.new_id();
+            let f = Folder {
+                id: id.clone(),
+                name: name.to_string(),
+                parent_id: parent_id.map(|s| s.to_string()),
+                ..Default::default()
+            };
+            self.folders.lock().unwrap().push(f.clone());
+            Ok(f)
+        }
+        fn now_ms(&self) -> i64 {
+            1_000
+        }
+        fn new_id(&self) -> String {
+            let mut s = self.seq.lock().unwrap();
+            *s += 1;
+            format!("id{s}")
+        }
+        fn emit_changed(&self) {}
+    }
+
+    fn fake() -> Fake {
+        Fake {
+            notes: std::sync::Mutex::new(vec![Note {
+                id: "a".into(),
+                content: "<p>Hello world</p>".into(),
+                updated_at: 1,
+                ..Default::default()
+            }]),
+            folders: std::sync::Mutex::new(vec![]),
+            seq: std::sync::Mutex::new(0),
+        }
+    }
+```
+
+- [ ] **Step 4: Temporarily adapt `call_tool`/`handle_rpc`/resources to the new trait so it compiles**
+
+Change the `call_tool` signature and `handle_rpc`/`mcp_route` parameter types from `&dyn NoteAccess` to `&dyn NoteStore`. Replace the body of `call_tool` with a minimal placeholder that returns JSON built from `all_notes()` (proper tools land in Tasks 8-11):
+
+```rust
+fn call_tool(
+    name: &str,
+    args: &Value,
+    store: &dyn NoteStore,
+    allow_write: bool,
+) -> Result<String, String> {
+    let _ = (args, allow_write);
+    match name {
+        "list_notes" => {
+            let notes = store.all_notes()?;
+            Ok(json!(notes.iter().map(|n| json!({"id": n.id.clone()})).collect::<Vec<_>>()).to_string())
+        }
+        _ => Err(format!("unknown tool {name}")),
+    }
+}
+```
+
+Also update `resources/list` and `resources/read` in `handle_rpc` to use `store.all_notes()` (map to `note://{id}` with `title_from_html`; read returns `html_to_md`). Delete the tests that reference removed behavior only if they no longer compile — otherwise leave them; Task 8+ replace them. It is acceptable for this task to leave `tools/list` returning the old `tool_defs()` (rewritten in Task 11).
+
+- [ ] **Step 5: Verify it compiles and existing structural tests pass**
+
+Run: `cd src-tauri && cargo test --lib mcp`
+Expected: compiles; `initialize_reports_version_and_caps` and `notification_has_no_response` PASS. Some old tool tests may be temporarily removed — that is expected and they are restored/replaced in later tasks.
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "refactor(mcp): data-oriented NoteStore trait + Fake/StoreAccess"
+```
+
+---
+
+## Task 7: Handler helpers — status, group resolution, JSON builders
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (add pure helper fns above `call_tool`)
+
+**Interfaces:**
+- Produces (all take plain data, no `self`):
+  - `fn status_of(n: &Note) -> &'static str`
+  - `fn folder_path(folders: &[Folder], id: &str) -> String` — names from root joined by `/`.
+  - `fn group_json(folders: &[Folder], folder_id: Option<&str>) -> Value` — `{id,name,path}` or `Value::Null`.
+  - `fn resolve_group(store: &dyn NoteStore, group_id: Option<&str>, group_name: Option<&str>) -> Result<Option<String>, String>` — the id/name rules from the spec.
+  - `fn note_summary(n: &Note, folders: &[Folder]) -> Value` and `fn note_full(n: &Note, folders: &[Folder], content: &str, content_type: &str) -> Value`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Add a nested tests module (in the existing `#[cfg(test)] mod tests`):
+
+```rust
+    #[test]
+    fn status_of_derives_from_fields() {
+        let mut n = Note { id: "x".into(), ..Default::default() };
+        assert_eq!(status_of(&n), "active");
+        n.archived = true;
+        assert_eq!(status_of(&n), "archived");
+        n.deleted_at = Some(1);
+        assert_eq!(status_of(&n), "trashed"); // trashed wins over archived
+    }
+
+    #[test]
+    fn folder_path_walks_parents() {
+        let folders = vec![
+            Folder { id: "p".into(), name: "Work".into(), ..Default::default() },
+            Folder { id: "c".into(), name: "Proj".into(), parent_id: Some("p".into()), ..Default::default() },
+        ];
+        assert_eq!(folder_path(&folders, "c"), "Work/Proj");
+        assert_eq!(folder_path(&folders, "p"), "Work");
+    }
+
+    #[test]
+    fn resolve_group_by_id_name_and_errors() {
+        let s = fake();
+        let f = s.create_folder("Home", None).unwrap();
+        // by id
+        assert_eq!(resolve_group(&s, Some(f.id.as_str()), None).unwrap(), Some(f.id.clone()));
+        // by name (case-insensitive)
+        assert_eq!(resolve_group(&s, None, Some("home")).unwrap(), Some(f.id.clone()));
+        // neither -> None
+        assert_eq!(resolve_group(&s, None, None).unwrap(), None);
+        // unknown id
+        assert!(resolve_group(&s, Some("nope"), None).is_err());
+        // unknown name
+        assert!(resolve_group(&s, None, Some("ghost")).is_err());
+        // both -> error
+        assert!(resolve_group(&s, Some(f.id.as_str()), Some("Home")).is_err());
+    }
+
+    #[test]
+    fn resolve_group_ambiguous_name_errors() {
+        let s = fake();
+        s.create_folder("Dup", None).unwrap();
+        s.create_folder("Dup", None).unwrap();
+        let e = resolve_group(&s, None, Some("Dup")).unwrap_err();
+        assert!(e.contains("ambiguous"), "got: {e}");
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests::resolve_group_by_id_name_and_errors`
+Expected: FAIL (helpers undefined).
+
+- [ ] **Step 3: Implement the helpers**
+
+Add above `call_tool` in `src-tauri/src/mcp.rs`:
+
+```rust
+fn status_of(n: &Note) -> &'static str {
+    if n.deleted_at.is_some() {
+        "trashed"
+    } else if n.archived {
+        "archived"
+    } else {
+        "active"
+    }
+}
+
+fn folder_path(folders: &[Folder], id: &str) -> String {
+    let mut names = Vec::new();
+    let mut cur = Some(id.to_string());
+    let mut guard = 0;
+    while let Some(cid) = cur {
+        guard += 1;
+        if guard > 64 {
+            break; // defensive against cycles
+        }
+        match folders.iter().find(|f| f.id == cid) {
+            Some(f) => {
+                names.push(f.name.clone());
+                cur = f.parent_id.clone();
+            }
+            None => break,
+        }
+    }
+    names.reverse();
+    names.join("/")
+}
+
+fn group_json(folders: &[Folder], folder_id: Option<&str>) -> Value {
+    match folder_id {
+        Some(fid) => match folders.iter().find(|f| f.id == fid) {
+            Some(f) => json!({ "id": f.id, "name": f.name, "path": folder_path(folders, fid) }),
+            None => Value::Null,
+        },
+        None => Value::Null,
+    }
+}
+
+fn resolve_group(
+    store: &dyn NoteStore,
+    group_id: Option<&str>,
+    group_name: Option<&str>,
+) -> Result<Option<String>, String> {
+    match (group_id, group_name) {
+        (Some(_), Some(_)) => Err("specify groupId or groupName, not both".into()),
+        (Some(id), None) => {
+            let folders = store.list_folders()?;
+            if folders.iter().any(|f| f.id == id) {
+                Ok(Some(id.to_string()))
+            } else {
+                Err("group not found".into())
+            }
+        }
+        (None, Some(name)) => {
+            let folders = store.list_folders()?;
+            let matches: Vec<&Folder> = folders
+                .iter()
+                .filter(|f| f.name.to_lowercase() == name.to_lowercase())
+                .collect();
+            match matches.as_slice() {
+                [] => Err("group not found".into()),
+                [one] => Ok(Some(one.id.clone())),
+                many => Err(format!(
+                    "ambiguous group name '{}': {}",
+                    name,
+                    many.iter().map(|f| f.id.as_str()).collect::<Vec<_>>().join(", ")
+                )),
+            }
+        }
+        (None, None) => Ok(None),
+    }
+}
+
+fn note_summary(n: &Note, folders: &[Folder]) -> Value {
+    json!({
+        "id": n.id,
+        "title": crate::mdconv::title_from_html(&n.content),
+        "group": group_json(folders, n.folder_id.as_deref()),
+        "contentType": "markdown",
+        "status": status_of(n),
+        "updatedAt": n.updated_at,
+    })
+}
+
+fn note_full(n: &Note, folders: &[Folder], content: &str, content_type: &str) -> Value {
+    let mut v = note_summary(n, folders);
+    v["content"] = json!(content);
+    v["contentType"] = json!(content_type);
+    v["pinned"] = json!(n.pinned);
+    v["dueAt"] = json!(n.due_at);
+    v
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests`
+Expected: PASS (the four new helper tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "feat(mcp): status/group-resolution/json-builder helpers"
+```
+
+---
+
+## Task 8: Read tools — `list_notes`, `get_note`, `search_notes`, `list_groups`
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (`call_tool` read arms)
+
+**Interfaces:**
+- Consumes: Task 7 helpers, `mdconv::html_to_md`, `mdconv::html_to_text` (existing) for text format.
+- Produces `call_tool` arms:
+  - `list_notes` — args `status?` (`active` default / `archived` / `trashed` / `all`), `groupId?`. Returns JSON array of `note_summary`.
+  - `get_note` — args `id` (req), `format?` (`markdown` default / `html` / `text`). Returns `note_full` JSON. Error `"note not found"`.
+  - `search_notes` — args `query` (req), `status?` (default `active`), `groupId?`. Returns array of summaries each with `snippet`.
+  - `list_groups` — no args. Returns JSON array of `{id,name,parentId,path}`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to the tests module. Uses a helper to invoke a tool and parse JSON:
+
+```rust
+    fn call_json(store: &dyn NoteStore, name: &str, args: Value, allow_write: bool) -> Value {
+        let text = call_tool(name, &args, store, allow_write).unwrap();
+        serde_json::from_str(&text).unwrap()
+    }
+
+    #[test]
+    fn list_notes_returns_summaries_with_group_and_status() {
+        let s = fake();
+        let f = s.create_folder("Work", None).unwrap();
+        s.save(&Note { id: "b".into(), content: "<p>Second</p>".into(), folder_id: Some(f.id.clone()), updated_at: 2, ..Default::default() }).unwrap();
+        let arr = call_json(&s, "list_notes", json!({}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 2); // "a" (seed) + "b", both active
+        let b = items.iter().find(|i| i["id"] == "b").unwrap();
+        assert_eq!(b["group"]["name"], "Work");
+        assert_eq!(b["contentType"], "markdown");
+        assert_eq!(b["status"], "active");
+        assert!(b["title"].as_str().unwrap().contains("Second"));
+    }
+
+    #[test]
+    fn list_notes_status_filter() {
+        let s = fake();
+        s.save(&Note { id: "arch".into(), content: "<p>x</p>".into(), archived: true, updated_at: 2, ..Default::default() }).unwrap();
+        s.save(&Note { id: "del".into(), content: "<p>y</p>".into(), deleted_at: Some(9), updated_at: 3, ..Default::default() }).unwrap();
+        let active = call_json(&s, "list_notes", json!({}), false);
+        assert_eq!(active.as_array().unwrap().len(), 1); // only seed "a"
+        let archived = call_json(&s, "list_notes", json!({"status":"archived"}), false);
+        assert_eq!(archived.as_array().unwrap()[0]["id"], "arch");
+        let trashed = call_json(&s, "list_notes", json!({"status":"trashed"}), false);
+        assert_eq!(trashed.as_array().unwrap()[0]["id"], "del");
+        let all = call_json(&s, "list_notes", json!({"status":"all"}), false);
+        assert_eq!(all.as_array().unwrap().len(), 3);
+    }
+
+    #[test]
+    fn list_notes_group_filter() {
+        let s = fake();
+        let f = s.create_folder("G", None).unwrap();
+        s.save(&Note { id: "in".into(), content: "<p>x</p>".into(), folder_id: Some(f.id.clone()), updated_at: 2, ..Default::default() }).unwrap();
+        let arr = call_json(&s, "list_notes", json!({"groupId": f.id}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0]["id"], "in");
+    }
+
+    #[test]
+    fn get_note_returns_markdown_content() {
+        let s = fake();
+        s.save(&Note { id: "m".into(), content: "<h1>Title</h1><p>body</p>".into(), updated_at: 2, ..Default::default() }).unwrap();
+        let v = call_json(&s, "get_note", json!({"id":"m"}), false);
+        assert_eq!(v["contentType"], "markdown");
+        assert!(v["content"].as_str().unwrap().contains("# Title"));
+        assert!(v.get("pinned").is_some());
+    }
+
+    #[test]
+    fn get_note_html_format() {
+        let s = fake();
+        let v = call_json(&s, "get_note", json!({"id":"a","format":"html"}), false);
+        assert_eq!(v["contentType"], "html");
+        assert!(v["content"].as_str().unwrap().contains("<p>Hello world</p>"));
+    }
+
+    #[test]
+    fn get_note_missing_errors() {
+        let s = fake();
+        assert!(call_tool("get_note", &json!({"id":"zzz"}), &s, false).is_err());
+    }
+
+    #[test]
+    fn search_notes_matches_and_snippets() {
+        let s = fake();
+        let arr = call_json(&s, "search_notes", json!({"query":"hello"}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0]["id"], "a");
+        assert!(items[0]["snippet"].as_str().unwrap().to_lowercase().contains("hello"));
+    }
+
+    #[test]
+    fn list_groups_returns_tree_fields() {
+        let s = fake();
+        let p = s.create_folder("P", None).unwrap();
+        s.create_folder("C", Some(p.id.as_str())).unwrap();
+        let arr = call_json(&s, "list_groups", json!({}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 2);
+        let c = items.iter().find(|i| i["name"] == "C").unwrap();
+        assert_eq!(c["parentId"], p.id);
+        assert_eq!(c["path"], "P/C");
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests::list_notes_returns_summaries_with_group_and_status`
+Expected: FAIL (placeholder `call_tool` only returns `{id}` objects / unknown tool).
+
+- [ ] **Step 3: Implement the read arms**
+
+Replace the placeholder `call_tool` read handling with (keep the `_ => Err(...)` default and the write arms from later tasks):
+
+```rust
+fn call_tool(
+    name: &str,
+    args: &Value,
+    store: &dyn NoteStore,
+    allow_write: bool,
+) -> Result<String, String> {
+    let s = |k: &str| args.get(k).and_then(|v| v.as_str()).map(|v| v.to_string());
+    match name {
+        "list_notes" => {
+            let status = s("status").unwrap_or_else(|| "active".into());
+            let group = s("groupId");
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = store
+                .all_notes()?
+                .into_iter()
+                .filter(|n| status == "all" || status_of(n) == status)
+                .filter(|n| group.as_deref().map_or(true, |g| n.folder_id.as_deref() == Some(g)))
+                .map(|n| note_summary(&n, &folders))
+                .collect();
+            Ok(json!(items).to_string())
+        }
+        "get_note" => {
+            let id = s("id").unwrap_or_default();
+            let n = store.get_note(&id)?.ok_or("note not found")?;
+            let folders = store.list_folders()?;
+            let fmt = s("format").unwrap_or_else(|| "markdown".into());
+            let content = match fmt.as_str() {
+                "html" => n.content.clone(),
+                "text" => html_to_text(&n.content),
+                _ => crate::mdconv::html_to_md(&n.content),
+            };
+            let ct = match fmt.as_str() {
+                "html" => "html",
+                "text" => "text",
+                _ => "markdown",
+            };
+            Ok(note_full(&n, &folders, &content, ct).to_string())
+        }
+        "search_notes" => {
+            let q = s("query").unwrap_or_default().to_lowercase();
+            let status = s("status").unwrap_or_else(|| "active".into());
+            let group = s("groupId");
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = store
+                .all_notes()?
+                .into_iter()
+                .filter(|n| status == "all" || status_of(n) == status)
+                .filter(|n| group.as_deref().map_or(true, |g| n.folder_id.as_deref() == Some(g)))
+                .filter_map(|n| {
+                    let plain = html_to_text(&n.content);
+                    if !plain.to_lowercase().contains(&q) || q.is_empty() {
+                        return None;
+                    }
+                    let mut v = note_summary(&n, &folders);
+                    v["snippet"] = json!(snippet(&plain, &q));
+                    Some(v)
+                })
+                .collect();
+            Ok(json!(items).to_string())
+        }
+        "list_groups" => {
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = folders
+                .iter()
+                .map(|f| json!({
+                    "id": f.id,
+                    "name": f.name,
+                    "parentId": f.parent_id,
+                    "path": folder_path(&folders, &f.id),
+                }))
+                .collect();
+            Ok(json!(items).to_string())
+        }
+        _ => Err(format!("unknown tool {name}")),
+    }
+}
+```
+
+Add the `snippet` helper near the other helpers:
+
+```rust
+/// A short window (~120 chars) of `plain` around the first occurrence of the
+/// already-lowercased `q`, with leading/trailing ellipses when clipped.
+fn snippet(plain: &str, q: &str) -> String {
+    let chars: Vec<char> = plain.chars().collect();
+    let lower = plain.to_lowercase();
+    let Some(byte_idx) = lower.find(q) else {
+        return chars.iter().take(120).collect::<String>().trim().to_string();
+    };
+    let start = lower[..byte_idx].chars().count().saturating_sub(40);
+    let end = (start + 120).min(chars.len());
+    let mut out = String::new();
+    if start > 0 {
+        out.push('…');
+    }
+    out.push_str(chars[start..end].iter().collect::<String>().trim());
+    if end < chars.len() {
+        out.push('…');
+    }
+    out
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests`
+Expected: PASS (all read-tool tests + Task 7 helper tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "feat(mcp): JSON read tools with group/status filters"
+```
+
+---
+
+## Task 9: Write tools — `create_note`, `append_note`, `update_note`
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (`call_tool` write arms)
+
+**Interfaces:**
+- Consumes: `mdconv::{md_to_html, wrap_plaintext}`, `resolve_group`, `NoteStore`.
+- Produces `call_tool` arms (all return `Err("writing disabled")` when `!allow_write`):
+  - `create_note` — `content` (req), `format?`, `groupId?`, `groupName?`. Inserts a note; returns `{id, group, status:"active"}`.
+  - `append_note` — `id` (req), `text` (req), `format?`. Appends converted HTML; returns `{id, status}`.
+  - `update_note` — `id` (req), `content?`, `format?`, `groupId?`, `groupName?`. Replaces content (if `content` present) and/or moves group (if a group param present); returns `{id, group, status}`.
+- Shared helper `fn to_html(content: &str, format: Option<&str>) -> String`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to the tests module:
+
+```rust
+    #[test]
+    fn create_note_converts_markdown_and_sets_group() {
+        let s = fake();
+        let f = s.create_folder("Home", None).unwrap();
+        let v = call_json(&s, "create_note", json!({"content":"# Hi\n- [ ] task","groupName":"Home"}), true);
+        assert_eq!(v["status"], "active");
+        assert_eq!(v["group"]["name"], "Home");
+        let id = v["id"].as_str().unwrap().to_string();
+        let stored = s.get_note(&id).unwrap().unwrap();
+        assert!(stored.content.contains("<h1>Hi</h1>"), "got: {}", stored.content);
+        assert!(stored.content.contains(r#"data-type="taskItem""#), "got: {}", stored.content);
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+
+    #[test]
+    fn create_note_blocked_when_writing_disabled() {
+        let s = fake();
+        assert_eq!(call_tool("create_note", &json!({"content":"x"}), &s, false).unwrap_err(), "writing disabled");
+    }
+
+    #[test]
+    fn create_note_unknown_group_errors() {
+        let s = fake();
+        assert!(call_tool("create_note", &json!({"content":"x","groupName":"ghost"}), &s, true).is_err());
+    }
+
+    #[test]
+    fn append_note_appends_converted_html() {
+        let s = fake();
+        let _ = call_tool("append_note", &json!({"id":"a","text":"**more**"}), &s, true).unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert!(stored.content.contains("<p>Hello world</p>"), "got: {}", stored.content);
+        assert!(stored.content.contains("<strong>more</strong>"), "got: {}", stored.content);
+    }
+
+    #[test]
+    fn update_note_replaces_content_and_moves() {
+        let s = fake();
+        let f = s.create_folder("Dest", None).unwrap();
+        let _ = call_tool("update_note", &json!({"id":"a","content":"## New","groupName":"Dest"}), &s, true).unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert!(stored.content.contains("<h2>New</h2>"), "got: {}", stored.content);
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+
+    #[test]
+    fn update_note_move_only_keeps_content() {
+        let s = fake();
+        let f = s.create_folder("Dest", None).unwrap();
+        let _ = call_tool("update_note", &json!({"id":"a","groupId": f.id}), &s, true).unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert_eq!(stored.content, "<p>Hello world</p>"); // unchanged
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests::create_note_converts_markdown_and_sets_group`
+Expected: FAIL (`unknown tool create_note`).
+
+- [ ] **Step 3: Implement the write arms + `to_html`**
+
+Add the helper near the others:
+
+```rust
+fn to_html(content: &str, format: Option<&str>) -> String {
+    match format.unwrap_or("markdown") {
+        "html" => content.to_string(),
+        "text" => crate::mdconv::wrap_plaintext(content),
+        _ => crate::mdconv::md_to_html(content),
+    }
+}
+```
+
+Add these arms to the `match name` in `call_tool` (before the `_ =>` default):
+
+```rust
+        "create_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let content = s("content").ok_or("content is required")?;
+            let folder_id = resolve_group(store, s("groupId").as_deref(), s("groupName").as_deref())?;
+            let note = Note {
+                id: store.new_id(),
+                content: to_html(&content, s("format").as_deref()),
+                updated_at: store.now_ms(),
+                folder_id: folder_id.clone(),
+                ..Default::default()
+            };
+            store.save(&note)?;
+            store.emit_changed();
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": note.id,
+                "group": group_json(&folders, folder_id.as_deref()),
+                "status": "active",
+            })
+            .to_string())
+        }
+        "append_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            let text = s("text").ok_or("text is required")?;
+            let mut note = store.get_note(&id)?.ok_or("note not found")?;
+            note.content.push_str(&to_html(&text, s("format").as_deref()));
+            note.updated_at = store.now_ms();
+            store.save(&note)?;
+            store.emit_changed();
+            Ok(json!({ "id": note.id, "status": status_of(&note) }).to_string())
+        }
+        "update_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            let mut note = store.get_note(&id)?.ok_or("note not found")?;
+            if let Some(content) = s("content") {
+                note.content = to_html(&content, s("format").as_deref());
+                note.updated_at = store.now_ms();
+                store.save(&note)?;
+            }
+            // Move only when a group param is present (either key).
+            if args.get("groupId").is_some() || args.get("groupName").is_some() {
+                let folder_id = resolve_group(store, s("groupId").as_deref(), s("groupName").as_deref())?;
+                store.set_folder(&id, folder_id.as_deref())?;
+                note.folder_id = folder_id;
+            }
+            store.emit_changed();
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": note.id,
+                "group": group_json(&folders, note.folder_id.as_deref()),
+                "status": status_of(&note),
+            })
+            .to_string())
+        }
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests`
+Expected: PASS (all write-tool tests + earlier tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "feat(mcp): markdown-aware create/append/update note tools"
+```
+
+---
+
+## Task 10: Lifecycle tools — `create_group`, `archive_note`, `delete_note`, `restore_note`
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (`call_tool` arms)
+
+**Interfaces:**
+- Consumes: `NoteStore` mutation methods, `group_json`.
+- Produces `call_tool` arms (all write-gated):
+  - `create_group` — `name` (req), `parentId?`. Returns `{id,name,parentId,path}`.
+  - `archive_note` — `id` (req). `set_archived(id,true)`; returns `{id,status:"archived"}`.
+  - `delete_note` — `id` (req). `trash(id, now)`; returns `{id,status:"trashed"}`.
+  - `restore_note` — `id` (req). `untrash(id)` + `set_archived(id,false)`; returns `{id,status:"active"}`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Add to the tests module:
+
+```rust
+    #[test]
+    fn create_group_returns_group_object() {
+        let s = fake();
+        let v = call_json(&s, "create_group", json!({"name":"Projects"}), true);
+        assert_eq!(v["name"], "Projects");
+        assert!(v["id"].as_str().unwrap().starts_with("id"));
+        assert_eq!(v["path"], "Projects");
+        assert_eq!(s.list_folders().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn archive_then_restore_roundtrip() {
+        let s = fake();
+        let a = call_json(&s, "archive_note", json!({"id":"a"}), true);
+        assert_eq!(a["status"], "archived");
+        assert!(s.get_note("a").unwrap().unwrap().archived);
+        let r = call_json(&s, "restore_note", json!({"id":"a"}), true);
+        assert_eq!(r["status"], "active");
+        assert!(!s.get_note("a").unwrap().unwrap().archived);
+    }
+
+    #[test]
+    fn delete_then_restore_roundtrip() {
+        let s = fake();
+        let d = call_json(&s, "delete_note", json!({"id":"a"}), true);
+        assert_eq!(d["status"], "trashed");
+        assert!(s.get_note("a").unwrap().unwrap().deleted_at.is_some());
+        let r = call_json(&s, "restore_note", json!({"id":"a"}), true);
+        assert_eq!(r["status"], "active");
+        assert!(s.get_note("a").unwrap().unwrap().deleted_at.is_none());
+    }
+
+    #[test]
+    fn lifecycle_tools_write_gated() {
+        let s = fake();
+        for t in ["create_group", "archive_note", "delete_note", "restore_note"] {
+            assert_eq!(call_tool(t, &json!({"id":"a","name":"n"}), &s, false).unwrap_err(), "writing disabled");
+        }
+    }
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests::archive_then_restore_roundtrip`
+Expected: FAIL (`unknown tool archive_note`).
+
+- [ ] **Step 3: Implement the arms**
+
+Add before the `_ =>` default in `call_tool`:
+
+```rust
+        "create_group" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let name = s("name").ok_or("name is required")?;
+            let parent = s("parentId");
+            let f = store.create_folder(&name, parent.as_deref())?;
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": f.id,
+                "name": f.name,
+                "parentId": f.parent_id,
+                "path": folder_path(&folders, &f.id),
+            })
+            .to_string())
+        }
+        "archive_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.set_archived(&id, true)?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "archived" }).to_string())
+        }
+        "delete_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.trash(&id, store.now_ms())?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "trashed" }).to_string())
+        }
+        "restore_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.untrash(&id)?;
+            store.set_archived(&id, false)?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "active" }).to_string())
+        }
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests`
+Expected: PASS (all lifecycle tests + earlier).
+
+- [ ] **Step 5: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "feat(mcp): group creation + archive/trash/restore lifecycle"
+```
+
+---
+
+## Task 11: Rewrite `tool_defs`, adapt resources, remove dead helpers
+
+**Files:**
+- Modify: `src-tauri/src/mcp.rs` (`tool_defs` at `:53-61`, resources handlers, old helpers/tests)
+
+**Interfaces:**
+- Produces: `tool_defs()` advertising all 11 tools with explicit descriptions and input schemas; resources handlers using the new trait; removal of `html_to_text`'s old sibling `text_to_html` if now unused (keep `html_to_text` — used by `get_note`/`search_notes` for the `text` format and snippet).
+
+- [ ] **Step 1: Write the failing test**
+
+Update/replace the old `tools_list_has_five` test with:
+
+```rust
+    #[test]
+    fn tools_list_has_all_tools() {
+        let r = handle_rpc(&call("tools/list", json!({})), &fake(), false, "v").unwrap();
+        let names: Vec<String> = r["result"]["tools"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|t| t["name"].as_str().unwrap().to_string())
+            .collect();
+        for expected in [
+            "list_notes", "get_note", "search_notes", "list_groups",
+            "create_note", "append_note", "update_note", "create_group",
+            "archive_note", "delete_note", "restore_note",
+        ] {
+            assert!(names.contains(&expected.to_string()), "missing {expected}: {names:?}");
+        }
+        // create_note advertises that content is Markdown:
+        let cn = r["result"]["tools"].as_array().unwrap().iter().find(|t| t["name"] == "create_note").unwrap();
+        assert!(cn["description"].as_str().unwrap().to_lowercase().contains("markdown"));
+    }
+
+    #[test]
+    fn resources_read_returns_markdown() {
+        let s = fake();
+        let r = handle_rpc(&call("resources/read", json!({"uri":"note://a"})), &s, false, "v").unwrap();
+        assert!(r["result"]["contents"][0]["text"].as_str().unwrap().contains("Hello world"));
+        assert_eq!(r["result"]["contents"][0]["mimeType"], "text/markdown");
+    }
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `cd src-tauri && cargo test --lib mcp::tests::tools_list_has_all_tools`
+Expected: FAIL (old `tool_defs` lists 5 tools with vague descriptions).
+
+- [ ] **Step 3: Rewrite `tool_defs`**
+
+Replace `tool_defs()` with:
+
+```rust
+fn tool_defs() -> Value {
+    json!([
+        { "name": "list_notes", "description": "List notes as JSON. Each item: {id, title, group, contentType, status, updatedAt}. Optional filters: status (active|archived|trashed|all, default active) and groupId.",
+          "inputSchema": { "type": "object", "properties": {
+            "status": { "type": "string", "enum": ["active", "archived", "trashed", "all"] },
+            "groupId": { "type": "string" } } } },
+        { "name": "get_note", "description": "Get one note as JSON including its content. Content is returned as Markdown by default (contentType 'markdown'); pass format 'html' or 'text' for other representations.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "html", "text"] } }, "required": ["id"] } },
+        { "name": "search_notes", "description": "Search notes by text (case-insensitive). Returns JSON summaries with a snippet. Optional status (default active) and groupId filters.",
+          "inputSchema": { "type": "object", "properties": {
+            "query": { "type": "string" },
+            "status": { "type": "string", "enum": ["active", "archived", "trashed", "all"] },
+            "groupId": { "type": "string" } }, "required": ["query"] } },
+        { "name": "list_groups", "description": "List groups (folders) as JSON: {id, name, parentId, path}. Use these ids/names to target a group when creating or moving notes.",
+          "inputSchema": { "type": "object", "properties": {} } },
+        { "name": "create_note", "description": "Create a note. 'content' is GitHub-Flavored Markdown by default and is converted to the app's rich format (headings, bold, lists, task lists, tables). Pass format 'html' or 'text' to override. Optionally place it in a group via groupId or groupName (groupName must match exactly one existing group).",
+          "inputSchema": { "type": "object", "properties": {
+            "content": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "html", "text"] },
+            "groupId": { "type": "string" },
+            "groupName": { "type": "string" } }, "required": ["content"] } },
+        { "name": "append_note", "description": "Append to a note. 'text' is Markdown by default (format 'html'/'text' to override) and is converted before appending.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "text": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "html", "text"] } }, "required": ["id", "text"] } },
+        { "name": "update_note", "description": "Replace a note's whole content (Markdown by default; format 'html'/'text' to override) and/or move it to another group via groupId or groupName. Omit 'content' to move only.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "content": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "html", "text"] },
+            "groupId": { "type": "string" },
+            "groupName": { "type": "string" } }, "required": ["id"] } },
+        { "name": "create_group", "description": "Create a group (folder). Optionally nest it under an existing group via parentId. Returns the new group {id, name, parentId, path}.",
+          "inputSchema": { "type": "object", "properties": {
+            "name": { "type": "string" },
+            "parentId": { "type": "string" } }, "required": ["name"] } },
+        { "name": "archive_note", "description": "Archive a note (moves it out of the active list; reversible with restore_note).",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } },
+        { "name": "delete_note", "description": "Move a note to trash (soft-delete; reversible with restore_note).",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } },
+        { "name": "restore_note", "description": "Restore a note to active from trash or archive.",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } }
+    ])
+}
+```
+
+- [ ] **Step 4: Adapt the resources handlers**
+
+In `handle_rpc`, update `resources/list` and `resources/read` to use the new trait (they may already be adapted in Task 6 — ensure the final form is):
+
+```rust
+        "resources/list" => {
+            let notes = store.all_notes().unwrap_or_default();
+            let res: Vec<Value> = notes
+                .into_iter()
+                .filter(|n| n.deleted_at.is_none())
+                .map(|n| json!({
+                    "uri": format!("note://{}", n.id),
+                    "name": crate::mdconv::title_from_html(&n.content),
+                    "mimeType": "text/markdown"
+                }))
+                .collect();
+            Some(ok(&id, json!({ "resources": res })))
+        }
+        "resources/read" => {
+            let uri = req.pointer("/params/uri").and_then(|u| u.as_str()).unwrap_or("");
+            let nid = uri.strip_prefix("note://").unwrap_or("");
+            match store.get_note(nid) {
+                Ok(Some(n)) => Some(ok(&id, json!({ "contents": [{
+                    "uri": uri, "mimeType": "text/markdown", "text": crate::mdconv::html_to_md(&n.content)
+                }] }))),
+                _ => Some(rpc_err(&id, -32602, "note not found")),
+            }
+        }
+```
+
+- [ ] **Step 5: Remove dead code**
+
+If `text_to_html` (old inline helper) is no longer referenced anywhere, delete it and its `html_text_roundtrip_helpers` test assertion for it (keep the `html_to_text` half if still used, or move that assertion to cover only `html_to_text`). Run `cargo build` and fix any unused-import/dead-code warnings.
+
+- [ ] **Step 6: Run the full mcp test suite**
+
+Run: `cd src-tauri && cargo test --lib mcp`
+Expected: PASS (all mcp tests, including `tools_list_has_all_tools` and `resources_read_returns_markdown`).
+
+- [ ] **Step 7: Commit**
+
+```bash
+cd src-tauri && cargo fmt
+git add src-tauri/src/mcp.rs
+git commit -m "feat(mcp): advertise all 11 tools, markdown resources, cleanup"
+```
+
+---
+
+## Task 12: Full verification
+
+**Files:** none (verification only)
+
+- [ ] **Step 1: Rust tests**
+
+Run: `cd src-tauri && cargo test`
+Expected: PASS (all tests across storage/folders/mcp/mdconv).
+
+- [ ] **Step 2: Formatting + lint**
+
+Run: `cd src-tauri && cargo fmt --check && cargo clippy --all-targets -- -D warnings`
+Expected: no formatting diffs, no clippy errors. Fix any warnings inline.
+
+- [ ] **Step 3: Frontend gates (must stay green)**
+
+Run from repo root:
+
+```bash
+npx tsc --noEmit && npx vitest run
+```
+
+Expected: PASS (no frontend changes were made; this confirms nothing regressed).
+
+- [ ] **Step 4: Manual smoke (optional but recommended)**
+
+Build/run the desktop app, enable the MCP server with write access in settings, and from an MCP client: `create_note` with `"# Hello\n- [ ] task"` into a group by name, then `get_note` — confirm the returned content is Markdown with `- [ ] task` and the note renders formatted (heading + checkbox) in the app, in the correct group.
+
+- [ ] **Step 5: Final commit (if any fixes were needed)**
+
+```bash
+git add -A
+git commit -m "chore(mcp): verification fixups"
+```
+
+---
+
+## Self-Review (spec coverage)
+
+- **Markdown both ways** → Tasks 2–5 (`mdconv`), consumed by read (Task 8) and write (Task 9) tools.
+- **Task-list fidelity** → Tasks 3–4 with explicit Tiptap-structure assertions; round-trip in Task 5.
+- **Return the group** → `group_json`/`folder_path` (Task 7), on every summary/full note (Tasks 7–8).
+- **Return the content type** → `contentType` field in `note_summary`/`note_full` (Task 7), reflecting requested format in `get_note` (Task 8).
+- **create_note accepts content type** → `format` param + `to_html` (Task 9); advertised in `tool_defs` (Task 11).
+- **Create note in a group** → `groupId`/`groupName` + `resolve_group` (Tasks 7, 9).
+- **list_groups / create_group** → Tasks 8, 10.
+- **update_note (replace + move)** → Task 9.
+- **archive/delete/restore + status listing** → Tasks 8 (status filter) + 10 (verbs).
+- **JSON responses** → all read tools (Task 8), write confirmations (Tasks 9–10).
+- **allow_write gating** → every write/lifecycle arm (Tasks 9–10) with a dedicated gating test.
+- **No DB migration / desktop-only / green frontend gates** → Global Constraints + Task 12.
diff --git a/docs/superpowers/specs/2026-08-05-mcp-server-overhaul-design.md b/docs/superpowers/specs/2026-08-05-mcp-server-overhaul-design.md
new file mode 100644
index 0000000..ec90a58
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-05-mcp-server-overhaul-design.md
@@ -0,0 +1,245 @@
+# MCP Server Overhaul — Design
+
+**Date:** 2026-08-05
+**Status:** Approved (design), pending implementation plan
+
+## Problem
+
+Notefix ships an HTTP JSON-RPC MCP server (`src-tauri/src/mcp.rs`) that lets
+local desktop AI clients (e.g. Claude Desktop) work with notes. Today it is too
+thin and lossy:
+
+1. **Markdown gets mangled on write.** Notes are stored as Tiptap HTML. The MCP
+   server accepts plain text and converts it with a crude `text_to_html()` that
+   just wraps each line in `<p>…</p>`. When a client sends Markdown
+   (`# Heading`, `**bold**`, `- [ ] task`), the syntax is preserved literally as
+   paragraph text and shows up escaped/unformatted in the app.
+2. **No group information.** `list_notes`/`search_notes` return only `id` + title;
+   the client can't see which folder (group) a note belongs to, and `create_note`
+   can't place a note into a group.
+3. **No content-type signal.** Responses don't declare what format the content is
+   in, so the client has to guess.
+4. **Lossy reads.** `get_note` flattens HTML to plain text, destroying formatting.
+5. **Fragile output format.** `list_notes`/`search_notes` return tab-separated
+   `"{id}\t{title}"` lines that the client must split by hand — brittle and not
+   extensible.
+6. **Incomplete lifecycle.** Only `create_note` and `append_note` exist. No way to
+   edit (full replace), move, archive, trash, restore, or list archived/trashed
+   notes; no way to create or discover groups.
+
+## Goals
+
+Turn the MCP server into a **Markdown-native, group-aware notes API** with a full
+note lifecycle:
+
+- Content crosses the MCP boundary as **Markdown** in both directions, converted
+  to/from Tiptap HTML in Rust.
+- Every list/get/search response is **JSON** (returned in the tool's text block).
+- Groups (folders) are first-class: discoverable, targetable by id or name,
+  returned on every note.
+- Full lifecycle tools: create/append/update/archive/trash/restore notes;
+  create/list groups; status-filtered listing.
+
+## Non-goals (YAGNI)
+
+- Setting `pinned` / `color` / `dueAt` on create.
+- Tags (no such field exists in the model).
+- Reconstructing custom link-preview node cards from MCP input.
+- A persisted per-note "type" field (we use delivery-format metadata instead — no
+  DB migration).
+- Mobile considerations: the MCP server is desktop-only and already hidden on
+  mobile; nothing changes there.
+
+## Background / current state
+
+- **Storage:** SQLite via `rusqlite`. Notes stored as Tiptap **HTML** in
+  `notes.content`. No `content_type`/`format` column exists, and none is added.
+- **Note model** (`src-tauri/src/storage.rs`, `src/types.ts`): `id`, `content`
+  (HTML), `updatedAt`, `pinned`, `archived`, `color`, `dueAt`, `folderId`,
+  `position`, `deletedAt`, `dirty`.
+- **Groups = Folders** (`src-tauri/src/folders.rs`): `id`, `name`, `parentId`
+  (hierarchical), `position`, `icon`, `color`, `sort`. A note's group membership is
+  `notes.folder_id` (nullable; `NULL` = ungrouped/top-level).
+- **Status is derived from fields**, not a single column:
+  - `deletedAt != NULL` → **trashed** (soft-delete tombstone)
+  - else `archived == true` → **archived**
+  - else → **active**
+- **Frontend markdown** (`src/markdown.ts`): `markdownToHtml` (marked + GFM +
+  `fixTaskLists`/`restoreLinkPreviews`) and `htmlToMarkdown` (Turndown + GFM). The
+  MCP server is Rust and **cannot** reuse this JS; it gets its own Rust converter.
+- **Write gating:** an existing `allow_write` setting already gates
+  `create_note`/`append_note` (`Err("writing disabled")` when off). All new write
+  tools respect it.
+
+## Architecture
+
+### New module: `src-tauri/src/mdconv.rs`
+
+Isolated, unit-tested Markdown↔HTML conversion, replacing the crude
+`text_to_html`/`html_to_text` helpers currently inline in `mcp.rs`.
+
+- **`md_to_html(md: &str) -> String`** — comrak with GFM extensions
+  (tables, strikethrough, task list items, autolinks).
+- **`html_to_md(html: &str) -> String`** — HTML → Markdown (via a Rust
+  html-to-markdown crate; candidate: `htmd`). Used by `get_note`.
+- **Task-list fidelity (hard requirement):** `- [ ]` / `- [x]` must round-trip to
+  Notefix's Tiptap task-list structure
+  `<ul data-type="taskList"><li data-type="taskItem" data-checked="true|false">…</li></ul>`,
+  mirroring the frontend's `fixTaskLists`. comrak's default checkbox output
+  (`<input type="checkbox">`) does **not** match Tiptap and must be post-processed
+  into the `data-type` structure. Symmetrically, `html_to_md` must recognise the
+  Tiptap task-list structure and emit `- [ ]` / `- [x]`.
+- **`title_of(md_or_html)`** — first non-empty text line, used for the `title`
+  field (matches today's behaviour).
+
+**Contract & interface:** `mdconv` depends only on the conversion crates and knows
+nothing about SQLite or MCP. Inputs are strings; outputs are strings. It can be
+tested entirely in isolation.
+
+### Content format at the boundary
+
+- Reads return **Markdown** by default; `contentType` in the response echoes the
+  format (`"markdown"`).
+- Every **write** tool accepts an optional `format: "markdown" | "html" | "text"`
+  (default `"markdown"`):
+  - `markdown` → `md_to_html` before storing.
+  - `html` → stored as-is (trusted passthrough for advanced clients).
+  - `text` → literal text, wrapped safely (each line → `<p>`), for clients that
+    explicitly want no Markdown interpretation.
+- `get_note` accepts an optional `format` to request `html` or `text` instead of
+  markdown; `contentType` in the response reflects what was returned.
+
+### Response shape (JSON in the text block)
+
+Note summary object (used by `list_notes`, `search_notes`):
+
+```json
+{
+  "id": "uuid",
+  "title": "First line of the note",
+  "group": { "id": "uuid", "name": "Work", "path": "Work/Projects" },
+  "contentType": "markdown",
+  "status": "active",
+  "updatedAt": 1234567890
+}
+```
+
+- `group` is `null` for ungrouped notes. `path` is the folder name chain from root
+  joined by `/`.
+- `status` is one of `"active" | "archived" | "trashed"` (derived as above).
+- `search_notes` items additionally include `"snippet": "…"`.
+
+`get_note` returns a **full** object: the summary fields **plus** `content`
+(markdown by default), `pinned` (bool), and `dueAt` (number | null).
+
+`list_groups` returns an array of `{ "id", "name", "parentId": "uuid"|null, "path" }`.
+
+Write tools return a small JSON confirmation, e.g. `create_note` →
+`{ "id": "…", "group": { "id":"…", "name":"…" } | null, "status": "active" }`.
+`archive_note`/`delete_note`/`restore_note` → `{ "id": "…", "status": "…" }`.
+`create_group` → `{ "id": "…", "name": "…", "parentId": "…"|null, "path": "…" }`.
+
+All JSON is returned as the tool result's `content[0].text` (a JSON string), the
+same channel used today. Errors keep the existing shape
+(`content: [{type:text,text:msg}], isError:true`).
+
+### Group targeting (create_note / update_note)
+
+A note can be placed/moved into a group via **either**:
+
+- `groupId` — resolved exactly; error `"group not found"` if unknown.
+- `groupName` — resolved **case-insensitively** against folder names. If exactly
+  one match → use it. If none → error `"group not found"` (no accidental folder
+  creation — use `create_group` first). If multiple → error listing the candidate
+  ids, e.g. `"ambiguous group name 'Work': a1b2…, c3d4…"`.
+
+Passing neither leaves the note ungrouped (`folder_id = NULL`). Passing both is an
+error (`"specify groupId or groupName, not both"`).
+
+## Tools (final set)
+
+### Reads
+
+| Tool | Input | Returns |
+|------|-------|---------|
+| `list_notes` | `status?` = `active`(default)`\|archived\|trashed\|all`, `groupId?` | JSON array of note summaries |
+| `get_note` | `id` (req), `format?` | Full note JSON |
+| `search_notes` | `query` (req), `status?` (default `active`), `groupId?` | JSON array of summaries + `snippet` |
+| `list_groups` | — | JSON array of group objects |
+
+### Writes (all gated by `allow_write`)
+
+| Tool | Input | Effect / Returns |
+|------|-------|------------------|
+| `create_note` | `content` (req), `format?`, `groupId?`, `groupName?` | New note; returns id + group + status |
+| `append_note` | `id` (req), `text` (req), `format?` | Appends converted content; returns `{id,status}` |
+| `update_note` | `id` (req), `content?`, `format?`, `groupId?`, `groupName?` | Full-replace content and/or move to group; returns `{id,group,status}` |
+| `create_group` | `name` (req), `parentId?` | New folder; returns group object |
+| `archive_note` | `id` (req) | Sets `archived=true`; returns `{id,status:"archived"}` |
+| `delete_note` | `id` (req) | Soft-delete (sets `deletedAt`) → trash; returns `{id,status:"trashed"}` |
+| `restore_note` | `id` (req) | Returns note to active: clears `deletedAt` if trashed, sets `archived=false` if archived; returns `{id,status:"active"}` |
+
+`update_note` with no `content` and only a group param performs a move-only. With
+`content` present it replaces the whole note body.
+
+All tool `description` and `inputSchema` strings are rewritten to be explicit,
+notably stating **"content is Markdown (GFM)"** on `create_note`/`append_note`/
+`update_note` so clients format correctly.
+
+## Data flow examples
+
+**Create a task note in a group:**
+1. Client → `create_note { content: "# Groceries\n- [ ] milk\n- [x] eggs", groupName: "Home" }`.
+2. Server resolves `groupName` "Home" → folder id.
+3. `md_to_html` converts (task list → Tiptap `data-type` structure).
+4. Note saved with `folder_id` set, UUID minted, `notes-changed` event emitted.
+5. Returns `{ "id":"…", "group":{"id":"…","name":"Home","path":"Home"}, "status":"active" }`.
+
+**Read it back:**
+1. Client → `get_note { id }`.
+2. `html_to_md` converts stored HTML back to Markdown (checkboxes → `- [ ]`/`- [x]`).
+3. Returns full JSON with `content` in Markdown and `contentType: "markdown"`.
+
+## Error handling
+
+- Unknown note id → `"note not found"`.
+- Unknown/ambiguous group → messages above.
+- Writes while `allow_write` is off → existing `"writing disabled"`.
+- Conflicting/invalid params → explicit messages (`groupId`+`groupName`, etc.).
+- All errors returned via the existing `isError:true` text-content shape; the RPC
+  envelope is unchanged.
+
+## Testing
+
+Rust unit tests (isolated where possible):
+
+- **`mdconv` round-trips:** headings, bold/italic, ordered/unordered lists,
+  **task lists** (checked & unchecked), inline code, code blocks, tables, links.
+  Assert Tiptap task-list structure specifically.
+- **Group resolution:** by id, by name (case-insensitive), not-found, ambiguous
+  (multiple folders same name), both-params error.
+- **Status filtering:** `list_notes` returns the right set for
+  active/archived/trashed/all, and honours `groupId`.
+- **Write gating:** each write tool refuses when `allow_write` is off.
+- **JSON shape:** responses parse as JSON and carry the documented fields
+  (`group`, `contentType`, `status`).
+
+Project-wide gates stay green: `npx tsc --noEmit` and `npx vitest run` (i18n key
+parity). No frontend changes are expected; verify regardless.
+
+## Risks
+
+- **Task-list conversion fidelity** is the main technical risk (comrak output vs
+  Tiptap's `data-type` structure, both directions). Covered by dedicated tests; if
+  a chosen crate can't be coaxed into the right structure, post-process the HTML.
+- **Breaking contract change** (tab-separated → JSON, plain text → Markdown).
+  Acceptable: the server only talks to the user's own local AI clients; no external
+  consumers.
+- **New Rust dependencies** (comrak + an html-to-markdown crate). Adds build
+  weight; both are mature, widely-used crates.
+
+## Out-of-scope / future
+
+- Exposing note metadata (pinned/color/dueAt) as writable via MCP.
+- MCP `structuredContent` + `outputSchema` (chose JSON-in-text for universal client
+  support; can be layered on later without breaking the text payload).
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 5060f60..d52201e 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -41,6 +41,56 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anstream"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
+
+[[package]]
+name = "anstyle-parse"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.102"
@@ -306,6 +356,15 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bit-set"
 version = "0.8.0"
@@ -367,6 +426,31 @@ dependencies = [
  "piper",
 ]
 
+[[package]]
+name = "bon"
+version = "3.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a602c73c7b0148ec6d12af6fd5cc7a46e2eacc8878271a999abac56eed12f561"
+dependencies = [
+ "bon-macros",
+ "rustversion",
+]
+
+[[package]]
+name = "bon-macros"
+version = "3.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dee98b0db6a962de883bf5d20362dee4d7ca0d12fe39a7c6c73c844e1cd7c1f"
+dependencies = [
+ "darling",
+ "ident_case",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "brotli"
 version = "8.0.4"
@@ -491,6 +575,15 @@ dependencies = [
  "toml 0.9.12+spec-1.1.0",
 ]
 
+[[package]]
+name = "caseless"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6fd507454086c8edfd769ca6ada439193cdb209c7681712ef6275cccbfe5d8"
+dependencies = [
+ "unicode-normalization",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.65"
@@ -554,6 +647,47 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "clap"
+version = "4.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "301b56658598e48f3648647ac6fc887be7e7108eddfa4e9b63fcf3ec58c0cadf"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94a65403d1a1bd28f7dc68eb8506e8874808ee5eecb59298de588e2e1407a078"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+ "terminal_size",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "clap_lex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+
 [[package]]
 name = "cmake"
 version = "0.1.58"
@@ -563,6 +697,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "colorchoice"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -573,6 +713,30 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "comrak"
+version = "0.54.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d5910408554659ed848ff469e67ec83b30f179e72cec286cfdae64d1616f466"
+dependencies = [
+ "bon",
+ "caseless",
+ "clap",
+ "emojis",
+ "entities",
+ "finl_unicode",
+ "fmt2io",
+ "jetscii",
+ "phf",
+ "phf_codegen",
+ "rustc-hash",
+ "shell-words",
+ "smallvec",
+ "syntect",
+ "typed-arena",
+ "xdg",
+]
+
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
@@ -1017,6 +1181,15 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 
+[[package]]
+name = "emojis"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a4d5d50b0b58df5173d8ff1192b4d1422ceae5d981b30d4b6f8ed1d673a2bc4"
+dependencies = [
+ "phf",
+]
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.35"
@@ -1032,6 +1205,12 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 
+[[package]]
+name = "entities"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5320ae4c3782150d900b79807611a59a99fc9a1d61d686faafc24b93fc8d7ca"
+
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -1113,6 +1292,17 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
+[[package]]
+name = "fancy-regex"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "998b056554fbe42e03ae0e152895cd1a7e1002aec800fdc6635d20270260c46f"
+dependencies = [
+ "bit-set",
+ "regex-automata",
+ "regex-syntax",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.4.1"
@@ -1144,6 +1334,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "finl_unicode"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9844ddc3a6e533d62bba727eb6c28b5d360921d5175e9ff0f1e621a5c590a4d5"
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -1154,6 +1350,12 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "fmt2io"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b6129284da9f7e5296cc22183a63f24300e945e297705dcc0672f7df01d62c8"
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
@@ -1669,6 +1871,17 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "htmd"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5a1c7113c831fec68cbd79cd8bf281a84e5b6943f51473dc266b0b88a6a017e"
+dependencies = [
+ "html5ever",
+ "markup5ever_rcdom",
+ "phf",
+]
+
 [[package]]
 name = "html5ever"
 version = "0.38.0"
@@ -1984,6 +2197,12 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -2013,6 +2232,12 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "jetscii"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47f142fe24a9c9944451e8349de0a56af5f3e7226dc46f3ed4d4ecc0b85af75e"
+
 [[package]]
 name = "jni"
 version = "0.21.1"
@@ -2222,6 +2447,12 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -2266,6 +2497,18 @@ dependencies = [
  "web_atoms",
 ]
 
+[[package]]
+name = "markup5ever_rcdom"
+version = "0.38.0+unofficial"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "333171ccdf66e915257740d44e38ea5b1b19ce7b45d33cc35cb6f118fbd981ff"
+dependencies = [
+ "html5ever",
+ "markup5ever",
+ "tendril",
+ "xml5ever",
+]
+
 [[package]]
 name = "matchit"
 version = "0.8.4"
@@ -2381,7 +2624,9 @@ version = "0.5.0"
 dependencies = [
  "axum",
  "base64 0.22.1",
+ "comrak",
  "dirs 6.0.0",
+ "htmd",
  "keyring",
  "rand 0.8.6",
  "regex",
@@ -2644,6 +2889,34 @@ version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "onig"
+version = "6.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2"
+dependencies = [
+ "bitflags 2.13.0",
+ "libc",
+ "once_cell",
+ "onig_sys",
+]
+
+[[package]]
+name = "onig_sys"
+version = "69.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
 [[package]]
 name = "open"
 version = "5.3.5"
@@ -2913,6 +3186,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "1.3.1"
@@ -3771,6 +4054,12 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -3913,6 +4202,7 @@ dependencies = [
  "parking_lot",
  "phf_shared",
  "precomputed-hash",
+ "serde",
 ]
 
 [[package]]
@@ -3971,6 +4261,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
 [[package]]
 name = "sync_wrapper"
 version = "1.0.2"
@@ -3991,6 +4292,28 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "syntect"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "656b45c05d95a5704399aeef6bd0ddec7b2b3531b7c9e900abbf7c4d2190c925"
+dependencies = [
+ "bincode",
+ "fancy-regex",
+ "flate2",
+ "fnv",
+ "once_cell",
+ "onig",
+ "plist",
+ "regex-syntax",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "thiserror 2.0.18",
+ "walkdir",
+ "yaml-rust",
+]
+
 [[package]]
 name = "system-deps"
 version = "6.2.2"
@@ -4438,6 +4761,16 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "terminal_size"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
+dependencies = [
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -4815,6 +5148,12 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "typed-arena"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
+
 [[package]]
 name = "typeid"
 version = "1.0.3"
@@ -4891,6 +5230,15 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.13.3"
@@ -4940,6 +5288,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
 [[package]]
 name = "uuid"
 version = "1.23.3"
@@ -5778,6 +6132,31 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "xdg"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fb433233f2df9344722454bc7e96465c9d03bff9d77c248f9e7523fe79585b5"
+
+[[package]]
+name = "xml5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dc9559429edf0cd3f327cc0afd9d6b36fa8cec6d93107b7fbe64f806b5f2d9"
+dependencies = [
+ "log",
+ "markup5ever",
+]
+
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 7b94739..c16a292 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -41,6 +41,8 @@ sha2 = "0.10"
 rand = "0.8"
 url = "2"
 time = { version = "0.3", features = ["parsing", "formatting"] }
+comrak = "0.54.0"
+htmd = "0.5.5"
 
 [dev-dependencies]
 tempfile = "3.27.0"
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index a0f55dc..bd25e73 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -8,6 +8,7 @@ mod images;
 mod imagesync;
 mod linkmeta;
 mod mcp;
+mod mdconv;
 mod migrate;
 mod profiles;
 mod revisions;
diff --git a/src-tauri/src/mcp.rs b/src-tauri/src/mcp.rs
index f40b522..0554e8f 100644
--- a/src-tauri/src/mcp.rs
+++ b/src-tauri/src/mcp.rs
@@ -1,13 +1,27 @@
+use crate::folders::Folder;
+use crate::storage::Note;
 use serde_json::{json, Value};
 use std::sync::{Arc, Mutex, OnceLock};
 use tauri::{AppHandle, Emitter, Manager};
 
-pub trait NoteAccess: Send + Sync {
-    fn list(&self) -> Vec<(String, String)>; // (id, title)
-    fn get(&self, id: &str) -> Option<String>; // text
-    fn search(&self, q: &str) -> Vec<(String, String)>;
-    fn create(&self, content: &str) -> Result<String, String>; // -> id
-    fn append(&self, id: &str, text: &str) -> Result<(), String>;
+pub trait NoteStore: Send + Sync {
+    /// All notes incl. archived and trashed (like `load_all_notes`).
+    fn all_notes(&self) -> Result<Vec<Note>, String>;
+    fn get_note(&self, id: &str) -> Result<Option<Note>, String>;
+    /// Upsert. On an existing row only content/updated_at change (see Global
+    /// Constraints) — used for create (insert), append, and content replace.
+    fn save(&self, note: &Note) -> Result<(), String>;
+    fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String>;
+    fn set_archived(&self, id: &str, archived: bool) -> Result<(), String>;
+    fn trash(&self, id: &str, ts: i64) -> Result<(), String>;
+    /// Clear the trash tombstone (does not touch `archived`).
+    fn untrash(&self, id: &str) -> Result<(), String>;
+    fn list_folders(&self) -> Result<Vec<Folder>, String>;
+    /// Create a folder with a fresh id; returns the created `Folder`.
+    fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String>;
+    fn now_ms(&self) -> i64;
+    fn new_id(&self) -> String;
+    fn emit_changed(&self);
 }
 
 pub fn html_to_text(html: &str) -> String {
@@ -27,22 +41,6 @@ pub fn html_to_text(html: &str) -> String {
         .to_string()
 }
 
-pub fn text_to_html(text: &str) -> String {
-    if text.is_empty() {
-        return "<p></p>".to_string();
-    }
-    text.lines()
-        .map(|l| {
-            format!(
-                "<p>{}</p>",
-                l.replace('&', "&amp;")
-                    .replace('<', "&lt;")
-                    .replace('>', "&gt;")
-            )
-        })
-        .collect()
-}
-
 fn ok(id: &Value, result: Value) -> Value {
     json!({ "jsonrpc": "2.0", "id": id, "result": result })
 }
@@ -52,55 +50,400 @@ fn rpc_err(id: &Value, code: i64, msg: &str) -> Value {
 
 fn tool_defs() -> Value {
     json!([
-        { "name": "list_notes", "description": "List all notes (id and title).", "inputSchema": { "type": "object", "properties": {} } },
-        { "name": "get_note", "description": "Get a note's text by id.", "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } },
-        { "name": "search_notes", "description": "Search notes by text (case-insensitive).", "inputSchema": { "type": "object", "properties": { "query": { "type": "string" } }, "required": ["query"] } },
-        { "name": "create_note", "description": "Create a new note from text.", "inputSchema": { "type": "object", "properties": { "content": { "type": "string" } }, "required": ["content"] } },
-        { "name": "append_note", "description": "Append text to a note.", "inputSchema": { "type": "object", "properties": { "id": { "type": "string" }, "text": { "type": "string" } }, "required": ["id", "text"] } }
+        { "name": "list_notes", "description": "List notes as JSON. Each item: {id, title, group, contentType, status, updatedAt}. Optional filters: status (active|archived|trashed|all, default active) and groupId.",
+          "inputSchema": { "type": "object", "properties": {
+            "status": { "type": "string", "enum": ["active", "archived", "trashed", "all"] },
+            "groupId": { "type": "string" } } } },
+        { "name": "get_note", "description": "Get one note as JSON including its content. Content is returned as Markdown by default (contentType 'markdown'); pass format 'html' or 'text' for other representations.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "html", "text"] } }, "required": ["id"] } },
+        { "name": "search_notes", "description": "Search notes by text (case-insensitive). Returns JSON summaries with a snippet. Optional status (default active) and groupId filters.",
+          "inputSchema": { "type": "object", "properties": {
+            "query": { "type": "string" },
+            "status": { "type": "string", "enum": ["active", "archived", "trashed", "all"] },
+            "groupId": { "type": "string" } }, "required": ["query"] } },
+        { "name": "list_groups", "description": "List groups (folders) as JSON: {id, name, parentId, path}. Use these ids/names to target a group when creating or moving notes.",
+          "inputSchema": { "type": "object", "properties": {} } },
+        { "name": "create_note", "description": "Create a note. 'content' is GitHub-Flavored Markdown by default and is converted to the app's rich format (headings, bold, lists, task lists, tables). Pass format 'text' to override. Optionally place it in a group via groupId or groupName (groupName must match exactly one existing group).",
+          "inputSchema": { "type": "object", "properties": {
+            "content": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "text"] },
+            "groupId": { "type": "string" },
+            "groupName": { "type": "string" } }, "required": ["content"] } },
+        { "name": "append_note", "description": "Append to a note. 'text' is Markdown by default (format 'text' to override) and is converted before appending.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "text": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "text"] } }, "required": ["id", "text"] } },
+        { "name": "update_note", "description": "Replace a note's whole content (Markdown by default; format 'text' to override) and/or move it to another group via groupId or groupName. Omit 'content' to move only.",
+          "inputSchema": { "type": "object", "properties": {
+            "id": { "type": "string" },
+            "content": { "type": "string" },
+            "format": { "type": "string", "enum": ["markdown", "text"] },
+            "groupId": { "type": "string" },
+            "groupName": { "type": "string" } }, "required": ["id"] } },
+        { "name": "create_group", "description": "Create a group (folder). Optionally nest it under an existing group via parentId. Returns the new group {id, name, parentId, path}.",
+          "inputSchema": { "type": "object", "properties": {
+            "name": { "type": "string" },
+            "parentId": { "type": "string" } }, "required": ["name"] } },
+        { "name": "archive_note", "description": "Archive a note (moves it out of the active list; reversible with restore_note).",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } },
+        { "name": "delete_note", "description": "Move a note to trash (soft-delete; reversible with restore_note).",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } },
+        { "name": "restore_note", "description": "Restore a note to active from trash or archive.",
+          "inputSchema": { "type": "object", "properties": { "id": { "type": "string" } }, "required": ["id"] } }
     ])
 }
 
+fn status_of(n: &Note) -> &'static str {
+    if n.deleted_at.is_some() {
+        "trashed"
+    } else if n.archived {
+        "archived"
+    } else {
+        "active"
+    }
+}
+
+fn folder_path(folders: &[Folder], id: &str) -> String {
+    let mut names = Vec::new();
+    let mut cur = Some(id.to_string());
+    let mut guard = 0;
+    while let Some(cid) = cur {
+        guard += 1;
+        if guard > 64 {
+            break; // defensive against cycles
+        }
+        match folders.iter().find(|f| f.id == cid) {
+            Some(f) => {
+                names.push(f.name.clone());
+                cur = f.parent_id.clone();
+            }
+            None => break,
+        }
+    }
+    names.reverse();
+    names.join("/")
+}
+
+fn group_json(folders: &[Folder], folder_id: Option<&str>) -> Value {
+    match folder_id {
+        Some(fid) => match folders.iter().find(|f| f.id == fid) {
+            Some(f) => json!({ "id": f.id, "name": f.name, "path": folder_path(folders, fid) }),
+            None => Value::Null,
+        },
+        None => Value::Null,
+    }
+}
+
+fn resolve_group(
+    store: &dyn NoteStore,
+    group_id: Option<&str>,
+    group_name: Option<&str>,
+) -> Result<Option<String>, String> {
+    match (group_id, group_name) {
+        (Some(_), Some(_)) => Err("specify groupId or groupName, not both".into()),
+        (Some(id), None) => {
+            let folders = store.list_folders()?;
+            if folders.iter().any(|f| f.id == id) {
+                Ok(Some(id.to_string()))
+            } else {
+                Err("group not found".into())
+            }
+        }
+        (None, Some(name)) => {
+            let folders = store.list_folders()?;
+            let matches: Vec<&Folder> = folders
+                .iter()
+                .filter(|f| f.name.to_lowercase() == name.to_lowercase())
+                .collect();
+            match matches.as_slice() {
+                [] => Err("group not found".into()),
+                [one] => Ok(Some(one.id.clone())),
+                many => Err(format!(
+                    "ambiguous group name '{}': {}",
+                    name,
+                    many.iter()
+                        .map(|f| f.id.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )),
+            }
+        }
+        (None, None) => Ok(None),
+    }
+}
+
+fn note_summary(n: &Note, folders: &[Folder]) -> Value {
+    json!({
+        "id": n.id,
+        "title": crate::mdconv::title_from_html(&n.content),
+        "group": group_json(folders, n.folder_id.as_deref()),
+        "contentType": "markdown",
+        "status": status_of(n),
+        "updatedAt": n.updated_at,
+    })
+}
+
+fn note_full(n: &Note, folders: &[Folder], content: &str, content_type: &str) -> Value {
+    let mut v = note_summary(n, folders);
+    v["content"] = json!(content);
+    v["contentType"] = json!(content_type);
+    v["pinned"] = json!(n.pinned);
+    v["dueAt"] = json!(n.due_at);
+    v
+}
+
+/// A short window (~120 chars) of `plain` around the first occurrence of the
+/// already-lowercased `q`, with leading/trailing ellipses when clipped.
+fn snippet(plain: &str, q: &str) -> String {
+    let chars: Vec<char> = plain.chars().collect();
+    let lower = plain.to_lowercase();
+    let Some(byte_idx) = lower.find(q) else {
+        return chars
+            .iter()
+            .take(120)
+            .collect::<String>()
+            .trim()
+            .to_string();
+    };
+    // `lower` (from `to_lowercase()`) can have a different char count than
+    // the original `chars` (some characters expand when lowercased, e.g.
+    // 'İ' -> "i̇"), so a char index computed from `lower`'s bytes must be
+    // clamped to `chars.len()` before it's used to slice `chars` — otherwise
+    // `start` (or `end`) could exceed `chars.len()` and panic the slice.
+    let start = lower[..byte_idx]
+        .chars()
+        .count()
+        .saturating_sub(40)
+        .min(chars.len());
+    let end = (start + 120).min(chars.len());
+    let mut out = String::new();
+    if start > 0 {
+        out.push('…');
+    }
+    out.push_str(chars[start..end].iter().collect::<String>().trim());
+    if end < chars.len() {
+        out.push('…');
+    }
+    out
+}
+
+fn to_html(content: &str, format: Option<&str>) -> String {
+    match format.unwrap_or("markdown") {
+        "text" => crate::mdconv::wrap_plaintext(content),
+        // "markdown", None, or any other/unrecognized value (including the
+        // now-removed "html" override): a write must never store caller-
+        // supplied HTML verbatim, so it always goes through the Markdown
+        // converter.
+        _ => crate::mdconv::md_to_html(content),
+    }
+}
+
 fn call_tool(
     name: &str,
     args: &Value,
-    store: &dyn NoteAccess,
+    store: &dyn NoteStore,
     allow_write: bool,
 ) -> Result<String, String> {
-    let s = |k: &str| {
-        args.get(k)
-            .and_then(|v| v.as_str())
-            .unwrap_or("")
-            .to_string()
-    };
+    let s = |k: &str| args.get(k).and_then(|v| v.as_str()).map(|v| v.to_string());
     match name {
-        "list_notes" => Ok(store
-            .list()
-            .into_iter()
-            .map(|(id, t)| format!("{id}\t{t}"))
-            .collect::<Vec<_>>()
-            .join("\n")),
-        "get_note" => store
-            .get(&s("id"))
-            .ok_or_else(|| "note not found".to_string()),
-        "search_notes" => Ok(store
-            .search(&s("query"))
-            .into_iter()
-            .map(|(id, t)| format!("{id}\t{t}"))
-            .collect::<Vec<_>>()
-            .join("\n")),
+        "list_notes" => {
+            let status = s("status").unwrap_or_else(|| "active".into());
+            let group = s("groupId");
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = store
+                .all_notes()?
+                .into_iter()
+                .filter(|n| status == "all" || status_of(n) == status)
+                .filter(|n| {
+                    group
+                        .as_deref()
+                        .is_none_or(|g| n.folder_id.as_deref() == Some(g))
+                })
+                .map(|n| note_summary(&n, &folders))
+                .collect();
+            Ok(json!(items).to_string())
+        }
+        "get_note" => {
+            let id = s("id").unwrap_or_default();
+            let n = store.get_note(&id)?.ok_or("note not found")?;
+            let folders = store.list_folders()?;
+            let fmt = s("format").unwrap_or_else(|| "markdown".into());
+            let content = match fmt.as_str() {
+                "html" => n.content.clone(),
+                "text" => html_to_text(&n.content),
+                _ => crate::mdconv::html_to_md(&n.content),
+            };
+            let ct = match fmt.as_str() {
+                "html" => "html",
+                "text" => "text",
+                _ => "markdown",
+            };
+            Ok(note_full(&n, &folders, &content, ct).to_string())
+        }
+        "search_notes" => {
+            let q = s("query").unwrap_or_default().to_lowercase();
+            let status = s("status").unwrap_or_else(|| "active".into());
+            let group = s("groupId");
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = store
+                .all_notes()?
+                .into_iter()
+                .filter(|n| status == "all" || status_of(n) == status)
+                .filter(|n| {
+                    group
+                        .as_deref()
+                        .is_none_or(|g| n.folder_id.as_deref() == Some(g))
+                })
+                .filter_map(|n| {
+                    let plain = html_to_text(&n.content);
+                    if !plain.to_lowercase().contains(&q) || q.is_empty() {
+                        return None;
+                    }
+                    let mut v = note_summary(&n, &folders);
+                    v["snippet"] = json!(snippet(&plain, &q));
+                    Some(v)
+                })
+                .collect();
+            Ok(json!(items).to_string())
+        }
+        "list_groups" => {
+            let folders = store.list_folders()?;
+            let items: Vec<Value> = folders
+                .iter()
+                .map(|f| {
+                    json!({
+                        "id": f.id,
+                        "name": f.name,
+                        "parentId": f.parent_id,
+                        "path": folder_path(&folders, &f.id),
+                    })
+                })
+                .collect();
+            Ok(json!(items).to_string())
+        }
         "create_note" => {
             if !allow_write {
                 return Err("writing disabled".into());
             }
-            store
-                .create(&s("content"))
-                .map(|id| format!("created {id}"))
+            let content = s("content").ok_or("content is required")?;
+            let folder_id =
+                resolve_group(store, s("groupId").as_deref(), s("groupName").as_deref())?;
+            let note = Note {
+                id: store.new_id(),
+                content: to_html(&content, s("format").as_deref()),
+                updated_at: store.now_ms(),
+                folder_id: folder_id.clone(),
+                ..Default::default()
+            };
+            store.save(&note)?;
+            store.emit_changed();
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": note.id,
+                "group": group_json(&folders, folder_id.as_deref()),
+                "status": "active",
+            })
+            .to_string())
         }
         "append_note" => {
             if !allow_write {
                 return Err("writing disabled".into());
             }
-            store.append(&s("id"), &s("text")).map(|_| "ok".to_string())
+            let id = s("id").ok_or("id is required")?;
+            let text = s("text").ok_or("text is required")?;
+            let mut note = store.get_note(&id)?.ok_or("note not found")?;
+            note.content
+                .push_str(&to_html(&text, s("format").as_deref()));
+            note.updated_at = store.now_ms();
+            store.save(&note)?;
+            store.emit_changed();
+            Ok(json!({ "id": note.id, "status": status_of(&note) }).to_string())
+        }
+        "update_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            // Resolve the group (when present) BEFORE any mutation, mirroring
+            // create_note's ordering: an invalid/ambiguous groupId/groupName
+            // must error out before content is saved, so a bad group can
+            // never leave the note's content mutated with the error still
+            // returned.
+            let folder_id = if args.get("groupId").is_some() || args.get("groupName").is_some() {
+                Some(resolve_group(
+                    store,
+                    s("groupId").as_deref(),
+                    s("groupName").as_deref(),
+                )?)
+            } else {
+                None
+            };
+            let mut note = store.get_note(&id)?.ok_or("note not found")?;
+            if let Some(content) = s("content") {
+                note.content = to_html(&content, s("format").as_deref());
+                note.updated_at = store.now_ms();
+                store.save(&note)?;
+            }
+            // Move only when a group param was present (either key).
+            if let Some(folder_id) = folder_id {
+                store.set_folder(&id, folder_id.as_deref())?;
+                note.folder_id = folder_id;
+            }
+            store.emit_changed();
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": note.id,
+                "group": group_json(&folders, note.folder_id.as_deref()),
+                "status": status_of(&note),
+            })
+            .to_string())
+        }
+        "create_group" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let name = s("name").ok_or("name is required")?;
+            let parent = s("parentId");
+            let f = store.create_folder(&name, parent.as_deref())?;
+            let folders = store.list_folders()?;
+            Ok(json!({
+                "id": f.id,
+                "name": f.name,
+                "parentId": f.parent_id,
+                "path": folder_path(&folders, &f.id),
+            })
+            .to_string())
+        }
+        "archive_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.set_archived(&id, true)?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "archived" }).to_string())
+        }
+        "delete_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.trash(&id, store.now_ms())?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "trashed" }).to_string())
+        }
+        "restore_note" => {
+            if !allow_write {
+                return Err("writing disabled".into());
+            }
+            let id = s("id").ok_or("id is required")?;
+            store.untrash(&id)?;
+            store.set_archived(&id, false)?;
+            store.emit_changed();
+            Ok(json!({ "id": id, "status": "active" }).to_string())
         }
         _ => Err(format!("unknown tool {name}")),
     }
@@ -109,7 +452,7 @@ fn call_tool(
 /// Returns None for notifications (no response).
 pub fn handle_rpc(
     req: &Value,
-    store: &dyn NoteAccess,
+    store: &dyn NoteStore,
     allow_write: bool,
     version: &str,
 ) -> Option<Value> {
@@ -147,7 +490,19 @@ pub fn handle_rpc(
             })
         }
         "resources/list" => {
-            let res: Vec<Value> = store.list().into_iter().map(|(nid, title)| json!({ "uri": format!("note://{nid}"), "name": title, "mimeType": "text/markdown" })).collect();
+            let res: Vec<Value> = store
+                .all_notes()
+                .unwrap_or_default()
+                .into_iter()
+                .filter(|n| n.deleted_at.is_none())
+                .map(|n| {
+                    json!({
+                        "uri": format!("note://{}", n.id),
+                        "name": crate::mdconv::title_from_html(&n.content),
+                        "mimeType": "text/markdown"
+                    })
+                })
+                .collect();
             Some(ok(&id, json!({ "resources": res })))
         }
         "resources/read" => {
@@ -155,12 +510,15 @@ pub fn handle_rpc(
                 .pointer("/params/uri")
                 .and_then(|u| u.as_str())
                 .unwrap_or("");
-            match store.get(uri.strip_prefix("note://").unwrap_or("")) {
-                Some(text) => Some(ok(
+            match store.get_note(uri.strip_prefix("note://").unwrap_or("")) {
+                // Match resources/list, which filters out trashed notes:
+                // a trashed note isn't readable via the resources surface
+                // even though it's still fetchable via the get_note tool.
+                Ok(Some(note)) if note.deleted_at.is_none() => Some(ok(
                     &id,
-                    json!({ "contents": [{ "uri": uri, "mimeType": "text/plain", "text": text }] }),
+                    json!({ "contents": [{ "uri": uri, "mimeType": "text/markdown", "text": crate::mdconv::html_to_md(&note.content) }] }),
                 )),
-                None => Some(rpc_err(&id, -32602, "note not found")),
+                _ => Some(rpc_err(&id, -32602, "note not found")),
             }
         }
         _ => Some(rpc_err(&id, -32601, "method not found")),
@@ -171,93 +529,73 @@ pub struct StoreAccess {
     pub app: AppHandle,
 }
 
-impl NoteAccess for StoreAccess {
-    fn list(&self) -> Vec<(String, String)> {
+impl NoteStore for StoreAccess {
+    fn all_notes(&self) -> Result<Vec<Note>, String> {
         let st = self.app.state::<Mutex<crate::storage::Store>>();
         let store = st.lock().unwrap();
-        store
-            .load_notes()
-            .unwrap_or_default()
-            .into_iter()
-            .map(|n| {
-                let t = html_to_text(&n.content);
-                (n.id, t.lines().next().unwrap_or("").to_string())
-            })
-            .collect()
+        store.load_all_notes().map_err(|e| e.to_string())
+    }
+    fn get_note(&self, id: &str) -> Result<Option<Note>, String> {
+        Ok(self.all_notes()?.into_iter().find(|n| n.id == id))
+    }
+    fn save(&self, note: &Note) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        {
+            let store = st.lock().unwrap();
+            store.save_note(note).map_err(|e| e.to_string())?;
+        }
+        Ok(())
     }
-    fn get(&self, id: &str) -> Option<String> {
+    fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String> {
         let st = self.app.state::<Mutex<crate::storage::Store>>();
         let store = st.lock().unwrap();
-        store
-            .load_all_notes()
-            .ok()?
-            .into_iter()
-            .find(|n| n.id == id)
-            .map(|n| html_to_text(&n.content))
+        store.set_folder(id, folder_id).map_err(|e| e.to_string())
     }
-    fn search(&self, q: &str) -> Vec<(String, String)> {
-        let ql = q.to_lowercase();
+    fn set_archived(&self, id: &str, archived: bool) -> Result<(), String> {
         let st = self.app.state::<Mutex<crate::storage::Store>>();
         let store = st.lock().unwrap();
-        store
-            .load_notes()
-            .unwrap_or_default()
-            .into_iter()
-            .filter_map(|n| {
-                let t = html_to_text(&n.content);
-                if t.to_lowercase().contains(&ql) {
-                    Some((n.id, t.lines().next().unwrap_or("").to_string()))
-                } else {
-                    None
-                }
-            })
-            .collect()
+        store.set_archived(id, archived).map_err(|e| e.to_string())
     }
-    fn create(&self, content: &str) -> Result<String, String> {
-        let id = uuid::Uuid::new_v4().to_string();
-        let now = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .map(|d| d.as_millis() as i64)
-            .unwrap_or(0);
-        let note = crate::storage::Note {
-            id: id.clone(),
-            content: text_to_html(content),
-            updated_at: now,
-            pinned: false,
-            archived: false,
-            color: String::new(),
-            due_at: None,
-            folder_id: None,
-            position: 0,
-            deleted_at: None,
-            dirty: false,
-        };
+    fn trash(&self, id: &str, ts: i64) -> Result<(), String> {
         let st = self.app.state::<Mutex<crate::storage::Store>>();
-        {
-            let store = st.lock().unwrap();
-            store.save_note(&note).map_err(|e| e.to_string())?;
-        }
-        let _ = self.app.emit("notes-changed", ());
-        Ok(id)
+        let store = st.lock().unwrap();
+        store.trash_note(id, ts).map_err(|e| e.to_string())
     }
-    fn append(&self, id: &str, text: &str) -> Result<(), String> {
+    fn untrash(&self, id: &str) -> Result<(), String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        store.restore_note(id).map_err(|e| e.to_string())
+    }
+    fn list_folders(&self) -> Result<Vec<Folder>, String> {
+        let st = self.app.state::<Mutex<crate::storage::Store>>();
+        let store = st.lock().unwrap();
+        crate::folders::load_folders(&store.conn).map_err(|e| e.to_string())
+    }
+    fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String> {
+        let id = self.new_id();
         let st = self.app.state::<Mutex<crate::storage::Store>>();
-        let mut note = {
-            let store = st.lock().unwrap();
-            store
-                .load_all_notes()
-                .map_err(|e| e.to_string())?
-                .into_iter()
-                .find(|n| n.id == id)
-                .ok_or("note not found")?
-        };
-        note.content.push_str(&text_to_html(text));
         {
             let store = st.lock().unwrap();
-            store.save_note(&note).map_err(|e| e.to_string())?;
+            crate::folders::create_folder(&store.conn, &id, name, parent_id)
+                .map_err(|e| e.to_string())?;
         }
+        // Read the created row back so position/defaults are accurate.
+        self.list_folders()?
+            .into_iter()
+            .find(|f| f.id == id)
+            .ok_or_else(|| "folder creation failed".to_string())
+    }
+    fn now_ms(&self) -> i64 {
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_millis() as i64)
+            .unwrap_or(0)
+    }
+    fn new_id(&self) -> String {
+        uuid::Uuid::new_v4().to_string()
+    }
+    fn emit_changed(&self) {
         let _ = self.app.emit("notes-changed", ());
-        Ok(())
     }
 }
 
@@ -356,52 +694,94 @@ pub async fn apply(
 mod tests {
     use super::*;
     struct Fake {
-        notes: std::sync::Mutex<Vec<(String, String)>>,
-    } // (id, text)
-    impl NoteAccess for Fake {
-        fn list(&self) -> Vec<(String, String)> {
-            self.notes
-                .lock()
-                .unwrap()
-                .iter()
-                .map(|(i, t)| (i.clone(), t.lines().next().unwrap_or("").to_string()))
-                .collect()
+        notes: std::sync::Mutex<Vec<Note>>,
+        folders: std::sync::Mutex<Vec<Folder>>,
+        seq: std::sync::Mutex<u64>,
+    }
+    impl NoteStore for Fake {
+        fn all_notes(&self) -> Result<Vec<Note>, String> {
+            Ok(self.notes.lock().unwrap().clone())
         }
-        fn get(&self, id: &str) -> Option<String> {
-            self.notes
+        fn get_note(&self, id: &str) -> Result<Option<Note>, String> {
+            Ok(self
+                .notes
                 .lock()
                 .unwrap()
                 .iter()
-                .find(|(i, _)| i == id)
-                .map(|(_, t)| t.clone())
+                .find(|n| n.id == id)
+                .cloned())
         }
-        fn search(&self, q: &str) -> Vec<(String, String)> {
-            let ql = q.to_lowercase();
-            self.notes
-                .lock()
-                .unwrap()
-                .iter()
-                .filter(|(_, t)| t.to_lowercase().contains(&ql))
-                .map(|(i, t)| (i.clone(), t.lines().next().unwrap_or("").to_string()))
-                .collect()
+        fn save(&self, note: &Note) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            match v.iter_mut().find(|n| n.id == note.id) {
+                // mirror save_note: only content/updated_at change on update
+                Some(existing) => {
+                    existing.content = note.content.clone();
+                    existing.updated_at = note.updated_at;
+                }
+                None => v.push(note.clone()),
+            }
+            Ok(())
         }
-        fn create(&self, content: &str) -> Result<String, String> {
-            self.notes
-                .lock()
-                .unwrap()
-                .push(("new".into(), content.into()));
-            Ok("new".into())
+        fn set_folder(&self, id: &str, folder_id: Option<&str>) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.folder_id = folder_id.map(|s| s.to_string());
+            Ok(())
+        }
+        fn set_archived(&self, id: &str, archived: bool) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.archived = archived;
+            Ok(())
+        }
+        fn trash(&self, id: &str, ts: i64) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.deleted_at = Some(ts);
+            Ok(())
         }
-        fn append(&self, id: &str, text: &str) -> Result<(), String> {
-            let mut n = self.notes.lock().unwrap();
-            let e = n.iter_mut().find(|(i, _)| i == id).ok_or("nf")?;
-            e.1.push_str(text);
+        fn untrash(&self, id: &str) -> Result<(), String> {
+            let mut v = self.notes.lock().unwrap();
+            let n = v.iter_mut().find(|n| n.id == id).ok_or("note not found")?;
+            n.deleted_at = None;
             Ok(())
         }
+        fn list_folders(&self) -> Result<Vec<Folder>, String> {
+            Ok(self.folders.lock().unwrap().clone())
+        }
+        fn create_folder(&self, name: &str, parent_id: Option<&str>) -> Result<Folder, String> {
+            let id = self.new_id();
+            let f = Folder {
+                id: id.clone(),
+                name: name.to_string(),
+                parent_id: parent_id.map(|s| s.to_string()),
+                ..Default::default()
+            };
+            self.folders.lock().unwrap().push(f.clone());
+            Ok(f)
+        }
+        fn now_ms(&self) -> i64 {
+            1_000
+        }
+        fn new_id(&self) -> String {
+            let mut s = self.seq.lock().unwrap();
+            *s += 1;
+            format!("id{s}")
+        }
+        fn emit_changed(&self) {}
     }
+
     fn fake() -> Fake {
         Fake {
-            notes: std::sync::Mutex::new(vec![("a".into(), "Hello world".into())]),
+            notes: std::sync::Mutex::new(vec![Note {
+                id: "a".into(),
+                content: "<p>Hello world</p>".into(),
+                updated_at: 1,
+                ..Default::default()
+            }]),
+            folders: std::sync::Mutex::new(vec![]),
+            seq: std::sync::Mutex::new(0),
         }
     }
     fn call(method: &str, params: Value) -> Value {
@@ -416,54 +796,77 @@ mod tests {
         assert!(r["result"]["capabilities"]["tools"].is_object());
     }
     #[test]
-    fn tools_list_has_five() {
+    fn tools_list_has_all_tools() {
         let r = handle_rpc(&call("tools/list", json!({})), &fake(), false, "v").unwrap();
-        assert_eq!(r["result"]["tools"].as_array().unwrap().len(), 5);
+        let names: Vec<String> = r["result"]["tools"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|t| t["name"].as_str().unwrap().to_string())
+            .collect();
+        for expected in [
+            "list_notes",
+            "get_note",
+            "search_notes",
+            "list_groups",
+            "create_note",
+            "append_note",
+            "update_note",
+            "create_group",
+            "archive_note",
+            "delete_note",
+            "restore_note",
+        ] {
+            assert!(
+                names.contains(&expected.to_string()),
+                "missing {expected}: {names:?}"
+            );
+        }
+        // create_note advertises that content is Markdown:
+        let cn = r["result"]["tools"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .find(|t| t["name"] == "create_note")
+            .unwrap();
+        assert!(cn["description"]
+            .as_str()
+            .unwrap()
+            .to_lowercase()
+            .contains("markdown"));
     }
+
     #[test]
-    fn search_filters() {
+    fn resources_read_returns_markdown() {
+        let s = fake();
         let r = handle_rpc(
-            &call(
-                "tools/call",
-                json!({ "name": "search_notes", "arguments": { "query": "hello" } }),
-            ),
-            &fake(),
+            &call("resources/read", json!({"uri":"note://a"})),
+            &s,
             false,
             "v",
         )
         .unwrap();
-        assert!(r["result"]["content"][0]["text"]
+        assert!(r["result"]["contents"][0]["text"]
             .as_str()
             .unwrap()
-            .contains("a"));
+            .contains("Hello world"));
+        assert_eq!(r["result"]["contents"][0]["mimeType"], "text/markdown");
     }
     #[test]
-    fn write_blocked_when_disabled() {
+    fn resources_read_trashed_note_is_not_found() {
+        // resources/list already filters out trashed notes; resources/read
+        // must be consistent and refuse to read one by URI too (the get_note
+        // TOOL is unaffected and may still fetch any note by id).
+        let s = fake();
+        s.trash("a", 9).unwrap();
         let r = handle_rpc(
-            &call(
-                "tools/call",
-                json!({ "name": "create_note", "arguments": { "content": "x" } }),
-            ),
-            &fake(),
+            &call("resources/read", json!({"uri":"note://a"})),
+            &s,
             false,
             "v",
         )
         .unwrap();
-        assert_eq!(r["result"]["isError"], true);
-    }
-    #[test]
-    fn write_allowed_when_enabled() {
-        let r = handle_rpc(
-            &call(
-                "tools/call",
-                json!({ "name": "create_note", "arguments": { "content": "x" } }),
-            ),
-            &fake(),
-            true,
-            "v",
-        )
-        .unwrap();
-        assert!(r["result"].get("isError").is_none());
+        assert_eq!(r["error"]["message"], "note not found");
     }
     #[test]
     fn notification_has_no_response() {
@@ -478,6 +881,428 @@ mod tests {
     #[test]
     fn html_text_roundtrip_helpers() {
         assert_eq!(html_to_text("<p>Hi</p><p>there</p>"), "Hi\nthere");
-        assert_eq!(text_to_html("a\nb"), "<p>a</p><p>b</p>");
+    }
+
+    #[test]
+    fn status_of_derives_from_fields() {
+        let mut n = Note {
+            id: "x".into(),
+            ..Default::default()
+        };
+        assert_eq!(status_of(&n), "active");
+        n.archived = true;
+        assert_eq!(status_of(&n), "archived");
+        n.deleted_at = Some(1);
+        assert_eq!(status_of(&n), "trashed"); // trashed wins over archived
+    }
+
+    #[test]
+    fn folder_path_walks_parents() {
+        let folders = vec![
+            Folder {
+                id: "p".into(),
+                name: "Work".into(),
+                ..Default::default()
+            },
+            Folder {
+                id: "c".into(),
+                name: "Proj".into(),
+                parent_id: Some("p".into()),
+                ..Default::default()
+            },
+        ];
+        assert_eq!(folder_path(&folders, "c"), "Work/Proj");
+        assert_eq!(folder_path(&folders, "p"), "Work");
+    }
+
+    #[test]
+    fn resolve_group_by_id_name_and_errors() {
+        let s = fake();
+        let f = s.create_folder("Home", None).unwrap();
+        // by id
+        assert_eq!(
+            resolve_group(&s, Some(f.id.as_str()), None).unwrap(),
+            Some(f.id.clone())
+        );
+        // by name (case-insensitive)
+        assert_eq!(
+            resolve_group(&s, None, Some("home")).unwrap(),
+            Some(f.id.clone())
+        );
+        // neither -> None
+        assert_eq!(resolve_group(&s, None, None).unwrap(), None);
+        // unknown id
+        assert!(resolve_group(&s, Some("nope"), None).is_err());
+        // unknown name
+        assert!(resolve_group(&s, None, Some("ghost")).is_err());
+        // both -> error
+        assert!(resolve_group(&s, Some(f.id.as_str()), Some("Home")).is_err());
+    }
+
+    #[test]
+    fn resolve_group_ambiguous_name_errors() {
+        let s = fake();
+        s.create_folder("Dup", None).unwrap();
+        s.create_folder("Dup", None).unwrap();
+        let e = resolve_group(&s, None, Some("Dup")).unwrap_err();
+        assert!(e.contains("ambiguous"), "got: {e}");
+    }
+
+    fn call_json(store: &dyn NoteStore, name: &str, args: Value, allow_write: bool) -> Value {
+        let text = call_tool(name, &args, store, allow_write).unwrap();
+        serde_json::from_str(&text).unwrap()
+    }
+
+    #[test]
+    fn list_notes_returns_summaries_with_group_and_status() {
+        let s = fake();
+        let f = s.create_folder("Work", None).unwrap();
+        s.save(&Note {
+            id: "b".into(),
+            content: "<p>Second</p>".into(),
+            folder_id: Some(f.id.clone()),
+            updated_at: 2,
+            ..Default::default()
+        })
+        .unwrap();
+        let arr = call_json(&s, "list_notes", json!({}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 2); // "a" (seed) + "b", both active
+        let b = items.iter().find(|i| i["id"] == "b").unwrap();
+        assert_eq!(b["group"]["name"], "Work");
+        assert_eq!(b["contentType"], "markdown");
+        assert_eq!(b["status"], "active");
+        assert!(b["title"].as_str().unwrap().contains("Second"));
+    }
+
+    #[test]
+    fn list_notes_status_filter() {
+        let s = fake();
+        s.save(&Note {
+            id: "arch".into(),
+            content: "<p>x</p>".into(),
+            archived: true,
+            updated_at: 2,
+            ..Default::default()
+        })
+        .unwrap();
+        s.save(&Note {
+            id: "del".into(),
+            content: "<p>y</p>".into(),
+            deleted_at: Some(9),
+            updated_at: 3,
+            ..Default::default()
+        })
+        .unwrap();
+        let active = call_json(&s, "list_notes", json!({}), false);
+        assert_eq!(active.as_array().unwrap().len(), 1); // only seed "a"
+        let archived = call_json(&s, "list_notes", json!({"status":"archived"}), false);
+        assert_eq!(archived.as_array().unwrap()[0]["id"], "arch");
+        let trashed = call_json(&s, "list_notes", json!({"status":"trashed"}), false);
+        assert_eq!(trashed.as_array().unwrap()[0]["id"], "del");
+        let all = call_json(&s, "list_notes", json!({"status":"all"}), false);
+        assert_eq!(all.as_array().unwrap().len(), 3);
+    }
+
+    #[test]
+    fn list_notes_group_filter() {
+        let s = fake();
+        let f = s.create_folder("G", None).unwrap();
+        s.save(&Note {
+            id: "in".into(),
+            content: "<p>x</p>".into(),
+            folder_id: Some(f.id.clone()),
+            updated_at: 2,
+            ..Default::default()
+        })
+        .unwrap();
+        let arr = call_json(&s, "list_notes", json!({"groupId": f.id}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0]["id"], "in");
+    }
+
+    #[test]
+    fn get_note_returns_markdown_content() {
+        let s = fake();
+        s.save(&Note {
+            id: "m".into(),
+            content: "<h1>Title</h1><p>body</p>".into(),
+            updated_at: 2,
+            ..Default::default()
+        })
+        .unwrap();
+        let v = call_json(&s, "get_note", json!({"id":"m"}), false);
+        assert_eq!(v["contentType"], "markdown");
+        assert!(v["content"].as_str().unwrap().contains("# Title"));
+        assert!(v.get("pinned").is_some());
+    }
+
+    #[test]
+    fn get_note_html_format() {
+        let s = fake();
+        let v = call_json(&s, "get_note", json!({"id":"a","format":"html"}), false);
+        assert_eq!(v["contentType"], "html");
+        assert!(v["content"]
+            .as_str()
+            .unwrap()
+            .contains("<p>Hello world</p>"));
+    }
+
+    #[test]
+    fn get_note_missing_errors() {
+        let s = fake();
+        assert!(call_tool("get_note", &json!({"id":"zzz"}), &s, false).is_err());
+    }
+
+    #[test]
+    fn search_notes_matches_and_snippets() {
+        let s = fake();
+        let arr = call_json(&s, "search_notes", json!({"query":"hello"}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0]["id"], "a");
+        assert!(items[0]["snippet"]
+            .as_str()
+            .unwrap()
+            .to_lowercase()
+            .contains("hello"));
+    }
+
+    #[test]
+    fn snippet_does_not_panic_on_expanding_lowercase() {
+        // 'İ' (U+0130) lowercases to TWO chars ("i" + a combining dot
+        // above), so `lower` can have more chars than `chars` (the
+        // original). With a long-enough run of 'İ' immediately before a
+        // late match, the char index computed from `lower`'s bytes minus 40
+        // exceeds `chars.len()`, which used to panic the `chars[start..end]`
+        // slice. 42 copies contribute 42 extra chars once lowered, enough to
+        // push `start` (44) past `chars.len()` (43) for a match on the very
+        // last character.
+        let plain = format!("{}z", "İ".repeat(42));
+        let q = plain.to_lowercase();
+        // Must not panic; clamped to an empty/short in-bounds result instead.
+        let _ = snippet(&plain, &q[q.len() - 1..]);
+    }
+
+    #[test]
+    fn search_notes_snippet_does_not_panic_on_expanding_lowercase() {
+        // Same expanding-lowercase scenario, exercised through the actual
+        // search_notes path (query lowercased once, then passed to snippet).
+        let s = fake();
+        let content = format!("<p>{}z</p>", "İ".repeat(42));
+        s.save(&Note {
+            id: "tr".into(),
+            content,
+            updated_at: 2,
+            ..Default::default()
+        })
+        .unwrap();
+        let arr = call_json(&s, "search_notes", json!({"query":"z"}), false);
+        let items = arr.as_array().unwrap();
+        assert!(items.iter().any(|i| i["id"] == "tr"), "got: {items:?}");
+    }
+
+    #[test]
+    fn list_groups_returns_tree_fields() {
+        let s = fake();
+        let p = s.create_folder("P", None).unwrap();
+        s.create_folder("C", Some(p.id.as_str())).unwrap();
+        let arr = call_json(&s, "list_groups", json!({}), false);
+        let items = arr.as_array().unwrap();
+        assert_eq!(items.len(), 2);
+        let c = items.iter().find(|i| i["name"] == "C").unwrap();
+        assert_eq!(c["parentId"], p.id);
+        assert_eq!(c["path"], "P/C");
+    }
+
+    #[test]
+    fn create_note_converts_markdown_and_sets_group() {
+        let s = fake();
+        let f = s.create_folder("Home", None).unwrap();
+        let v = call_json(
+            &s,
+            "create_note",
+            json!({"content":"# Hi\n- [ ] task","groupName":"Home"}),
+            true,
+        );
+        assert_eq!(v["status"], "active");
+        assert_eq!(v["group"]["name"], "Home");
+        let id = v["id"].as_str().unwrap().to_string();
+        let stored = s.get_note(&id).unwrap().unwrap();
+        assert!(
+            stored.content.contains("<h1>Hi</h1>"),
+            "got: {}",
+            stored.content
+        );
+        assert!(
+            stored.content.contains(r#"data-type="taskItem""#),
+            "got: {}",
+            stored.content
+        );
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+
+    #[test]
+    fn create_note_blocked_when_writing_disabled() {
+        let s = fake();
+        assert_eq!(
+            call_tool("create_note", &json!({"content":"x"}), &s, false).unwrap_err(),
+            "writing disabled"
+        );
+    }
+
+    #[test]
+    fn create_note_unknown_group_errors() {
+        let s = fake();
+        assert!(call_tool(
+            "create_note",
+            &json!({"content":"x","groupName":"ghost"}),
+            &s,
+            true
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn create_note_format_html_is_not_stored_verbatim() {
+        // Per product decision, writes must never store caller-supplied HTML
+        // as-is: a "format":"html" override no longer exists on the write
+        // path, so it falls through to the Markdown converter like any other
+        // unrecognized format value, and raw HTML tags never survive intact.
+        let s = fake();
+        let v = call_json(
+            &s,
+            "create_note",
+            json!({"content":"<script>alert(1)</script>","format":"html"}),
+            true,
+        );
+        let id = v["id"].as_str().unwrap().to_string();
+        let stored = s.get_note(&id).unwrap().unwrap();
+        assert!(
+            !stored.content.contains("<script>"),
+            "raw HTML passthrough still present: {}",
+            stored.content
+        );
+    }
+
+    #[test]
+    fn append_note_appends_converted_html() {
+        let s = fake();
+        let _ = call_tool(
+            "append_note",
+            &json!({"id":"a","text":"**more**"}),
+            &s,
+            true,
+        )
+        .unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert!(
+            stored.content.contains("<p>Hello world</p>"),
+            "got: {}",
+            stored.content
+        );
+        assert!(
+            stored.content.contains("<strong>more</strong>"),
+            "got: {}",
+            stored.content
+        );
+    }
+
+    #[test]
+    fn update_note_replaces_content_and_moves() {
+        let s = fake();
+        let f = s.create_folder("Dest", None).unwrap();
+        let _ = call_tool(
+            "update_note",
+            &json!({"id":"a","content":"## New","groupName":"Dest"}),
+            &s,
+            true,
+        )
+        .unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert!(
+            stored.content.contains("<h2>New</h2>"),
+            "got: {}",
+            stored.content
+        );
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+
+    #[test]
+    fn update_note_invalid_group_leaves_content_and_write_unapplied() {
+        let s = fake();
+        let before = s.get_note("a").unwrap().unwrap().content;
+        let err = call_tool(
+            "update_note",
+            &json!({"id":"a","content":"## New","groupName":"ghost"}),
+            &s,
+            true,
+        )
+        .unwrap_err();
+        assert!(err.contains("group not found"), "got: {err}");
+        // The group is resolved before any save, so a bad group must leave
+        // the note completely untouched -- content included.
+        let after = s.get_note("a").unwrap().unwrap();
+        assert_eq!(after.content, before);
+        assert_eq!(after.folder_id, None);
+    }
+
+    #[test]
+    fn update_note_move_only_keeps_content() {
+        let s = fake();
+        let f = s.create_folder("Dest", None).unwrap();
+        let _ = call_tool("update_note", &json!({"id":"a","groupId": f.id}), &s, true).unwrap();
+        let stored = s.get_note("a").unwrap().unwrap();
+        assert_eq!(stored.content, "<p>Hello world</p>"); // unchanged
+        assert_eq!(stored.folder_id.as_deref(), Some(f.id.as_str()));
+    }
+
+    #[test]
+    fn create_group_returns_group_object() {
+        let s = fake();
+        let v = call_json(&s, "create_group", json!({"name":"Projects"}), true);
+        assert_eq!(v["name"], "Projects");
+        assert!(v["id"].as_str().unwrap().starts_with("id"));
+        assert_eq!(v["path"], "Projects");
+        assert_eq!(s.list_folders().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn archive_then_restore_roundtrip() {
+        let s = fake();
+        let a = call_json(&s, "archive_note", json!({"id":"a"}), true);
+        assert_eq!(a["status"], "archived");
+        assert!(s.get_note("a").unwrap().unwrap().archived);
+        let r = call_json(&s, "restore_note", json!({"id":"a"}), true);
+        assert_eq!(r["status"], "active");
+        assert!(!s.get_note("a").unwrap().unwrap().archived);
+    }
+
+    #[test]
+    fn delete_then_restore_roundtrip() {
+        let s = fake();
+        let d = call_json(&s, "delete_note", json!({"id":"a"}), true);
+        assert_eq!(d["status"], "trashed");
+        assert!(s.get_note("a").unwrap().unwrap().deleted_at.is_some());
+        let r = call_json(&s, "restore_note", json!({"id":"a"}), true);
+        assert_eq!(r["status"], "active");
+        assert!(s.get_note("a").unwrap().unwrap().deleted_at.is_none());
+    }
+
+    #[test]
+    fn lifecycle_tools_write_gated() {
+        let s = fake();
+        for t in [
+            "create_group",
+            "archive_note",
+            "delete_note",
+            "restore_note",
+        ] {
+            assert_eq!(
+                call_tool(t, &json!({"id":"a","name":"n"}), &s, false).unwrap_err(),
+                "writing disabled"
+            );
+        }
     }
 }
diff --git a/src-tauri/src/mdconv.rs b/src-tauri/src/mdconv.rs
new file mode 100644
index 0000000..928f43f
--- /dev/null
+++ b/src-tauri/src/mdconv.rs
@@ -0,0 +1,446 @@
+//! Pure Markdown <-> HTML conversion for the MCP boundary. Notes are stored as
+//! Tiptap HTML; MCP speaks Markdown. Task-list handling mirrors `src/markdown.ts`
+//! so notes created via MCP are indistinguishable from app-created ones.
+
+use comrak::nodes::{ListType, NodeValue};
+use comrak::{create_formatter, parse_document, Arena, Options};
+use std::fmt::Write as _;
+
+// A regex/string post-process over comrak's rendered HTML cannot robustly
+// tell a task item's closing </li> apart from a *nested* task item's closing
+// </li> (a lazy `(.*?)</li>` match stops at the first one it finds, which is
+// the inner list's, swallowing the inner <ul> and leaving its raw <input>
+// unstripped). Overriding comrak's AST->HTML rendering for the two node
+// types involved sidesteps that entirely: `NodeValue::TaskItem` and
+// `NodeValue::List` are distinct, separately-typed nodes in the tree (a
+// nested task list is just another `List`/`TaskItem` subtree), so this
+// formatter's rules apply independently and correctly at every nesting
+// depth. It also reuses the exact "is this list a task list" answer comrak's
+// own parser already computed (`NodeList::is_task_list`), which is set as
+// soon as *any* item in a list is a task item — precisely the Tiptap rule
+// that a mixed list's `<ul>` must carry `data-type="taskList"` while a plain
+// item inside it stays a plain `<li>`.
+create_formatter!(TiptapFormatter, {
+    // comrak renders a GFM task item (`- [ ] x` / `- [x] x`) as
+    // `<li><input type="checkbox" .../> x</li>`. Tiptap instead expects
+    // `<li data-type="taskItem" data-checked="true|false">x</li>` with no
+    // `<input>` (Tiptap's NodeView renders its own checkbox), mirroring
+    // `fixTaskLists` in `src/markdown.ts`.
+    NodeValue::TaskItem(ref nti) => |context, entering| {
+        if entering {
+            context.cr()?;
+            context.write_str(if nti.symbol.is_some() {
+                r#"<li data-type="taskItem" data-checked="true">"#
+            } else {
+                r#"<li data-type="taskItem" data-checked="false">"#
+            })?;
+        } else {
+            context.write_str("</li>")?;
+            context.lf()?;
+        }
+    },
+    NodeValue::List(ref nl) => |context, entering| {
+        if entering {
+            context.cr()?;
+            match nl.list_type {
+                ListType::Bullet => {
+                    context.write_str("<ul")?;
+                    if nl.is_task_list {
+                        context.write_str(r#" data-type="taskList""#)?;
+                    }
+                    context.write_str(">")?;
+                }
+                ListType::Ordered => {
+                    context.write_str("<ol")?;
+                    if nl.is_task_list {
+                        context.write_str(r#" data-type="taskList""#)?;
+                    }
+                    if nl.start == 1 {
+                        context.write_str(">")?;
+                    } else {
+                        write!(context, " start=\"{}\">", nl.start)?;
+                    }
+                }
+            }
+            context.lf()?;
+        } else if nl.list_type == ListType::Bullet {
+            context.write_str("</ul>")?;
+            context.lf()?;
+        } else {
+            context.write_str("</ol>")?;
+            context.lf()?;
+        }
+    },
+});
+
+/// Markdown (GFM) -> HTML. Hard line breaks on (matches the frontend's
+/// `marked` `breaks: true`), tables/strikethrough/autolinks/task items
+/// enabled. Task-list items are rendered straight from comrak's AST into
+/// Tiptap's `data-type="taskList"` / `data-type="taskItem"` structure via
+/// `TiptapFormatter` above, so homogeneous, mixed, and arbitrarily nested
+/// task lists all convert correctly.
+pub fn md_to_html(md: &str) -> String {
+    let mut opts = Options::default();
+    opts.extension.table = true;
+    opts.extension.strikethrough = true;
+    opts.extension.tasklist = true;
+    opts.extension.autolink = true;
+    opts.render.hardbreaks = true;
+
+    let arena = Arena::new();
+    let root = parse_document(&arena, md, &opts);
+    let mut html = String::new();
+    TiptapFormatter::format_document(root, &opts, &mut html)
+        .expect("formatting comrak's AST to a String is infallible");
+    html.trim().to_string()
+}
+
+/// Custom `<li>` handler, installed on top of `htmd`'s built-in one, that
+/// renders a Tiptap task item (`<li data-type="taskItem"
+/// data-checked="true|false">`) as a GFM checkbox item (`- [x]`/`- [ ]`)
+/// instead of a plain bullet.
+///
+/// `htmd` 0.5.5 has no element handler for `<input>` (a task item's checkbox
+/// never survives conversion) and its text escaping rewrites a literal
+/// `[ ]`/`[x]` appearing in text content into `\[ \]`/`\[x\]` (its rule for
+/// anything that could be mistaken for Markdown link syntax). So the marker
+/// can't be produced by pre-editing the HTML or the item's text before
+/// handing it to `htmd` (an earlier version of this function tried exactly
+/// that, via a regex pre-pass and placeholder tokens) -- it has to be
+/// written by this handler itself, directly into the converted output,
+/// after `htmd`'s own text escaping has already run on the item's children.
+///
+/// Registering this via `HtmlToMarkdownBuilder::add_handler` makes `htmd`
+/// call it once per `<li>` as it walks the *parsed DOM tree*, the same way
+/// it calls its own built-in list-item handler. That is what makes nesting
+/// depth a non-issue here, unlike a regex over raw HTML text: a task item
+/// nested inside another task item's `<ul>` gets its own independent call to
+/// this function, so a nested checked/unchecked state can never be
+/// swallowed as opaque text by a lazy match on an ancestor's closing `</li>`.
+/// A plain `<li>` (no `data-checked`) falls back to `htmd`'s built-in
+/// handler unchanged, via `Handlers::fallback`.
+///
+/// Inverse of `TiptapFormatter`'s `NodeValue::TaskItem`/`NodeValue::List`
+/// handling in `md_to_html`.
+fn task_item_handler(
+    handlers: &dyn htmd::element_handler::Handlers,
+    element: htmd::Element,
+) -> Option<htmd::element_handler::HandlerResult> {
+    let checked = element
+        .attrs
+        .iter()
+        .find(|attr| &attr.name.local == "data-checked")
+        .map(|attr| attr.value.to_string());
+    let mark = match checked.as_deref() {
+        Some("true") => "x",
+        Some("false") => " ",
+        // Not a Tiptap task item (or an attribute value it never actually
+        // emits): defer to htmd's own <li> handler.
+        _ => return handlers.fallback(element),
+    };
+
+    let bullet = match handlers.options().bullet_list_marker {
+        htmd::options::BulletListMarker::Asterisk => '*',
+        htmd::options::BulletListMarker::Dash => '-',
+    };
+    let spacing = " ".repeat(handlers.options().ul_bullet_spacing as usize);
+    let prefix = format!("{bullet}{spacing}[{mark}] ");
+
+    let content = handlers.walk_children(element.node).content;
+    let content = content.trim_start_matches('\n');
+    // Indent any continuation lines (e.g. a nested list under this item) so
+    // they line up under the item's own text, matching htmd's plain bullet
+    // list-item indentation.
+    let indent = " ".repeat(prefix.chars().count());
+    let indented = content
+        .lines()
+        .enumerate()
+        .map(|(i, line)| {
+            if i == 0 || line.is_empty() {
+                line.to_string()
+            } else {
+                format!("{indent}{line}")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    Some(format!("\n{prefix}{indented}").into())
+}
+
+/// Tiptap HTML -> GFM Markdown. Inverse of `md_to_html`: headings, emphasis,
+/// lists, code, links and tables go through `htmd`'s built-in handlers; task
+/// items, at any nesting depth, go through `task_item_handler` above so they
+/// land back on `- [ ]`/`- [x]`.
+pub fn html_to_md(html: &str) -> String {
+    // Dash bullets with single-space spacing match GFM (and `md_to_html`'s
+    // own comrak output), so a note round-tripped through both directions
+    // keeps the same list style.
+    let converter = htmd::HtmlToMarkdown::builder()
+        .options(htmd::options::Options {
+            bullet_list_marker: htmd::options::BulletListMarker::Dash,
+            ul_bullet_spacing: 1,
+            ..Default::default()
+        })
+        .add_handler(vec!["li"], task_item_handler)
+        .build();
+    converter
+        .convert(html)
+        .unwrap_or_default()
+        .trim()
+        .to_string()
+}
+
+/// Strip one leading Markdown block prefix — an ATX heading marker
+/// (`#`..`######`), a blockquote marker (`>`), or a list bullet
+/// (`-`/`*`/`+`) — but only when followed by whitespace, which is what
+/// makes it real block syntax rather than literal text (e.g. `#hashtag` or
+/// `-1 lemons` keep their leading character).
+fn strip_markdown_block_prefix(line: &str) -> &str {
+    static PREFIX: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
+    let re = PREFIX.get_or_init(|| regex::Regex::new(r"^(#{1,6}|>|[-*+])\s+").unwrap());
+    match re.find(line) {
+        Some(m) => &line[m.end()..],
+        None => line,
+    }
+}
+
+/// Undo `htmd`'s backslash-escaping of characters that would otherwise read
+/// as Markdown syntax (e.g. `\*starred\*`, `\- 1 lemons`), so a title built
+/// from literal text that merely *looks* like Markdown doesn't carry stray
+/// backslashes.
+fn unescape_markdown(line: &str) -> String {
+    let mut out = String::with_capacity(line.len());
+    let mut chars = line.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '\\' {
+            if let Some(&next) = chars.peek() {
+                if next.is_ascii_punctuation() {
+                    out.push(next);
+                    chars.next();
+                    continue;
+                }
+            }
+        }
+        out.push(c);
+    }
+    out
+}
+
+/// First non-empty text line of an HTML fragment — used as a note's title.
+/// Strips one leading Markdown block marker (heading/blockquote/bullet) and
+/// unescapes any backslash-escaping `html_to_md` introduced, so a literal
+/// first line that happens to start with a Markdown-significant character
+/// (`#hashtag`, `-1 lemons`, `*starred*`) survives as human-readable text
+/// rather than being mangled or left with a stray `\`.
+pub fn title_from_html(html: &str) -> String {
+    let md = html_to_md(html);
+    let Some(line) = md.lines().find(|l| !l.trim().is_empty()) else {
+        return String::new();
+    };
+    let without_prefix = strip_markdown_block_prefix(line.trim());
+    unescape_markdown(without_prefix.trim())
+}
+
+/// Wrap literal text as HTML paragraphs, escaping markup. For `format:"text"`.
+pub fn wrap_plaintext(text: &str) -> String {
+    if text.is_empty() {
+        return "<p></p>".to_string();
+    }
+    text.lines()
+        .map(|l| {
+            format!(
+                "<p>{}</p>",
+                l.replace('&', "&amp;")
+                    .replace('<', "&lt;")
+                    .replace('>', "&gt;")
+            )
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn headings_and_emphasis() {
+        let h = md_to_html("# Title\n\nsome **bold** and *italic*");
+        assert!(h.contains("<h1>Title</h1>"), "got: {h}");
+        assert!(h.contains("<strong>bold</strong>"), "got: {h}");
+        assert!(h.contains("<em>italic</em>"), "got: {h}");
+    }
+
+    #[test]
+    fn bullet_and_ordered_lists() {
+        let h = md_to_html("- a\n- b");
+        assert!(h.contains("<ul>") && h.contains("<li>a</li>"), "got: {h}");
+        let o = md_to_html("1. one\n2. two");
+        assert!(o.contains("<ol>") && o.contains("<li>one</li>"), "got: {o}");
+    }
+
+    #[test]
+    fn code_and_tables() {
+        let c = md_to_html("`inline` and\n\n```\nblock\n```");
+        assert!(c.contains("<code>inline</code>"), "got: {c}");
+        assert!(c.contains("<pre>"), "got: {c}");
+        let t = md_to_html("| a | b |\n|---|---|\n| 1 | 2 |");
+        assert!(
+            t.contains("<table>") && t.contains("<td>1</td>"),
+            "got: {t}"
+        );
+    }
+
+    #[test]
+    fn task_list_becomes_tiptap_structure() {
+        let h = md_to_html("- [ ] todo\n- [x] done");
+        // Tiptap task-list markers present:
+        assert!(h.contains(r#"data-type="taskList""#), "got: {h}");
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="false""#),
+            "got: {h}"
+        );
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="true""#),
+            "got: {h}"
+        );
+        // The raw checkbox <input> must be gone (Tiptap renders its own):
+        assert!(!h.contains("<input"), "input not stripped: {h}");
+        // Item text survives:
+        assert!(h.contains("todo") && h.contains("done"), "got: {h}");
+    }
+
+    #[test]
+    fn plain_list_is_not_marked_as_tasklist() {
+        let h = md_to_html("- a\n- b");
+        assert!(!h.contains("taskList"), "plain list wrongly tagged: {h}");
+    }
+
+    #[test]
+    fn task_list_mixed_items() {
+        let h = md_to_html("- a\n- [ ] b\n- [x] c");
+        assert!(h.contains(r#"data-type="taskList""#), "got: {h}");
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="false""#),
+            "got: {h}"
+        );
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="true""#),
+            "got: {h}"
+        );
+        // The plain item "a" must stay a plain <li>, not become a taskItem.
+        assert!(h.contains("<li>a</li>"), "got: {h}");
+        assert!(!h.contains("<input"), "input not stripped: {h}");
+    }
+
+    #[test]
+    fn html_to_md_basic() {
+        let m = html_to_md("<h1>Title</h1><p>a <strong>b</strong></p>");
+        assert!(m.contains("# Title"), "got: {m}");
+        assert!(m.contains("**b**"), "got: {m}");
+    }
+
+    #[test]
+    fn html_to_md_task_items() {
+        let html = r#"<ul data-type="taskList"><li data-type="taskItem" data-checked="false">todo</li><li data-type="taskItem" data-checked="true">done</li></ul>"#;
+        let m = html_to_md(html);
+        assert!(m.contains("- [ ] todo"), "got: {m}");
+        assert!(m.contains("- [x] done"), "got: {m}");
+    }
+
+    #[test]
+    fn html_to_md_nested_task_items() {
+        // The exact HTML `md_to_html` produces for "- [ ] a\n  - [x] nested\n- [x] b":
+        // an outer taskList <ul> whose first <li> is itself an unchecked task item
+        // containing a nested taskList <ul> with one checked task item, followed by
+        // a sibling checked task item.
+        let html = concat!(
+            r#"<ul data-type="taskList">"#,
+            "\n",
+            r#"<li data-type="taskItem" data-checked="false">a"#,
+            "\n",
+            r#"<ul data-type="taskList">"#,
+            "\n",
+            r#"<li data-type="taskItem" data-checked="true">nested</li>"#,
+            "\n",
+            r#"</ul>"#,
+            "\n",
+            r#"</li>"#,
+            "\n",
+            r#"<li data-type="taskItem" data-checked="true">b</li>"#,
+            "\n",
+            r#"</ul>"#,
+        );
+        let m = html_to_md(html);
+        assert!(m.contains("- [ ] a"), "outer unchecked item missing: {m}");
+        assert!(m.contains("- [x] b"), "sibling checked item missing: {m}");
+        // The nested item must keep its checked marker (not become a plain bullet)
+        // and stay indented under its parent.
+        assert!(
+            m.contains("  - [x] nested") || m.contains("    - [x] nested"),
+            "nested checked item lost its marker or indentation: {m}"
+        );
+        assert!(
+            !m.contains("- nested"),
+            "nested item became a plain bullet, checked state was lost: {m}"
+        );
+    }
+
+    #[test]
+    fn round_trip_preserves_structure() {
+        let md = "# Groceries\n\n- [ ] milk\n- [x] eggs";
+        let back = html_to_md(&md_to_html(md));
+        assert!(back.contains("# Groceries"), "got: {back}");
+        assert!(back.contains("- [ ] milk"), "got: {back}");
+        assert!(back.contains("- [x] eggs"), "got: {back}");
+    }
+
+    #[test]
+    fn title_from_html_takes_first_line() {
+        assert_eq!(title_from_html("<h1>Hello</h1><p>world</p>"), "Hello");
+        assert_eq!(title_from_html("<h3>Deep</h3>"), "Deep");
+        assert_eq!(title_from_html("<p></p><p>Second</p>"), "Second");
+        assert_eq!(title_from_html(""), "");
+    }
+
+    #[test]
+    fn title_from_html_keeps_literal_markdown_looking_text() {
+        // A leading marker not followed by real block syntax is literal text
+        // and must be kept, not stripped as if it were a heading/bullet.
+        assert_eq!(title_from_html("<p>#hashtag</p>"), "#hashtag");
+        assert_eq!(title_from_html("<p>-1 lemons</p>"), "-1 lemons");
+        // htmd escapes "- " / "*x*" as Markdown-significant; the escapes
+        // must be undone so no stray backslash leaks into the title.
+        assert_eq!(title_from_html("<p>- 1 lemons</p>"), "- 1 lemons");
+        assert_eq!(title_from_html("<p>*starred*</p>"), "*starred*");
+    }
+
+    #[test]
+    fn title_from_html_strips_real_block_markers() {
+        assert_eq!(
+            title_from_html("<blockquote><p>Quote me</p></blockquote>"),
+            "Quote me"
+        );
+    }
+
+    #[test]
+    fn wrap_plaintext_escapes_and_wraps() {
+        assert_eq!(wrap_plaintext("a\nb"), "<p>a</p><p>b</p>");
+        assert_eq!(wrap_plaintext("<b>&"), "<p>&lt;b&gt;&amp;</p>");
+        assert_eq!(wrap_plaintext(""), "<p></p>");
+    }
+
+    #[test]
+    fn task_list_nested() {
+        let h = md_to_html("- [ ] a\n  - [x] nested\n- [x] b");
+        assert!(!h.contains("<input"), "input not stripped: {h}");
+        // Both the outer and the nested <ul> must be tagged as taskList.
+        let task_list_count = h.matches(r#"data-type="taskList""#).count();
+        assert!(task_list_count >= 2, "got: {h}");
+        assert!(
+            h.contains(r#"data-type="taskItem" data-checked="true""#),
+            "got: {h}"
+        );
+        assert!(h.contains("nested"), "got: {h}");
+    }
+}