From 7cd6127d5ebdd1a92749c41566d9f02945ffa4ee Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:30:39 -0400
Subject: [PATCH 01/12] T31: add Notes v2 repository and board storage

Cites V7, V48, V49, V50, V51, V52, V54.
---
 SPEC.md                       |  25 +-
 scripts/notes.py              | 945 +++++++++++++++++++++++++++++-----
 tests/test_notes_workspace.py | 141 +++++
 3 files changed, 986 insertions(+), 125 deletions(-)
 create mode 100644 tests/test_notes_workspace.py

diff --git a/SPEC.md b/SPEC.md
index 378a0d3..cda407f 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -17,7 +17,7 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - LLM: FastFlowLM NPU @ `:52625` | Ollama @ `:11434`, OpenAI-compat `POST /v1/chat/completions`
 - dashboard: daemon-served `scripts/ui/web/{index.html,app.js,styles.css}`, CSP `default-src 'self'`
 - paths: `scripts/paths.py` → USER_ROOT/{config,data,logs}; `_version.py` = version src of truth
-- version: `2.3.0` (prompt-v2 speed+quality release); `2.2.0` released (`v2.2.0` on `25b8794`); repo `agr77one/Fastflow`
+- version: `2.4.3`; target `2.5.0` = living Notes workspace + vision board; repo `agr77one/Fastflow`
 - run tree = `flowkey-pub2` (worktree, branch `live`=origin/main). old `FastFlowPrompt_Local_Setup`=1.5.0 stale.
 
 ## §I interfaces
@@ -26,6 +26,14 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - api: `POST /action/<name>` ! header `X-FFP-API: 1` → 200 `{ok,result,error,elapsed_ms}`
 - api: `GET /` → dashboard; `GET /healthz` → `{ok,version,api,actions}`
 - action: `config_snapshot` → full cfg; `apply_config_patch {patch}` → merge (whitelist `filter_config_patch`)
+- action: `notes_query {query?,kind?,status?,category?,tag?,sort?,limit?,offset?}` → `{results,count,facets}`
+- action: `note_create {title?,body?,kind?,category?,tags?,color?,due?,source?}` → note
+- action: `note_update {note_id,revision,patch}` → note | conflict
+- action: `note_trash {note_id}` / `note_restore {note_id}` → note; `note_delete {note_id,permanent:true}` → deleted
+- action: `notes_board_get` → `{board,placements}`; `notes_board_save {revision,board}` → board | conflict
+- action: `note_stage_capture {text?,source_app?}` / `note_take_staged` → quick-capture payload
+- data: note Markdown frontmatter schema v2 → stable `note_id`, `kind`, `status`, `tags`, `color`, `pinned`, `due`, `created`, `updated`, `revision`
+- data: `<vault>/.flowkey/board.json` → board sections + placements keyed by `note_id`
 - action: `recent_history {limit?}` → newest history rows; `input_text`/`output_text` iff stored @ write-time
 - action: `prompt_builder_preview {settings?,sample?}` → deterministic local preview (`⊥` LLM call)
 - config: `prompt_builder.prompt_version` ∈ {`v1`,`v2`}; default `v2`; v1 = instant rollback
@@ -98,6 +106,15 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - V45: surfaced v2 text → article agreement + fixed typo map normalized (∵ render copies user wording verbatim); ⊥ meaning change
 - V46: A/B rubric = 8 items; R8 = ⊥ section restates `<task>` (coverage-of-task ≥ 0.8), boilerplate-excluded set-wise on constraints; R8 false ⇒ disqualifying ∀ other scores; gate pass ≥ 7/8 ∧ R8 ∧ ⊥ invented
 - V40: model picker + installed list = app-styled elements (⊥ native `<datalist>`/`<select size>`, ∵ browser chrome ignores page CSS); theme-aware + keyboard-navigable (↑↓/Enter/Esc)
+- V47: Notes tab = notes + organization only; note config controls ∈ Config tab
+- V48: ∀ note API/UI identity = stable `note_id`; file move/rename ⊥ identity change
+- V49: AI enrichment ? fill blank/generated metadata; user-authored body/title ⊥ overwrite
+- V50: default remove → Trash, recoverable; permanent delete ! explicit Trash action + confirm
+- V51: v1 Markdown → schema v2 migration preserves body + unknown frontmatter + source path; migration backup ∃ before rewrite
+- V52: board placement references `note_id`; remove placement ⊥ delete/mutate note
+- V53: capture hotkey w/ selection → staged prefill; ⊥ selection → blank composer; stale clipboard ⊥ silent capture
+- V54: note writes + board writes atomic; stale `revision` → conflict, ⊥ overwrite
+- V55: note card/editor controls keyboard reachable; desktop split workspace + ≤720px stacked layout
 
 ## §T tasks
 
@@ -133,6 +150,12 @@ T27|x|streaming Chat tab (SSE): `ffp_chat.stream_send` + daemon `_STREAM_ACTIONS
 T30|x|clarify shape for underspecified requests + typo/article normalization + R8 echo gate + reported input in fixed set (2.4.3)|V44,V45,V46
 T29|x|bench memory guard + keep-warm/bench mutual exclusion + provider-error surfacing (2.4.2)|V41,V42,V43
 T28|x|model picker 2.4.1: footprint/MoE sizing + never-hide + active-model health + merged single Models card + app-styled combobox|V38,V39,V40
+T31|x|Notes schema v2 repository: stable ids, zero-loss migration, CRUD, Trash, indexed query, atomic board store|V7,V48,V49,V50,V51,V52,V54
+T32|.|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
+T33|.|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
+T34|.|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55
+T35|.|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
+T36|.|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 ```
 
 ## §B bugs
diff --git a/scripts/notes.py b/scripts/notes.py
index bb5568b..d4791d0 100644
--- a/scripts/notes.py
+++ b/scripts/notes.py
@@ -31,6 +31,7 @@
 import logging
 import os
 import re
+import shutil
 import socket
 import threading
 import time
@@ -55,6 +56,16 @@
     "ideas",
 ]
 INBOX = "inbox"
+SCHEMA_VERSION = 2
+NOTE_KINDS = frozenset({"note", "task", "idea", "link", "read_later"})
+NOTE_STATUSES = frozenset({"active", "done", "archived", "trashed"})
+NOTE_COLORS = frozenset({"yellow", "peach", "pink", "violet", "blue", "mint", "slate"})
+DEFAULT_COLOR = "yellow"
+FLOWKEY_DIR = ".flowkey"
+TRASH_DIR = ".trash"
+BOARD_FILENAME = "board.json"
+_NOTES_LOCK = threading.RLock()
+_INDEX_CACHE: dict[str, tuple[tuple[tuple[str, int, int], ...], list[dict]]] = {}
 
 URL_RE = re.compile(r"^\s*(https?://\S+)\s*$")
 
@@ -410,6 +421,384 @@ def _fallback_title(text: str, fetched_title: str) -> str:
     return (snippet or "untitled")[:60].strip()
 
 
+# ---------- Schema v2 repository --------------------------------------------
+
+_FRONTMATTER_RE = re.compile(
+    r"\A---\r?\n(?P<frontmatter>.*?)\r?\n---(?P<newline>\r?\n|$)",
+    re.DOTALL,
+)
+_FRONTMATTER_LINE_RE = re.compile(r"^([A-Za-z0-9_-]+):\s*(.*)$")
+
+
+def _now_iso() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime())
+
+
+def _decode_frontmatter_value(raw: str) -> Any:
+    value = raw.strip()
+    if not value:
+        return ""
+    try:
+        return json.loads(value)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        low = value.lower()
+        if low == "true":
+            return True
+        if low == "false":
+            return False
+        if low in {"null", "~"}:
+            return None
+        if re.fullmatch(r"-?\d+", value):
+            try:
+                return int(value)
+            except ValueError:
+                pass
+        if re.fullmatch(r"-?\d+(?:\.\d+)", value):
+            try:
+                return float(value)
+            except ValueError:
+                pass
+        return value.strip('"').strip("'")
+
+
+def _encode_frontmatter_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if value is None:
+        return "null"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        return json.dumps([str(item) for item in value], ensure_ascii=False)
+    return json.dumps(str(value), ensure_ascii=False)
+
+
+def _note_parts(text: str) -> tuple[dict, str, list[str]]:
+    """Return parsed metadata, exact body tail, and original frontmatter lines."""
+    match = _FRONTMATTER_RE.match(text)
+    if not match:
+        return {}, text, []
+    lines = match.group("frontmatter").splitlines()
+    metadata: dict[str, Any] = {}
+    for line in lines:
+        parsed = _FRONTMATTER_LINE_RE.match(line)
+        if parsed:
+            metadata[parsed.group(1)] = _decode_frontmatter_value(parsed.group(2))
+    return metadata, text[match.end():], lines
+
+
+def _merge_frontmatter(text: str, updates: dict[str, Any], body: str | None = None) -> str:
+    """Patch top-level frontmatter keys while retaining every unknown line."""
+    metadata, existing_body, lines = _note_parts(text)
+    del metadata
+    wanted = dict(updates)
+    rendered: list[str] = []
+    seen: set[str] = set()
+    for line in lines:
+        parsed = _FRONTMATTER_LINE_RE.match(line)
+        if not parsed:
+            rendered.append(line)
+            continue
+        key = parsed.group(1)
+        if key in wanted:
+            rendered.append(f"{key}: {_encode_frontmatter_value(wanted[key])}")
+            seen.add(key)
+        else:
+            rendered.append(line)
+    for key, value in wanted.items():
+        if key not in seen:
+            rendered.append(f"{key}: {_encode_frontmatter_value(value)}")
+    final_body = existing_body if body is None else body
+    return "---\n" + "\n".join(rendered) + "\n---\n" + final_body
+
+
+def _atomic_write_text(path: Path, text: str) -> None:
+    _ensure_dir(path.parent)
+    tmp = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+    try:
+        tmp.write_text(text, encoding="utf-8")
+        os.replace(tmp, path)
+    finally:
+        if tmp.exists():
+            try:
+                tmp.unlink()
+            except OSError:
+                pass
+
+
+def _invalidate_index() -> None:
+    _INDEX_CACHE.clear()
+
+
+def _note_category(path: Path, metadata: dict | None = None) -> str:
+    vault = _vault_dir().resolve()
+    try:
+        rel = path.resolve().relative_to(vault)
+    except ValueError:
+        return INBOX
+    if rel.parts and rel.parts[0] == TRASH_DIR:
+        original = str((metadata or {}).get("original_category") or INBOX)
+        try:
+            return _safe_category(original)
+        except ValueError:
+            return INBOX
+    category = str(rel.parent).replace("\\", "/")
+    return INBOX if category in ("", ".") else category
+
+
+def _backup_before_migration(path: Path) -> None:
+    vault = _vault_dir().resolve()
+    try:
+        rel = path.resolve().relative_to(vault)
+    except ValueError:
+        return
+    backup = _vault_subpath(FLOWKEY_DIR, "backups", "v1", *rel.parts)
+    backup = backup.with_suffix(backup.suffix + ".bak")
+    if not backup.exists():
+        _ensure_dir(backup.parent)
+        shutil.copy2(path, backup)
+
+
+def _ensure_note_schema(path: Path) -> tuple[dict, str, str]:
+    """Upgrade one Markdown note in place, preserving body and unknown metadata."""
+    text = path.read_text(encoding="utf-8", errors="replace")
+    metadata, body, _lines = _note_parts(text)
+    try:
+        schema = int(metadata.get("schema_version") or 0)
+    except (TypeError, ValueError):
+        schema = 0
+    note_id = str(metadata.get("note_id") or "").strip()
+    if schema >= SCHEMA_VERSION and note_id:
+        return metadata, body, text
+
+    stat = path.stat()
+    created = str(metadata.get("created") or time.strftime(
+        "%Y-%m-%dT%H:%M:%S", time.localtime(stat.st_mtime)
+    ))
+    source = str(metadata.get("source") or "")
+    kind = str(metadata.get("kind") or ("link" if source else "note"))
+    if kind not in NOTE_KINDS:
+        kind = "note"
+    status = str(metadata.get("status") or (
+        "trashed" if TRASH_DIR in path.parts else "active"
+    ))
+    if status not in NOTE_STATUSES:
+        status = "active"
+    try:
+        revision = max(1, int(metadata.get("revision") or 1))
+    except (TypeError, ValueError):
+        revision = 1
+    updates = {
+        "schema_version": SCHEMA_VERSION,
+        "note_id": note_id or uuid.uuid4().hex,
+        "kind": kind,
+        "status": status,
+        "tags": metadata.get("tags") if isinstance(metadata.get("tags"), list) else [],
+        "color": (
+            metadata.get("color")
+            if metadata.get("color") in NOTE_COLORS
+            else DEFAULT_COLOR
+        ),
+        "pinned": bool(metadata.get("pinned", False)),
+        "due": str(metadata.get("due") or ""),
+        "created": created,
+        "updated": str(metadata.get("updated") or created),
+        "revision": revision,
+        "category": _note_category(path, metadata),
+    }
+    _backup_before_migration(path)
+    migrated = _merge_frontmatter(text, updates)
+    _atomic_write_text(path, migrated)
+    merged = dict(metadata)
+    merged.update(updates)
+    _invalidate_index()
+    return merged, body, migrated
+
+
+def _iter_note_paths(include_trash: bool = False) -> list[Path]:
+    vault = _vault_dir()
+    if not vault.exists():
+        return []
+    paths: list[Path] = []
+    for path in vault.rglob("*.md"):
+        try:
+            rel = path.relative_to(vault)
+        except ValueError:
+            continue
+        if FLOWKEY_DIR in rel.parts:
+            continue
+        in_trash = bool(rel.parts and rel.parts[0] == TRASH_DIR)
+        if in_trash != include_trash:
+            continue
+        paths.append(path)
+    return paths
+
+
+def _normalize_tags(value: Any) -> list[str]:
+    if isinstance(value, str):
+        value = re.split(r"[,\n]", value)
+    if not isinstance(value, list):
+        return []
+    out: list[str] = []
+    for item in value:
+        tag = re.sub(r"\s+", "-", str(item).strip().lower()).strip("-")
+        if tag and tag not in out:
+            out.append(tag[:40])
+    return out[:20]
+
+
+def _note_record(path: Path, metadata: dict, body: str, include_body: bool = False) -> dict:
+    clean_body = body.lstrip("\r\n")
+    excerpt = re.sub(r"(?m)^\s*(?:[#>*-]+\s*|\[[ xX]\]\s*)", "", clean_body)
+    excerpt = re.sub(r"\s+", " ", excerpt).strip()[:220]
+    tags = _normalize_tags(metadata.get("tags"))
+    category = _note_category(path, metadata)
+    record = {
+        "ok": True,
+        "note_id": str(metadata.get("note_id") or ""),
+        "revision": int(metadata.get("revision") or 1),
+        "title": str(metadata.get("title") or path.stem),
+        "kind": str(metadata.get("kind") or "note"),
+        "status": str(metadata.get("status") or "active"),
+        "category": category,
+        "tags": tags,
+        "color": str(metadata.get("color") or DEFAULT_COLOR),
+        "pinned": bool(metadata.get("pinned", False)),
+        "due": str(metadata.get("due") or ""),
+        "source": str(metadata.get("source") or ""),
+        "summary": str(metadata.get("summary") or ""),
+        "created": str(metadata.get("created") or ""),
+        "updated": str(metadata.get("updated") or ""),
+        "excerpt": excerpt,
+        "relpath": str(path.relative_to(_vault_dir())).replace("\\", "/"),
+    }
+    if include_body:
+        record["body"] = clean_body
+    return record
+
+
+def _index_signature(paths: list[Path]) -> tuple[tuple[str, int, int], ...]:
+    signature: list[tuple[str, int, int]] = []
+    vault = _vault_dir()
+    for path in paths:
+        try:
+            stat = path.stat()
+            relpath = str(path.relative_to(vault)).replace("\\", "/")
+            signature.append((relpath, stat.st_mtime_ns, stat.st_size))
+        except OSError:
+            continue
+    return tuple(sorted(signature))
+
+
+def _load_note_index(include_trash: bool = False) -> list[dict]:
+    paths = _iter_note_paths(include_trash=include_trash)
+    cache_key = f"{_vault_dir().resolve()}|trash={include_trash}"
+    signature = _index_signature(paths)
+    cached = _INDEX_CACHE.get(cache_key)
+    if cached and cached[0] == signature:
+        return [dict(item) for item in cached[1]]
+
+    records: list[dict] = []
+    for path in paths:
+        try:
+            metadata, body, _text = _ensure_note_schema(path)
+            records.append(_note_record(path, metadata, body))
+        except (OSError, ValueError):
+            log.exception("could not index note %s", path)
+    final_signature = _index_signature(paths)
+    _INDEX_CACHE[cache_key] = (final_signature, [dict(item) for item in records])
+    return records
+
+
+def _find_note_path(identifier: str, include_trash: bool = True) -> Path | None:
+    raw = str(identifier or "").strip()
+    if not raw:
+        return None
+    if raw.lower().endswith(".md") or "/" in raw or "\\" in raw:
+        safe = _safe_relpath(raw)
+        candidate = _vault_subpath(*safe.split("/"))
+        if candidate.exists() and candidate.suffix.lower() == ".md":
+            return candidate
+    for trashed in ((False, True) if include_trash else (False,)):
+        for path in _iter_note_paths(include_trash=trashed):
+            try:
+                metadata, _body, _text = _ensure_note_schema(path)
+            except OSError:
+                continue
+            if str(metadata.get("note_id") or "") == raw:
+                return path
+    return None
+
+
+def query_notes(
+    query: str = "",
+    *,
+    kind: str = "",
+    status: str = "",
+    category: str = "",
+    tag: str = "",
+    sort: str = "updated",
+    limit: int = 50,
+    offset: int = 0,
+) -> dict:
+    """Filterable Notes workspace feed with lightweight cached metadata."""
+    requested_status = str(status or "").strip().lower()
+    include_trash = requested_status == "trashed"
+    records = _load_note_index(include_trash=include_trash)
+    terms = [term for term in re.split(r"\s+", str(query or "").strip().lower()) if term]
+    wanted_kind = str(kind or "").strip().lower()
+    wanted_category = str(category or "").strip()
+    wanted_tag = str(tag or "").strip().lower()
+    filtered: list[dict] = []
+    for record in records:
+        if requested_status and record["status"] != requested_status:
+            continue
+        if not requested_status and record["status"] == "trashed":
+            continue
+        if wanted_kind and record["kind"] != wanted_kind:
+            continue
+        if wanted_category and record["category"] != wanted_category:
+            continue
+        if wanted_tag and wanted_tag not in record["tags"]:
+            continue
+        haystack = " ".join([
+            record["title"], record["excerpt"], record["category"],
+            " ".join(record["tags"]), record["source"],
+        ]).lower()
+        if terms and not all(term in haystack for term in terms):
+            continue
+        filtered.append(record)
+
+    if sort == "title":
+        filtered.sort(key=lambda item: item["title"].lower())
+    elif sort == "created":
+        filtered.sort(key=lambda item: item["created"], reverse=True)
+    elif sort == "due":
+        filtered.sort(key=lambda item: (not item["due"], item["due"], item["title"].lower()))
+    else:
+        filtered.sort(
+            key=lambda item: (item["pinned"], item["updated"], item["created"]),
+            reverse=True,
+        )
+    counts = {
+        "all": len(records),
+        "tasks": sum(item["kind"] == "task" for item in records),
+        "ideas": sum(item["kind"] == "idea" for item in records),
+        "links": sum(item["kind"] in {"link", "read_later"} for item in records),
+        "pinned": sum(bool(item["pinned"]) for item in records),
+    }
+    categories = sorted({item["category"] for item in records})
+    tags = sorted({item for record in records for item in record["tags"]})
+    total = len(filtered)
+    start = max(0, int(offset or 0))
+    cap = max(1, min(int(limit or 50), 200))
+    return {
+        "results": filtered[start:start + cap],
+        "count": total,
+        "facets": {"counts": counts, "categories": categories, "tags": tags},
+    }
+
+
 # ---------- Search (note_search tool) ----------------------------------------
 
 def _split_frontmatter_title(text: str) -> tuple[str, str]:
@@ -446,39 +835,25 @@ def search_notes(query: str, limit: int = 5) -> dict:
     frontmatter title 5x over the body. Returns
     {query, results: [{title, category, path, score, snippet}], count}.
     """
-    vault = _vault_dir()
     terms = [t for t in re.split(r"\s+", (query or "").strip().lower()) if t]
-    if not terms or not vault.exists():
+    if not terms:
         return {"query": query, "results": [], "count": 0}
+    records = _load_note_index(include_trash=False)
     matches: list[dict] = []
-    for path in vault.rglob("*.md"):
-        try:
-            text = path.read_text(encoding="utf-8", errors="replace")
-        except Exception:
-            continue
-        title, body = _split_frontmatter_title(text)
-        title_l, body_l = title.lower(), body.lower()
-        score = sum(title_l.count(t) * 5 + body_l.count(t) for t in terms)
+    for record in records:
+        title_l = record["title"].lower()
+        content = " ".join([
+            record["excerpt"], record["category"], " ".join(record["tags"]),
+        ]).lower()
+        score = sum(title_l.count(term) * 5 + content.count(term) for term in terms)
         if score <= 0:
             continue
-        try:
-            rel = path.relative_to(vault)
-            category = str(rel.parent).replace("\\", "/")
-            if category in (".", ""):
-                category = "inbox"
-            relpath = str(rel).replace("\\", "/")
-        except ValueError:
-            category = path.parent.name
-            relpath = path.name
-        matches.append({
-            "title": title or path.stem,
-            "category": category,
-            "path": str(path),
-            "relpath": relpath,
-            "score": score,
-            "snippet": _snippet_around(body, terms),
-        })
-    matches.sort(key=lambda r: r["score"], reverse=True)
+        item = dict(record)
+        item["score"] = score
+        item["snippet"] = record["excerpt"]
+        item["path"] = str(_vault_subpath(*record["relpath"].split("/")))
+        matches.append(item)
+    matches.sort(key=lambda item: (item["score"], item["updated"]), reverse=True)
     capped = matches[: max(1, int(limit or 5))]
     return {"query": query, "results": capped, "count": len(matches)}
 
@@ -489,33 +864,17 @@ def list_recent_notes(limit: int = 20) -> dict:
     Read-only browse feed for the web dashboard's Notes tab; note bodies are
     not returned (use note_search for content snippets).
     """
-    vault = _vault_dir()
-    if not vault.exists():
+    records = _load_note_index(include_trash=False)
+    if not records:
         return {"results": [], "count": 0}
-    files = sorted(vault.rglob("*.md"), key=lambda p: p.stat().st_mtime, reverse=True)
-    results: list[dict] = []
-    for path in files[: max(1, min(int(limit or 20), 100))]:
-        try:
-            text = path.read_text(encoding="utf-8", errors="replace")
-        except Exception:
-            continue
-        title, _body = _split_frontmatter_title(text)
-        try:
-            rel = path.relative_to(vault)
-            category = str(rel.parent).replace("\\", "/")
-            if category in (".", ""):
-                category = "inbox"
-            relpath = str(rel).replace("\\", "/")
-        except ValueError:
-            category = path.parent.name
-            relpath = path.name
-        results.append({
-            "title": title or path.stem,
-            "category": category,
-            "relpath": relpath,
-            "modified": time.strftime("%Y-%m-%d %H:%M", time.localtime(path.stat().st_mtime)),
-        })
-    return {"results": results, "count": len(files)}
+    records.sort(key=lambda item: (item["updated"], item["created"]), reverse=True)
+    results = []
+    for record in records[: max(1, min(int(limit or 20), 100))]:
+        item = dict(record)
+        modified = item.get("updated") or item.get("created") or ""
+        item["modified"] = modified.replace("T", " ")[:16]
+        results.append(item)
+    return {"results": results, "count": len(records)}
 
 
 # ---------- Note read / move / delete (web dashboard organizer) --------------
@@ -562,49 +921,348 @@ def _set_frontmatter_category(text: str, category: str) -> str:
 def get_note(relpath: str) -> dict:
     """Return one note's full content for the dashboard reader:
     {ok, title, category, body, source, relpath}. ok=False if not found."""
-    safe = _safe_relpath(relpath)
-    target = _vault_subpath(*safe.split("/"))
-    if not target.exists() or target.suffix.lower() != ".md":
+    target = _find_note_path(relpath, include_trash=True)
+    if target is None:
         return {"ok": False, "error": "note not found"}
-    text = target.read_text(encoding="utf-8", errors="replace")
-    title, body = _split_frontmatter_title(text)
-    category = str(Path(safe).parent).replace("\\", "/")
-    if category in (".", ""):
-        category = INBOX
+    metadata, body, _text = _ensure_note_schema(target)
+    return _note_record(target, metadata, body, include_body=True)
+
+
+def create_note(
+    *,
+    title: str = "",
+    body: str = "",
+    kind: str = "note",
+    category: str = INBOX,
+    tags: Any = None,
+    color: str = DEFAULT_COLOR,
+    due: str = "",
+    source: str = "",
+    pinned: bool = False,
+    captured_via: str = "dashboard",
+) -> dict:
+    """Create an immediately editable schema-v2 Markdown note."""
+    clean_kind = str(kind or "note").strip().lower()
+    if clean_kind not in NOTE_KINDS:
+        raise ValueError(f"invalid note kind: {kind!r}")
+    clean_category = _safe_category(category or INBOX)
+    clean_color = str(color or DEFAULT_COLOR).strip().lower()
+    if clean_color not in NOTE_COLORS:
+        clean_color = DEFAULT_COLOR
+    clean_body = str(body or "")
+    clean_title = str(title or "").strip()
+    if not clean_title:
+        clean_title = _fallback_title(clean_body, "") or "Untitled note"
+    if clean_title.lower() == "untitled":
+        clean_title = "Untitled note"
+    now = _now_iso()
+    metadata = {
+        "schema_version": SCHEMA_VERSION,
+        "note_id": uuid.uuid4().hex,
+        "title": clean_title[:120],
+        "kind": clean_kind,
+        "status": "active",
+        "category": clean_category,
+        "tags": _normalize_tags(tags),
+        "color": clean_color,
+        "pinned": bool(pinned),
+        "due": str(due or "").strip()[:32],
+        "source": str(source or "").strip(),
+        "source_app": "",
+        "captured_via": str(captured_via or "dashboard")[:40],
+        "created": now,
+        "updated": now,
+        "revision": 1,
+        "title_generated": False,
+    }
+    ts_prefix = _timestamp_prefix()
+    filename = f"{ts_prefix}-{_slugify(clean_title)}.md"
+    with _NOTES_LOCK:
+        destination = _vault_subpath(clean_category, filename)
+        if destination.exists():
+            destination = _vault_subpath(
+                clean_category,
+                f"{ts_prefix}-{_slugify(clean_title)}-{uuid.uuid4().hex[:6]}.md",
+            )
+        serialized = _yaml_frontmatter(metadata) + "\n\n" + clean_body
+        if clean_body and not clean_body.endswith("\n"):
+            serialized += "\n"
+        _atomic_write_text(destination, serialized)
+        _invalidate_index()
+        return _note_record(destination, metadata, clean_body, include_body=True)
+
+
+def update_note(note_id: str, revision: int | None, patch: dict) -> dict:
+    """Update editable note fields with optimistic revision checking."""
+    if not isinstance(patch, dict):
+        raise ValueError("note patch must be an object")
+    with _NOTES_LOCK:
+        source_path = _find_note_path(note_id, include_trash=True)
+        if source_path is None:
+            return {"ok": False, "error": "note not found"}
+        metadata, body, text = _ensure_note_schema(source_path)
+        current_revision = int(metadata.get("revision") or 1)
+        if revision is not None and int(revision) != current_revision:
+            return {
+                "ok": False,
+                "error": "note changed since it was opened",
+                "conflict": True,
+                "note": _note_record(source_path, metadata, body, include_body=True),
+            }
+
+        updates: dict[str, Any] = {}
+        new_body = body
+        if "title" in patch:
+            updates["title"] = str(patch.get("title") or "Untitled note").strip()[:120]
+            updates["title_generated"] = False
+        if "body" in patch:
+            new_body = str(patch.get("body") or "")
+        if "kind" in patch:
+            value = str(patch.get("kind") or "").strip().lower()
+            if value not in NOTE_KINDS:
+                raise ValueError(f"invalid note kind: {value!r}")
+            updates["kind"] = value
+        if "status" in patch:
+            value = str(patch.get("status") or "").strip().lower()
+            if value not in NOTE_STATUSES or value == "trashed":
+                raise ValueError(f"invalid note status: {value!r}")
+            updates["status"] = value
+        if "tags" in patch:
+            updates["tags"] = _normalize_tags(patch.get("tags"))
+        if "color" in patch:
+            value = str(patch.get("color") or DEFAULT_COLOR).strip().lower()
+            updates["color"] = value if value in NOTE_COLORS else DEFAULT_COLOR
+        if "pinned" in patch:
+            updates["pinned"] = bool(patch.get("pinned"))
+        for field in ("due", "source"):
+            if field in patch:
+                updates[field] = str(patch.get(field) or "").strip()[:500]
+
+        destination = source_path
+        if "category" in patch and metadata.get("status") != "trashed":
+            destination_category = _safe_category(str(patch.get("category") or INBOX))
+            updates["category"] = destination_category
+            destination = _vault_subpath(destination_category, source_path.name)
+            if destination.exists() and destination.resolve() != source_path.resolve():
+                destination = _vault_subpath(
+                    destination_category,
+                    f"{source_path.stem}-{uuid.uuid4().hex[:6]}{source_path.suffix}",
+                )
+
+        updates["schema_version"] = SCHEMA_VERSION
+        updates["note_id"] = str(metadata.get("note_id"))
+        updates["updated"] = _now_iso()
+        updates["revision"] = current_revision + 1
+        rewritten = _merge_frontmatter(text, updates, body=new_body)
+        _atomic_write_text(destination, rewritten)
+        if destination.resolve() != source_path.resolve() and source_path.exists():
+            source_path.unlink()
+        merged = dict(metadata)
+        merged.update(updates)
+        _invalidate_index()
+        return _note_record(destination, merged, new_body, include_body=True)
+
+
+def archive_note(note_id: str, revision: int | None = None) -> dict:
+    return update_note(note_id, revision, {"status": "archived"})
+
+
+def trash_note(note_id: str) -> dict:
+    """Move a note into the recoverable vault-local Trash."""
+    with _NOTES_LOCK:
+        source = _find_note_path(note_id, include_trash=False)
+        if source is None:
+            return {"ok": False, "error": "note not found"}
+        metadata, body, text = _ensure_note_schema(source)
+        revision = int(metadata.get("revision") or 1)
+        relpath = str(source.relative_to(_vault_dir())).replace("\\", "/")
+        updates = {
+            "status": "trashed",
+            "original_relpath": relpath,
+            "original_category": _note_category(source, metadata),
+            "updated": _now_iso(),
+            "revision": revision + 1,
+        }
+        destination = _vault_subpath(TRASH_DIR, f"{metadata['note_id']}.md")
+        rewritten = _merge_frontmatter(text, updates, body=body)
+        _atomic_write_text(destination, rewritten)
+        source.unlink()
+        merged = dict(metadata)
+        merged.update(updates)
+        _invalidate_index()
+        return _note_record(destination, merged, body, include_body=True)
+
+
+def restore_note(note_id: str) -> dict:
+    """Restore a trashed note to its previous category."""
+    with _NOTES_LOCK:
+        source = _find_note_path(note_id, include_trash=True)
+        if source is None:
+            return {"ok": False, "error": "note not found"}
+        metadata, body, text = _ensure_note_schema(source)
+        if metadata.get("status") != "trashed" and TRASH_DIR not in source.parts:
+            return {"ok": False, "error": "note is not in Trash"}
+        category = _safe_category(str(metadata.get("original_category") or INBOX))
+        original = str(metadata.get("original_relpath") or "").replace("\\", "/")
+        filename = Path(original).name if original.lower().endswith(".md") else source.name
+        if filename == f"{metadata.get('note_id')}.md":
+            filename = f"{_timestamp_prefix()}-{_slugify(str(metadata.get('title') or 'note'))}.md"
+        destination = _vault_subpath(category, filename)
+        if destination.exists():
+            destination = _vault_subpath(
+                category, f"{destination.stem}-{uuid.uuid4().hex[:6]}.md"
+            )
+        revision = int(metadata.get("revision") or 1)
+        updates = {
+            "status": "active",
+            "category": category,
+            "updated": _now_iso(),
+            "revision": revision + 1,
+        }
+        rewritten = _merge_frontmatter(text, updates, body=body)
+        _atomic_write_text(destination, rewritten)
+        source.unlink()
+        merged = dict(metadata)
+        merged.update(updates)
+        _invalidate_index()
+        return _note_record(destination, merged, body, include_body=True)
+
+
+def permanently_delete_note(note_id: str, permanent: bool = False) -> dict:
+    """Permanently remove one trashed note after an explicit permanent flag."""
+    if permanent is not True:
+        return {"ok": False, "error": "permanent confirmation required"}
+    with _NOTES_LOCK:
+        target = _find_note_path(note_id, include_trash=True)
+        if target is None:
+            return {"ok": False, "error": "note not found"}
+        metadata, _body, _text = _ensure_note_schema(target)
+        if metadata.get("status") != "trashed" or TRASH_DIR not in target.parts:
+            return {"ok": False, "error": "only notes in Trash can be permanently deleted"}
+        target.unlink()
+        _invalidate_index()
+        return {"ok": True, "deleted": True, "note_id": note_id}
+
+
+def _board_path() -> Path:
+    return _vault_subpath(FLOWKEY_DIR, BOARD_FILENAME)
+
+
+def _default_board() -> dict:
     return {
-        "ok": True,
-        "title": title or target.stem,
-        "category": category,
-        "body": body,
-        "source": _frontmatter_field(text, "source"),
-        "relpath": safe,
+        "schema_version": 1,
+        "revision": 1,
+        "title": "Vision Board",
+        "sections": [
+            {"id": "now", "title": "Now"},
+            {"id": "next", "title": "Next"},
+            {"id": "someday", "title": "Someday"},
+        ],
+        "placements": [],
     }
 
 
+def get_board() -> dict:
+    path = _board_path()
+    if not path.exists():
+        return {"ok": True, "board": _default_board()}
+    try:
+        board = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, json.JSONDecodeError):
+        log.exception("could not read Notes board")
+        return {"ok": True, "board": _default_board(), "recovered": True}
+    if not isinstance(board, dict):
+        board = _default_board()
+    board.setdefault("schema_version", 1)
+    board.setdefault("revision", 1)
+    board.setdefault("title", "Vision Board")
+    board.setdefault("sections", _default_board()["sections"])
+    board.setdefault("placements", [])
+    return {"ok": True, "board": board}
+
+
+def save_board(board: dict, revision: int | None) -> dict:
+    """Atomically save normalized board sections and note-id placements."""
+    if not isinstance(board, dict):
+        raise ValueError("board must be an object")
+    with _NOTES_LOCK:
+        current = get_board()["board"]
+        current_revision = int(current.get("revision") or 1)
+        if revision is not None and int(revision) != current_revision:
+            return {
+                "ok": False,
+                "error": "board changed since it was opened",
+                "conflict": True,
+                "board": current,
+            }
+        sections: list[dict] = []
+        section_ids: set[str] = set()
+        for raw in list(board.get("sections") or [])[:12]:
+            if not isinstance(raw, dict):
+                continue
+            section_id = re.sub(r"[^a-z0-9_-]+", "-", str(raw.get("id") or "").lower()).strip("-")
+            if not section_id or section_id in section_ids:
+                section_id = f"section-{len(sections) + 1}"
+            section_ids.add(section_id)
+            sections.append({
+                "id": section_id[:40],
+                "title": str(raw.get("title") or "Section").strip()[:60],
+            })
+        if not sections:
+            sections = _default_board()["sections"]
+            section_ids = {item["id"] for item in sections}
+        valid_note_ids = {item["note_id"] for item in _load_note_index(False)}
+        placements: list[dict] = []
+        seen_notes: set[str] = set()
+        for raw in list(board.get("placements") or [])[:500]:
+            if not isinstance(raw, dict):
+                continue
+            placed_note_id = str(raw.get("note_id") or "")
+            if not placed_note_id or placed_note_id in seen_notes or placed_note_id not in valid_note_ids:
+                continue
+            section_id = str(raw.get("section_id") or sections[0]["id"])
+            if section_id not in section_ids:
+                section_id = sections[0]["id"]
+            seen_notes.add(placed_note_id)
+            placements.append({
+                "note_id": placed_note_id,
+                "section_id": section_id,
+                "order": max(0, int(raw.get("order") or 0)),
+                "size": (
+                    raw.get("size")
+                    if raw.get("size") in {"small", "medium", "wide"}
+                    else "medium"
+                ),
+            })
+        normalized = {
+            "schema_version": 1,
+            "revision": current_revision + 1,
+            "title": str(board.get("title") or "Vision Board").strip()[:80],
+            "sections": sections,
+            "placements": placements,
+        }
+        _atomic_write_text(
+            _board_path(),
+            json.dumps(normalized, ensure_ascii=False, indent=2) + "\n",
+        )
+        return {"ok": True, "board": normalized}
+
+
 def move_note(relpath: str, category: str) -> dict:
     """Re-file a note into a different bucket folder, updating its frontmatter
     `category`. Returns {ok, relpath, category}."""
-    safe = _safe_relpath(relpath)
-    src = _vault_subpath(*safe.split("/"))
-    if not src.exists():
+    src = _find_note_path(relpath, include_trash=False)
+    if src is None:
         return {"ok": False, "error": "note not found"}
     dest_cat = _safe_category(category)
-    dest_dir = _vault_subpath(dest_cat)
-    dest = _vault_subpath(dest_cat, src.name)
-    if dest.resolve() == src.resolve():
-        return {"ok": True, "relpath": safe, "category": dest_cat}  # already there
-    _ensure_dir(dest_dir)
-    if dest.exists():
-        dest = _vault_subpath(dest_cat, f"{src.stem}-{uuid.uuid4().hex[:6]}{src.suffix}")
-    text = _set_frontmatter_category(src.read_text(encoding="utf-8", errors="replace"), dest_cat)
-    dest.write_text(text, encoding="utf-8")
-    src.unlink()
-    vault = _vault_dir().resolve()
-    try:
-        new_rel = str(dest.relative_to(vault)).replace("\\", "/")
-    except ValueError:
-        new_rel = dest.name
-    return {"ok": True, "relpath": new_rel, "category": dest_cat}
+    metadata, _body, _text = _ensure_note_schema(src)
+    if _note_category(src, metadata) == dest_cat:
+        return _note_record(src, metadata, _body)
+    return update_note(
+        str(metadata["note_id"]),
+        int(metadata.get("revision") or 1),
+        {"category": dest_cat},
+    )
 
 
 def delete_note(relpath: str) -> dict:
@@ -614,6 +1272,7 @@ def delete_note(relpath: str) -> dict:
     if not target.exists():
         return {"ok": False, "error": "note not found"}
     target.unlink()
+    _invalidate_index()
     return {"ok": True, "deleted": True}
 
 
@@ -677,7 +1336,8 @@ def _write_note(category: str, ts_prefix: str, slug: str,
     # Collision avoidance for the same-minute case.
     if target.exists():
         target = _vault_subpath(safe_cat, f"{ts_prefix}-{slug}-{uuid.uuid4().hex[:6]}.md")
-    target.write_text(_yaml_frontmatter(frontmatter) + "\n\n" + body, encoding="utf-8")
+    _atomic_write_text(target, _yaml_frontmatter(frontmatter) + "\n\n" + body)
+    _invalidate_index()
     return target
 
 
@@ -699,14 +1359,24 @@ def capture_note(text: str, source_app: str = "", url: str = "") -> dict:
     stub_slug = uuid.uuid4().hex[:8]
 
     frontmatter = {
+        "schema_version": SCHEMA_VERSION,
+        "note_id": note_id,
         "title": "(categorizing…)",
         "created": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(ts)),
+        "updated": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(ts)),
+        "revision": 1,
+        "kind": "link" if is_url_only else "note",
+        "status": "active",
+        "tags": [],
+        "color": DEFAULT_COLOR,
+        "pinned": False,
+        "due": "",
         "source": url or "",
         "source_app": source_app,
         "category": INBOX,
         "captured_via": "url" if is_url_only else "selection",
         "fetch_status": "pending" if is_url_only else "n/a",
-        "note_id": note_id,
+        "title_generated": True,
     }
     body = _build_body(text=text if not is_url_only else "",
                        url=url, fetched=None, categorized=None) or "(content pending)\n"
@@ -737,42 +1407,69 @@ def _categorize_in_background(stub_path: Path, note_id: str, text: str,
             fetched_body=(fetched or {}).get("body", "") if fetched else "",
         )
 
-        # Rebuild file in its final form.
-        target_category = categorized["category"]
-        title = categorized["title"]
-        ts_prefix = stub_path.name.split("-")[0:4]
-        ts_prefix = "-".join(ts_prefix) if len(ts_prefix) >= 4 else _timestamp_prefix()
-        slug = _slugify(title)
-
-        frontmatter = {
-            "title": title,
-            "created": _read_frontmatter_field(stub_path, "created") or time.strftime("%Y-%m-%dT%H:%M:%S"),
-            "source": url or "",
-            "source_app": source_app,
-            "category": target_category,
-            "captured_via": "url" if is_url_only else "selection",
-            "fetch_status": (fetched or {}).get("error") and "error" or
-                            ((fetched or {}).get("ok") and "ok") or "n/a",
-            "confidence": categorized["confidence"],
-            "note_id": note_id,
-        }
-        if fetched and fetched.get("error"):
-            frontmatter["fetch_error"] = fetched["error"]
-        if fetched and fetched.get("http_status"):
-            frontmatter["http_status"] = fetched["http_status"]
-
-        body = _build_body(text=text if not is_url_only else "",
-                           url=url, fetched=fetched, categorized=categorized)
-
-        # Write to final location, delete stub.
-        final_path = _write_note(target_category, ts_prefix, slug, frontmatter, body)
-        if stub_path.exists() and stub_path.resolve() != final_path.resolve():
-            try:
-                stub_path.unlink()
-            except Exception:
-                pass
+        # Enrichment patches metadata and untouched placeholders only. It never
+        # rebuilds user-authored content, so an edit made while the model runs
+        # cannot be lost.
+        with _NOTES_LOCK:
+            current_path = _find_note_path(note_id, include_trash=True)
+            if current_path is None and stub_path.exists():
+                current_path = stub_path
+            if current_path is None:
+                return
+            metadata, body, raw = _ensure_note_schema(current_path)
+            if metadata.get("status") == "trashed":
+                return
+            current_revision = int(metadata.get("revision") or 1)
+            updates: dict[str, Any] = {
+                "confidence": categorized["confidence"],
+                "suggested_category": categorized["category"],
+                "summary": categorized["summary"] if _wants_summary() else "",
+                "fetch_status": (
+                    "error" if fetched and fetched.get("error")
+                    else "ok" if fetched and fetched.get("ok")
+                    else "n/a"
+                ),
+                "updated": _now_iso(),
+                "revision": current_revision + 1,
+            }
+            if bool(metadata.get("title_generated", True)):
+                updates["title"] = categorized["title"]
+                updates["title_generated"] = True
+            if fetched and fetched.get("error"):
+                updates["fetch_error"] = fetched["error"]
+            if fetched and fetched.get("http_status"):
+                updates["http_status"] = fetched["http_status"]
+
+            final_body = body
+            if is_url_only and "(content pending)" in body:
+                final_body = _build_body(
+                    text="", url=url, fetched=fetched, categorized=None
+                )
+
+            target_category = _note_category(current_path, metadata)
+            if target_category == INBOX and categorized["category"] != INBOX:
+                target_category = categorized["category"]
+                updates["category"] = target_category
+            title = str(updates.get("title") or metadata.get("title") or "Untitled note")
+            destination = current_path
+            if target_category != _note_category(current_path, metadata):
+                ts_prefix = "-".join(stub_path.name.split("-")[0:4])
+                if len(ts_prefix) < 15:
+                    ts_prefix = _timestamp_prefix()
+                destination = _vault_subpath(
+                    target_category, f"{ts_prefix}-{_slugify(title)}.md"
+                )
+                if destination.exists() and destination.resolve() != current_path.resolve():
+                    destination = _vault_subpath(
+                        target_category,
+                        f"{ts_prefix}-{_slugify(title)}-{uuid.uuid4().hex[:6]}.md",
+                    )
+            rewritten = _merge_frontmatter(raw, updates, body=final_body)
+            _atomic_write_text(destination, rewritten)
+            if destination.resolve() != current_path.resolve() and current_path.exists():
+                current_path.unlink()
+            _invalidate_index()
 
-        # Toast result.
         if target_category == INBOX:
             msg = f"📥 Saved to inbox/ — {title}"
         else:
diff --git a/tests/test_notes_workspace.py b/tests/test_notes_workspace.py
new file mode 100644
index 0000000..e66d48e
--- /dev/null
+++ b/tests/test_notes_workspace.py
@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+
+import notes
+import pytest
+
+
+@pytest.fixture
+def vault(tmp_path, monkeypatch):
+    monkeypatch.setattr(notes, "_vault_dir", lambda: tmp_path)
+    notes._invalidate_index()
+    return tmp_path
+
+
+def _legacy_note(vault, relpath="inbox/legacy.md", body="Original body\n"):
+    path = vault / relpath
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "---\n"
+        'title: "Legacy"\n'
+        "custom_plugin_field: keep-me\n"
+        "---\n\n"
+        + body,
+        encoding="utf-8",
+    )
+    return path
+
+
+def test_v51_migration_preserves_body_unknown_metadata_and_backup(vault):
+    path = _legacy_note(vault)
+
+    note = notes.get_note("inbox/legacy.md")
+
+    assert note["ok"] is True
+    assert note["body"] == "Original body\n"
+    migrated = path.read_text(encoding="utf-8")
+    assert "schema_version: 2" in migrated
+    assert "custom_plugin_field: keep-me" in migrated
+    assert "Original body\n" in migrated
+    backup = vault / ".flowkey" / "backups" / "v1" / "inbox" / "legacy.md.bak"
+    assert backup.exists()
+    assert "schema_version" not in backup.read_text(encoding="utf-8")
+
+
+def test_v48_stable_note_id_survives_category_move(vault):
+    _legacy_note(vault)
+    before = notes.get_note("inbox/legacy.md")
+
+    moved = notes.move_note(before["note_id"], "ideas")
+
+    assert moved["note_id"] == before["note_id"]
+    assert moved["category"] == "ideas"
+    assert notes.get_note(before["note_id"])["relpath"].startswith("ideas/")
+
+
+def test_v54_create_update_and_stale_revision_conflict(vault):
+    created = notes.create_note(title="Release", body="Plan it", kind="task")
+
+    updated = notes.update_note(
+        created["note_id"],
+        created["revision"],
+        {"body": "Ship it", "tags": ["Flowkey", "2.5"], "pinned": True},
+    )
+    conflict = notes.update_note(
+        created["note_id"],
+        created["revision"],
+        {"body": "Overwrite"},
+    )
+
+    assert updated["body"] == "Ship it"
+    assert updated["tags"] == ["flowkey", "2.5"]
+    assert updated["pinned"] is True
+    assert conflict["conflict"] is True
+    assert notes.get_note(created["note_id"])["body"] == "Ship it"
+    assert not list(vault.rglob("*.tmp"))
+
+
+def test_v50_trash_restore_and_explicit_permanent_delete(vault):
+    created = notes.create_note(title="Recover me", body="x", category="ideas")
+
+    trashed = notes.trash_note(created["note_id"])
+    denied = notes.permanently_delete_note(created["note_id"], permanent=False)
+    restored = notes.restore_note(created["note_id"])
+    notes.trash_note(created["note_id"])
+    deleted = notes.permanently_delete_note(created["note_id"], permanent=True)
+
+    assert trashed["status"] == "trashed"
+    assert denied["ok"] is False
+    assert restored["status"] == "active"
+    assert restored["category"] == "ideas"
+    assert deleted["deleted"] is True
+    assert notes.get_note(created["note_id"])["ok"] is False
+
+
+def test_query_filters_kinds_tags_and_returns_facets(vault):
+    notes.create_note(title="Task", body="Ship release", kind="task", tags=["release"])
+    notes.create_note(title="Idea", body="Vision", kind="idea", tags=["future"])
+    notes.create_note(title="Link", body="Read", kind="read_later", source="https://example.com")
+
+    result = notes.query_notes(kind="task", tag="release")
+
+    assert result["count"] == 1
+    assert result["results"][0]["title"] == "Task"
+    assert result["facets"]["counts"]["tasks"] == 1
+    assert result["facets"]["counts"]["ideas"] == 1
+    assert result["facets"]["counts"]["links"] == 1
+
+
+def test_v52_board_references_notes_without_mutating_them(vault):
+    first = notes.create_note(title="First", body="A")
+    second = notes.create_note(title="Second", body="B")
+    original_body = notes.get_note(first["note_id"])["body"]
+    current = notes.get_board()["board"]
+    board = dict(current)
+    board["placements"] = [
+        {"note_id": first["note_id"], "section_id": "now", "order": 0},
+        {"note_id": second["note_id"], "section_id": "next", "order": 0},
+        {"note_id": "missing", "section_id": "now", "order": 1},
+    ]
+
+    saved = notes.save_board(board, current["revision"])
+
+    assert saved["ok"] is True
+    assert [item["note_id"] for item in saved["board"]["placements"]] == [
+        first["note_id"],
+        second["note_id"],
+    ]
+    assert notes.get_note(first["note_id"])["body"] == original_body
+    raw = json.loads((vault / ".flowkey" / "board.json").read_text(encoding="utf-8"))
+    assert raw["revision"] == 2
+
+
+def test_board_rejects_stale_revision(vault):
+    current = notes.get_board()["board"]
+    saved = notes.save_board(current, current["revision"])
+
+    conflict = notes.save_board(current, current["revision"])
+
+    assert saved["ok"] is True
+    assert conflict["conflict"] is True

From ed6e6bb994eef3595e18140551fac2f882e7435f Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:33:16 -0400
Subject: [PATCH 02/12] T32: expose Notes v2 daemon actions

Cites V1, V2, V3, V7, V48, V50, V53, V54.
---
 SPEC.md                            |   2 +-
 scripts/ffp_daemon.py              | 151 ++++++++++++++++++++++++++++-
 tests/test_ffp_daemon.py           |  10 +-
 tests/test_notes_daemon_actions.py |  93 ++++++++++++++++++
 4 files changed, 248 insertions(+), 8 deletions(-)
 create mode 100644 tests/test_notes_daemon_actions.py

diff --git a/SPEC.md b/SPEC.md
index cda407f..2a017f2 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -151,7 +151,7 @@ T30|x|clarify shape for underspecified requests + typo/article normalization + R
 T29|x|bench memory guard + keep-warm/bench mutual exclusion + provider-error surfacing (2.4.2)|V41,V42,V43
 T28|x|model picker 2.4.1: footprint/MoE sizing + never-hide + active-model health + merged single Models card + app-styled combobox|V38,V39,V40
 T31|x|Notes schema v2 repository: stable ids, zero-loss migration, CRUD, Trash, indexed query, atomic board store|V7,V48,V49,V50,V51,V52,V54
-T32|.|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
+T32|x|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
 T33|.|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
 T34|.|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55
 T35|.|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
diff --git a/scripts/ffp_daemon.py b/scripts/ffp_daemon.py
index b9eaa61..720ebbb 100644
--- a/scripts/ffp_daemon.py
+++ b/scripts/ffp_daemon.py
@@ -117,6 +117,7 @@ def _popen_logged(name: str, argv: list[str], **kwargs) -> subprocess.Popen:
 
 _paths.ensure_dirs()
 LOG_DIR = _paths.LOGS_DIR  # centralized via paths.py
+_NOTE_STAGED_PATH = _paths.DATA_DIR / ".note_staged.json"
 
 log = logging.getLogger("ffp.daemon")
 
@@ -603,6 +604,26 @@ def _act_notes_list(args: dict) -> dict:
     return notes.list_recent_notes(limit)
 
 
+def _act_notes_query(args: dict) -> dict:
+    """Filterable schema-v2 Notes workspace feed."""
+    import notes
+    try:
+        limit = int(args.get("limit") or 50)
+        offset = int(args.get("offset") or 0)
+    except (TypeError, ValueError):
+        limit, offset = 50, 0
+    return notes.query_notes(
+        str(args.get("query") or ""),
+        kind=str(args.get("kind") or ""),
+        status=str(args.get("status") or ""),
+        category=str(args.get("category") or ""),
+        tag=str(args.get("tag") or ""),
+        sort=str(args.get("sort") or "updated"),
+        limit=limit,
+        offset=offset,
+    )
+
+
 def _act_note_search(args: dict) -> dict:
     """Search the notes vault. args.query (str), args.limit (int, default 5)."""
     import notes
@@ -646,21 +667,131 @@ def _act_save_note(args: dict) -> dict:
 def _act_note_get(args: dict) -> dict:
     """Read one note's full content for the dashboard reader."""
     import notes
-    return notes.get_note(str(args.get("relpath") or args.get("path") or ""))
+    return notes.get_note(str(
+        args.get("note_id") or args.get("relpath") or args.get("path") or ""
+    ))
+
+
+def _act_note_create(args: dict) -> dict:
+    import notes
+    return notes.create_note(
+        title=str(args.get("title") or ""),
+        body=str(args.get("body") or ""),
+        kind=str(args.get("kind") or "note"),
+        category=str(args.get("category") or "inbox"),
+        tags=args.get("tags"),
+        color=str(args.get("color") or notes.DEFAULT_COLOR),
+        due=str(args.get("due") or ""),
+        source=str(args.get("source") or ""),
+        pinned=bool(args.get("pinned")),
+        captured_via=str(args.get("captured_via") or "dashboard"),
+    )
+
+
+def _act_note_update(args: dict) -> dict:
+    import notes
+    raw_revision = args.get("revision")
+    try:
+        revision = int(raw_revision) if raw_revision is not None else None
+    except (TypeError, ValueError):
+        raise ValueError("revision must be an integer") from None
+    return notes.update_note(
+        str(args.get("note_id") or ""),
+        revision,
+        args.get("patch") if isinstance(args.get("patch"), dict) else {},
+    )
+
+
+def _act_note_archive(args: dict) -> dict:
+    import notes
+    raw_revision = args.get("revision")
+    revision = int(raw_revision) if raw_revision is not None else None
+    return notes.archive_note(str(args.get("note_id") or ""), revision)
+
+
+def _act_note_trash(args: dict) -> dict:
+    import notes
+    return notes.trash_note(str(args.get("note_id") or ""))
+
+
+def _act_note_restore(args: dict) -> dict:
+    import notes
+    return notes.restore_note(str(args.get("note_id") or ""))
 
 
 def _act_note_move(args: dict) -> dict:
     """Re-file a note into a different bucket (updates frontmatter category)."""
     import notes
-    return notes.move_note(str(args.get("relpath") or ""), str(args.get("category") or ""))
+    return notes.move_note(
+        str(args.get("note_id") or args.get("relpath") or ""),
+        str(args.get("category") or ""),
+    )
 
 
 def _act_note_delete(args: dict) -> dict:
-    """Delete a note from the vault."""
+    """Legacy relpath delete, or explicit permanent deletion from v2 Trash."""
     import notes
+    note_id = str(args.get("note_id") or "")
+    if note_id:
+        if bool(args.get("permanent")):
+            return notes.permanently_delete_note(note_id, permanent=True)
+        return notes.trash_note(note_id)
     return notes.delete_note(str(args.get("relpath") or ""))
 
 
+def _act_notes_board_get(_args: dict) -> dict:
+    import notes
+    return notes.get_board()
+
+
+def _act_notes_board_save(args: dict) -> dict:
+    import notes
+    raw_revision = args.get("revision")
+    revision = int(raw_revision) if raw_revision is not None else None
+    return notes.save_board(
+        args.get("board") if isinstance(args.get("board"), dict) else {},
+        revision,
+    )
+
+
+def _act_note_stage_capture(args: dict) -> dict:
+    """Atomically stage selected or blank text for the Notes composer."""
+    payload = {
+        "text": str(args.get("text") or ""),
+        "source_app": str(args.get("source_app") or ""),
+        "staged_at": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()),
+    }
+    _NOTE_STAGED_PATH.parent.mkdir(parents=True, exist_ok=True)
+    temp = _NOTE_STAGED_PATH.with_name(
+        f".{_NOTE_STAGED_PATH.name}.{threading.get_ident()}.tmp"
+    )
+    try:
+        temp.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        temp.replace(_NOTE_STAGED_PATH)
+    finally:
+        if temp.exists():
+            with contextlib.suppress(OSError):
+                temp.unlink()
+    return {"ok": True, "chars": len(payload["text"]), "staged": True}
+
+
+def _act_note_take_staged(_args: dict) -> dict:
+    if not _NOTE_STAGED_PATH.exists():
+        return {"text": "", "source_app": "", "staged": False}
+    try:
+        payload = json.loads(_NOTE_STAGED_PATH.read_text(encoding="utf-8"))
+    except (OSError, ValueError, json.JSONDecodeError):
+        payload = {}
+    with contextlib.suppress(OSError):
+        _NOTE_STAGED_PATH.unlink()
+    return {
+        "text": str(payload.get("text") or ""),
+        "source_app": str(payload.get("source_app") or ""),
+        "staged_at": str(payload.get("staged_at") or ""),
+        "staged": True,
+    }
+
+
 def _act_notify(args: dict) -> str:
     title = str(args.get("title") or "").strip() or "Flowkey"
     message = str(args.get("message") or "").strip()
@@ -884,9 +1015,19 @@ def _act_meeting_week_summary(args: dict) -> dict:
     "bench_history": _act_bench_history,
     "note_search": _act_note_search,
     "notes_list": _act_notes_list,
+    "notes_query": _act_notes_query,
     "note_get": _act_note_get,
+    "note_create": _act_note_create,
+    "note_update": _act_note_update,
+    "note_archive": _act_note_archive,
+    "note_trash": _act_note_trash,
+    "note_restore": _act_note_restore,
     "note_move": _act_note_move,
     "note_delete": _act_note_delete,
+    "notes_board_get": _act_notes_board_get,
+    "notes_board_save": _act_notes_board_save,
+    "note_stage_capture": _act_note_stage_capture,
+    "note_take_staged": _act_note_take_staged,
     "mode_ids": _act_mode_ids,
     "pull_start": _act_pull_start,
     "pull_status": _act_pull_status,
@@ -929,7 +1070,9 @@ def _act_meeting_week_summary(args: dict) -> dict:
     "pull_model", "remove_model", "apply_config_patch", "update_apply",
     "set_autostart", "bench_start", "pull_start",
     "chat_send", "chat_thread_delete", "chat_stage_selection", "chat_take_staged",
-    "note_move", "note_delete",
+    "note_create", "note_update", "note_archive", "note_trash", "note_restore",
+    "note_move", "note_delete", "notes_board_save",
+    "note_stage_capture", "note_take_staged",
     "notify_gate",  # writes the notifications log + updates dedupe state
 }
 
diff --git a/tests/test_ffp_daemon.py b/tests/test_ffp_daemon.py
index 6e59a4c..f453051 100644
--- a/tests/test_ffp_daemon.py
+++ b/tests/test_ffp_daemon.py
@@ -76,11 +76,15 @@ def test_actions_count_and_expected_names(daemon_module):
     # meeting_digests_list/meeting_process/meeting_batch_run/meeting_batch_status/
     # meeting_ask -> 69; meeting_overview -> 70; meeting_actions_list /
     # meeting_action_set_status / meeting_week_summary -> 73; meeting_redigest
-    # (strict re-run of a digest) -> 74; prompt_builder_preview -> 75.
-    assert len(daemon_module.ACTIONS) == 75
+    # (strict re-run of a digest) -> 74; prompt_builder_preview -> 75;
+    # Notes v2 query/CRUD/Trash/board/staging adds 10 -> 85.
+    assert len(daemon_module.ACTIONS) == 85
     for a in ("chat_threads_list", "chat_thread_get", "chat_send",
               "chat_thread_delete", "chat_stage_selection", "chat_take_staged",
-              "note_get", "note_move", "note_delete",
+              "note_get", "note_move", "note_delete", "notes_query",
+              "note_create", "note_update", "note_archive", "note_trash",
+              "note_restore", "notes_board_get", "notes_board_save",
+              "note_stage_capture", "note_take_staged",
               "notify_gate", "notifications_log",
               "quill_status", "quill_search_meetings", "meeting_digest_get",
               "meeting_digests_list", "meeting_process", "meeting_batch_run",
diff --git a/tests/test_notes_daemon_actions.py b/tests/test_notes_daemon_actions.py
new file mode 100644
index 0000000..89b939c
--- /dev/null
+++ b/tests/test_notes_daemon_actions.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import ffp_daemon
+import notes
+import pytest
+
+
+@pytest.fixture
+def vault(tmp_path, monkeypatch):
+    monkeypatch.setattr(notes, "_vault_dir", lambda: tmp_path / "vault")
+    notes._invalidate_index()
+    return tmp_path / "vault"
+
+
+def test_notes_v2_daemon_crud_and_trash(vault):
+    created = ffp_daemon._act_note_create({
+        "title": "Ship 2.5",
+        "body": "Finish Notes",
+        "kind": "task",
+        "tags": ["release"],
+    })
+    queried = ffp_daemon._act_notes_query({"kind": "task"})
+    updated = ffp_daemon._act_note_update({
+        "note_id": created["note_id"],
+        "revision": created["revision"],
+        "patch": {"status": "done"},
+    })
+    trashed = ffp_daemon._act_note_trash({"note_id": created["note_id"]})
+    trash_query = ffp_daemon._act_notes_query({"status": "trashed"})
+    restored = ffp_daemon._act_note_restore({"note_id": created["note_id"]})
+
+    assert queried["count"] == 1
+    assert updated["status"] == "done"
+    assert trashed["status"] == "trashed"
+    assert trash_query["results"][0]["note_id"] == created["note_id"]
+    assert restored["status"] == "active"
+
+
+def test_note_delete_by_id_is_recoverable_unless_permanent(vault):
+    created = ffp_daemon._act_note_create({"title": "Keep", "body": "x"})
+
+    removed = ffp_daemon._act_note_delete({"note_id": created["note_id"]})
+    denied = ffp_daemon._act_note_delete({
+        "note_id": created["note_id"],
+        "permanent": False,
+    })
+    deleted = ffp_daemon._act_note_delete({
+        "note_id": created["note_id"],
+        "permanent": True,
+    })
+
+    assert removed["status"] == "trashed"
+    assert denied["ok"] is False
+    assert deleted["deleted"] is True
+
+
+def test_note_stage_capture_supports_selection_and_blank(tmp_path, monkeypatch):
+    staged_path = tmp_path / ".note_staged.json"
+    monkeypatch.setattr(ffp_daemon, "_NOTE_STAGED_PATH", staged_path)
+
+    selection = ffp_daemon._act_note_stage_capture({
+        "text": "selected",
+        "source_app": "chrome.exe",
+    })
+    taken_selection = ffp_daemon._act_note_take_staged({})
+    ffp_daemon._act_note_stage_capture({"text": "", "source_app": ""})
+    taken_blank = ffp_daemon._act_note_take_staged({})
+    empty = ffp_daemon._act_note_take_staged({})
+
+    assert selection == {"ok": True, "chars": 8, "staged": True}
+    assert taken_selection["text"] == "selected"
+    assert taken_selection["source_app"] == "chrome.exe"
+    assert taken_blank["staged"] is True
+    assert taken_blank["text"] == ""
+    assert empty["staged"] is False
+
+
+def test_notes_board_daemon_round_trip(vault):
+    note = ffp_daemon._act_note_create({"title": "Board card", "body": "x"})
+    current = ffp_daemon._act_notes_board_get({})["board"]
+    current["placements"] = [{
+        "note_id": note["note_id"],
+        "section_id": "now",
+        "order": 0,
+    }]
+
+    saved = ffp_daemon._act_notes_board_save({
+        "revision": current["revision"],
+        "board": current,
+    })
+
+    assert saved["ok"] is True
+    assert saved["board"]["placements"][0]["note_id"] == note["note_id"]

From 015164b72698c37f5aeac57cdaa1ff6346887483 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:36:05 -0400
Subject: [PATCH 03/12] T33: move Notes settings into Config

Cites V3 and V47.
---
 SPEC.md                             |  2 +-
 scripts/ui/web/app.js               | 65 +++++++++++++----------------
 scripts/ui/web/index.html           | 54 +++++++++++-------------
 tests/test_notes_config_location.py | 36 ++++++++++++++++
 4 files changed, 90 insertions(+), 67 deletions(-)
 create mode 100644 tests/test_notes_config_location.py

diff --git a/SPEC.md b/SPEC.md
index 2a017f2..f39bafb 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -152,7 +152,7 @@ T29|x|bench memory guard + keep-warm/bench mutual exclusion + provider-error sur
 T28|x|model picker 2.4.1: footprint/MoE sizing + never-hide + active-model health + merged single Models card + app-styled combobox|V38,V39,V40
 T31|x|Notes schema v2 repository: stable ids, zero-loss migration, CRUD, Trash, indexed query, atomic board store|V7,V48,V49,V50,V51,V52,V54
 T32|x|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
-T33|.|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
+T33|x|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
 T34|.|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55
 T35|.|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
 T36|.|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
diff --git a/scripts/ui/web/app.js b/scripts/ui/web/app.js
index a58d8be..ea8a567 100644
--- a/scripts/ui/web/app.js
+++ b/scripts/ui/web/app.js
@@ -669,47 +669,35 @@ async function loadNotes() {
   browseNotes();
   try {
     const cfg = await action("config_snapshot");
-    const notes = cfg.notes || {};
-    notesCategories = notes.categories || [];
-    $("notes-vault").value = notes.vault_dir || "";
-    $("notes-categories").value = (notes.categories || []).join("\n");
-    $("notes-fetch-timeout").value = notes.fetch_timeout_seconds ?? 8;
-    $("notes-max-chars").value = notes.max_extracted_chars ?? 2000;
-    $("notes-low-conf").checked = notes.low_confidence_to_inbox !== false;
-    $("notes-gen-title").checked = notes.generate_title !== false;
-    $("notes-gen-summary").checked = notes.generate_summary !== false;
-    setStatus("notes-status", "");
-  } catch (e) {
-    setStatus("notes-status", `Load failed: ${e.message}`, false);
-  }
+    notesCategories = (cfg.notes || {}).categories || [];
+  } catch (_e) {}
+}
+
+function populateNotesConfig(notes) {
+  const cfg = notes || {};
+  $("notes-vault").value = cfg.vault_dir || "";
+  $("notes-categories").value = (cfg.categories || []).join("\n");
+  $("notes-fetch-timeout").value = cfg.fetch_timeout_seconds ?? 8;
+  $("notes-max-chars").value = cfg.max_extracted_chars ?? 2000;
+  $("notes-low-conf").checked = cfg.low_confidence_to_inbox !== false;
+  $("notes-gen-title").checked = cfg.generate_title !== false;
+  $("notes-gen-summary").checked = cfg.generate_summary !== false;
 }
 
-async function saveNotes() {
+function notesConfigPatch() {
   const categories = $("notes-categories").value
     .split("\n")
     .map((line) => line.trim().replace(/^\/+|\/+$/g, ""))
     .filter(Boolean);
-  if (categories.length === 0) {
-    setStatus("notes-status", "⚠ Category list cannot be empty.", false);
-    return;
-  }
-  const patch = {
-    notes: {
-      vault_dir: $("notes-vault").value.trim(),
-      categories,
-      fetch_timeout_seconds: Number($("notes-fetch-timeout").value) || 8,
-      max_extracted_chars: Number($("notes-max-chars").value) || 2000,
-      low_confidence_to_inbox: $("notes-low-conf").checked,
-      generate_title: $("notes-gen-title").checked,
-      generate_summary: $("notes-gen-summary").checked,
-    },
+  return {
+    vault_dir: $("notes-vault").value.trim(),
+    categories,
+    fetch_timeout_seconds: Number($("notes-fetch-timeout").value) || 8,
+    max_extracted_chars: Number($("notes-max-chars").value) || 2000,
+    low_confidence_to_inbox: $("notes-low-conf").checked,
+    generate_title: $("notes-gen-title").checked,
+    generate_summary: $("notes-gen-summary").checked,
   };
-  try {
-    const out = await action("apply_config_patch", { patch });
-    setStatus("notes-status", `✅ Saved (${out}).`);
-  } catch (e) {
-    setStatus("notes-status", `⚠ Save failed: ${e.message}`, false);
-  }
 }
 
 // ---- Config ----------------------------------------------------------------
@@ -884,6 +872,7 @@ async function loadConfig() {
     populatePromptBuilder(cfg.prompt_builder || {});
     const tone = (cfg.tone || {}).preset || "formal";
     document.querySelectorAll('input[name="tone"]').forEach((r) => (r.checked = r.value === tone));
+    populateNotesConfig(cfg.notes || {});
     populateNotifications(cfg.notifications || {});
     populateMeetings(cfg.meetings || {});
     setStatus("config-status", "");
@@ -1195,6 +1184,11 @@ async function loadFlmVersion(force) {
 }
 
 async function saveConfig() {
+  const notesPatch = notesConfigPatch();
+  if (notesPatch.categories.length === 0) {
+    setStatus("config-status", "⚠ Notes categories cannot be empty.", false);
+    return;
+  }
   const hotkeys = {
     grammar_fix: $("hk-in-grammar").value.trim(),
     open_chat: $("hk-in-chat").value.trim(),
@@ -1240,6 +1234,7 @@ async function saveConfig() {
     prompt_builder: promptBuilderPatch(),
     modes: { tone: { preset: tone ? tone.value : "formal" } },
     hotkeys,
+    notes: notesPatch,
     notifications: notificationsPatch(),
     meetings: meetingsPatch(),
   };
@@ -2036,8 +2031,6 @@ document.addEventListener("DOMContentLoaded", () => {
   $("note-query").addEventListener("keydown", (e) => {
     if (e.key === "Enter") browseNotes();
   });
-  $("notes-save").addEventListener("click", saveNotes);
-  $("notes-revert").addEventListener("click", loadNotes);
   $("nr-move").addEventListener("click", moveNoteToBucket);
   $("nr-delete").addEventListener("click", deleteCurrentNote);
   $("nr-close").addEventListener("click", () => { $("note-reader").hidden = true; });
diff --git a/scripts/ui/web/index.html b/scripts/ui/web/index.html
index 57197ea..0ad399e 100644
--- a/scripts/ui/web/index.html
+++ b/scripts/ui/web/index.html
@@ -180,36 +180,6 @@ <h2 id="nr-title" class="nr-title">Note</h2>
         </div>
         <pre class="note-body" id="nr-body"></pre>
       </div>
-      <div class="card card-wide">
-        <h2>Vault</h2>
-        <div class="form-row">
-          <label for="notes-vault">Vault directory</label>
-          <input type="text" id="notes-vault">
-        </div>
-      </div>
-      <div class="card card-wide">
-        <h2>Categories <span class="muted small">(one per line — the LLM picks from this list)</span></h2>
-        <textarea id="notes-categories" rows="7" spellcheck="false"></textarea>
-      </div>
-      <div class="card card-wide">
-        <h2>LLM behavior</h2>
-        <div class="form-row">
-          <label for="notes-fetch-timeout">Fetch timeout (s)</label>
-          <input type="number" id="notes-fetch-timeout" min="1" max="120">
-        </div>
-        <div class="form-row">
-          <label for="notes-max-chars">Max extracted chars</label>
-          <input type="number" id="notes-max-chars" min="100" max="100000">
-        </div>
-        <label class="check-row"><input type="checkbox" id="notes-low-conf"> Low-confidence categorizations stay in inbox/ instead of being auto-filed</label>
-        <label class="check-row"><input type="checkbox" id="notes-gen-title"> Generate title via LLM</label>
-        <label class="check-row"><input type="checkbox" id="notes-gen-summary"> Generate summary via LLM</label>
-      </div>
-      <div class="card-actions card-wide">
-        <button class="btn btn-primary" id="notes-save">Save notes settings</button>
-        <button class="btn" id="notes-revert">Revert</button>
-        <span class="muted" id="notes-status"></span>
-      </div>
     </div>
   </section>
 
@@ -292,6 +262,30 @@ <h2>Hotkeys</h2>
         <div class="form-row"><label for="hk-in-ask">Ask in Chat</label><input type="text" id="hk-in-ask" class="mono"></div>
         <p class="muted small">Saving applies to the running app within a second (no restart).</p>
       </div>
+      <div class="card card-wide" id="config-notes">
+        <h2>Notes &amp; capture</h2>
+        <p class="muted small">Storage, organization, and optional local-model enrichment for the Notes workspace.</p>
+        <h3 class="subhead">Storage</h3>
+        <div class="form-row">
+          <label for="notes-vault">Vault directory</label>
+          <input type="text" id="notes-vault">
+        </div>
+        <h3 class="subhead">Organization</h3>
+        <label for="notes-categories">Categories <span class="muted small">(one per line)</span></label>
+        <textarea id="notes-categories" rows="6" spellcheck="false"></textarea>
+        <h3 class="subhead">Link extraction &amp; enrichment</h3>
+        <div class="form-row">
+          <label for="notes-fetch-timeout">Fetch timeout (s)</label>
+          <input type="number" id="notes-fetch-timeout" min="1" max="120">
+        </div>
+        <div class="form-row">
+          <label for="notes-max-chars">Max extracted chars</label>
+          <input type="number" id="notes-max-chars" min="100" max="100000">
+        </div>
+        <label class="check-row"><input type="checkbox" id="notes-low-conf"> Keep low-confidence categorizations in Inbox</label>
+        <label class="check-row"><input type="checkbox" id="notes-gen-title"> Suggest titles with the local model</label>
+        <label class="check-row"><input type="checkbox" id="notes-gen-summary"> Generate summaries with the local model</label>
+      </div>
       <div class="card">
         <h2>LLM provider &amp; server</h2>
         <div class="form-row">
diff --git a/tests/test_notes_config_location.py b/tests/test_notes_config_location.py
new file mode 100644
index 0000000..bdf96e3
--- /dev/null
+++ b/tests/test_notes_config_location.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "scripts" / "ui" / "web"
+NOTE_SETTING_IDS = {
+    "notes-vault",
+    "notes-categories",
+    "notes-fetch-timeout",
+    "notes-max-chars",
+    "notes-low-conf",
+    "notes-gen-title",
+    "notes-gen-summary",
+}
+
+
+def test_v47_note_settings_live_only_in_config_tab():
+    html = (WEB / "index.html").read_text(encoding="utf-8")
+    notes_panel = html.split('id="tab-notes"', 1)[1].split('id="tab-meetings"', 1)[0]
+    config_panel = html.split('id="tab-config"', 1)[1].split('id="tab-benchmark"', 1)[0]
+
+    for setting_id in NOTE_SETTING_IDS:
+        assert f'id="{setting_id}"' not in notes_panel
+        assert f'id="{setting_id}"' in config_panel
+    assert 'id="config-notes"' in config_panel
+    assert "Save notes settings" not in html
+
+
+def test_notes_settings_use_config_single_save_flow():
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+
+    assert "populateNotesConfig(cfg.notes || {})" in app
+    assert "notes: notesPatch" in app
+    assert "function saveNotes" not in app
+    assert '"notes-save"' not in app

From 0f6ab372c060ba5791eeddebfd780359bd1f9af2 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:52:24 -0400
Subject: [PATCH 04/12] T34: build living Notes workspace and vision board

Cites V5, V47, V48, V50, V52, V54, V55, V56.
---
 SPEC.md                             |   4 +-
 scripts/ui/web/app.js               | 866 +++++++++++++++++++++++++---
 scripts/ui/web/index.html           | 171 +++++-
 scripts/ui/web/styles.css           | 439 +++++++++++++-
 tests/test_notes_config_location.py |   2 +-
 tests/test_notes_workspace_ui.py    |  77 +++
 6 files changed, 1434 insertions(+), 125 deletions(-)
 create mode 100644 tests/test_notes_workspace_ui.py

diff --git a/SPEC.md b/SPEC.md
index f39bafb..9383b29 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -115,6 +115,7 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - V53: capture hotkey w/ selection → staged prefill; ⊥ selection → blank composer; stale clipboard ⊥ silent capture
 - V54: note writes + board writes atomic; stale `revision` → conflict, ⊥ overwrite
 - V55: note card/editor controls keyboard reachable; desktop split workspace + ≤720px stacked layout
+- V56: note `due` date-only value renders same calendar day ∀ timezone; ⊥ UTC date shift
 
 ## §T tasks
 
@@ -153,7 +154,7 @@ T28|x|model picker 2.4.1: footprint/MoE sizing + never-hide + active-model healt
 T31|x|Notes schema v2 repository: stable ids, zero-loss migration, CRUD, Trash, indexed query, atomic board store|V7,V48,V49,V50,V51,V52,V54
 T32|x|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
 T33|x|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
-T34|.|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55
+T34|x|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55,V56
 T35|.|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
 T36|.|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 ```
@@ -202,4 +203,5 @@ B35|2026-07-27|`flm bench qwen3.6-moe:35b-a3b` died 4s in w/ driver `0xc01e0200`
 B36|2026-07-27|keep-warm thread ⊥ aware of benchmarks: warms/reloads active model on 15min tick during a 10-20min bench ∴ NPU+mem contention mid-run|V42; `ffp_benchmark.is_running()` gate in `_warm_model_once`
 B37|2026-07-27|FLM returns HTTP **200** + `{"error":"Failed to load <model> model!"}`; `_call_openai_compatible`/`ffp_chat` read only `choices` ∴ real cause discarded → "Local LLM returned no usable text"|V43; surface the error body
 B34|2026-07-27|self-caught: `_active_model_health` tested membership vs `_provider_list("all")`; ollama "all" = installed+suggested (`ffp_provider_runtime:80`) ∴ never-pulled model → false `installed=True` (⊥ warn)|V39; trust `details` (unfiltered, authoritative) else re-list w/ `installed` filter
+B41|2026-07-29|Notes due `2026-08-04` parsed as UTC midnight → EDT displayed Aug 3|V56; parse date-only @ local noon
 ```
diff --git a/scripts/ui/web/app.js b/scripts/ui/web/app.js
index ea8a567..e3e681c 100644
--- a/scripts/ui/web/app.js
+++ b/scripts/ui/web/app.js
@@ -555,122 +555,766 @@ async function loadHistory() {
 
 // ---- Notes -----------------------------------------------------------------
 
-// Browse the vault: empty query lists the newest notes (notes_list); a query
-// runs the ranked search (note_search) and shows snippets instead of dates.
-let notesCategories = [];     // buckets from config, for the reader's Move dropdown
-let currentNoteRelpath = "";  // note open in the reader pane
-
-// Render the notes table with clickable rows that open the reader. `col3` maps
-// a result row to its third-column text (snippet for search, modified for list).
-function renderNotesTable(results, col3) {
-  const body = $("notes-body");
-  body.replaceChildren();
-  for (const r of results) {
-    const tr = document.createElement("tr");
-    for (const cell of [r.title, r.category, col3(r)]) {
-      const td = document.createElement("td");
-      td.textContent = cell || "";
-      tr.append(td);
+const NOTE_VIEW_META = {
+  board: ["Vision board", "Arrange what matters"],
+  all: ["All notes", "Everything you have captured"],
+  task: ["Tasks", "Things ready for action"],
+  idea: ["Ideas", "Possibilities worth growing"],
+  link: ["Links", "Useful places and references"],
+  read_later: ["Read later", "A quiet queue for focused reading"],
+  pinned: ["Pinned", "Keep the important things visible"],
+  archived: ["Archive", "Notes kept out of the daily flow"],
+  trashed: ["Trash", "Recover or permanently remove notes"],
+};
+
+const NOTE_KIND_META = {
+  note: ["✦", "Note"],
+  task: ["✓", "Task"],
+  idea: ["◇", "Idea"],
+  link: ["↗", "Link"],
+  read_later: ["◷", "Read later"],
+};
+
+let notesCategories = [];
+let notesSearchTimer = null;
+let draggedNoteId = "";
+let notesState = {
+  view: "board",
+  query: "",
+  category: "",
+  tag: "",
+  results: [],
+  facets: { counts: {}, categories: [], tags: [] },
+  board: null,
+  current: null,
+};
+
+function notesQueryArgs() {
+  const kind = ["task", "idea", "link", "read_later"].includes(notesState.view)
+    ? notesState.view
+    : "";
+  let status = "";
+  if (notesState.view === "board") status = "active";
+  if (notesState.view === "archived") status = "archived";
+  if (notesState.view === "trashed") status = "trashed";
+  return {
+    query: notesState.query,
+    kind,
+    status,
+    category: notesState.category,
+    tag: notesState.tag,
+    sort: notesState.view === "task" ? "due" : "updated",
+    limit: 200,
+  };
+}
+
+function visibleNotes() {
+  let notes = [...notesState.results];
+  if (!["archived", "trashed", "board"].includes(notesState.view)) {
+    notes = notes.filter((note) => note.status !== "archived");
+  }
+  if (notesState.view === "pinned") {
+    notes = notes.filter((note) => note.pinned);
+  }
+  return notes;
+}
+
+function setNotesStatus(message, good = true) {
+  setStatus("notes-status", message || "", good);
+}
+
+function setEditorStatus(message, good = true) {
+  setStatus("ne-status", message || "", good);
+}
+
+function renderNotesViewButtons() {
+  document.querySelectorAll("[data-notes-view]").forEach((button) => {
+    const active = button.dataset.notesView === notesState.view;
+    button.classList.toggle("active", active);
+    button.setAttribute("aria-current", active ? "page" : "false");
+  });
+}
+
+function makeFacetButton(label, active, onClick) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = `notes-facet-btn${active ? " active" : ""}`;
+  button.textContent = label;
+  button.addEventListener("click", onClick);
+  return button;
+}
+
+function renderNotesFacets() {
+  const categoryList = $("notes-category-list");
+  categoryList.replaceChildren();
+  categoryList.append(makeFacetButton(
+    "All categories",
+    !notesState.category,
+    () => {
+      notesState.category = "";
+      loadNotes(false);
+    },
+  ));
+  for (const category of notesState.facets.categories || []) {
+    categoryList.append(makeFacetButton(
+      category,
+      notesState.category === category,
+      () => {
+        notesState.category = notesState.category === category ? "" : category;
+        loadNotes(false);
+      },
+    ));
+  }
+
+  const tagList = $("notes-tag-list");
+  tagList.replaceChildren();
+  for (const tag of (notesState.facets.tags || []).slice(0, 18)) {
+    tagList.append(makeFacetButton(
+      `#${tag}`,
+      notesState.tag === tag,
+      () => {
+        notesState.tag = notesState.tag === tag ? "" : tag;
+        loadNotes(false);
+      },
+    ));
+  }
+  if (!(notesState.facets.tags || []).length) {
+    const empty = document.createElement("span");
+    empty.className = "muted small";
+    empty.textContent = "Tags appear as you add them.";
+    tagList.append(empty);
+  }
+}
+
+function formatNoteDate(value) {
+  if (!value) return "";
+  const raw = String(value);
+  const date = new Date(/^\d{4}-\d{2}-\d{2}$/.test(raw) ? `${raw}T12:00:00` : raw);
+  if (Number.isNaN(date.getTime())) return String(value).replace("T", " ").slice(0, 16);
+  return date.toLocaleDateString(undefined, { month: "short", day: "numeric" });
+}
+
+function noteKindMeta(kind) {
+  return NOTE_KIND_META[kind] || NOTE_KIND_META.note;
+}
+
+function createNoteCard(note, options = {}) {
+  const card = document.createElement("article");
+  const color = ["yellow", "peach", "pink", "violet", "blue", "mint", "slate"].includes(note.color)
+    ? note.color
+    : "yellow";
+  card.className = `note-card note-color-${color}`;
+  card.dataset.noteId = note.note_id;
+  card.tabIndex = 0;
+  card.setAttribute("aria-label", `${noteKindMeta(note.kind)[1]}: ${note.title || "Untitled note"}`);
+
+  const top = document.createElement("div");
+  top.className = "note-card-top";
+  const kind = document.createElement("span");
+  kind.className = "note-kind";
+  kind.textContent = `${noteKindMeta(note.kind)[0]} ${noteKindMeta(note.kind)[1]}`;
+  top.append(kind);
+  if (note.pinned) {
+    const pin = document.createElement("span");
+    pin.className = "note-pin";
+    pin.title = "Pinned";
+    pin.textContent = "⌖";
+    top.append(pin);
+  }
+  card.append(top);
+
+  const heading = document.createElement("h3");
+  heading.textContent = note.title || "Untitled note";
+  card.append(heading);
+  if (note.excerpt) {
+    const excerpt = document.createElement("p");
+    excerpt.className = "note-card-excerpt";
+    excerpt.textContent = note.excerpt;
+    card.append(excerpt);
+  }
+
+  const chips = document.createElement("div");
+  chips.className = "note-card-chips";
+  if (note.kind === "task" && note.status === "done") {
+    const done = document.createElement("span");
+    done.className = "note-chip done";
+    done.textContent = "Completed";
+    chips.append(done);
+  }
+  if (note.due) {
+    const due = document.createElement("span");
+    due.className = "note-chip";
+    due.textContent = `Due ${formatNoteDate(note.due)}`;
+    chips.append(due);
+  }
+  if (note.category) {
+    const category = document.createElement("span");
+    category.className = "note-chip";
+    category.textContent = note.category;
+    chips.append(category);
+  }
+  for (const tag of (note.tags || []).slice(0, 2)) {
+    const chip = document.createElement("span");
+    chip.className = "note-chip";
+    chip.textContent = `#${tag}`;
+    chips.append(chip);
+  }
+  if (chips.childElementCount) card.append(chips);
+
+  const footer = document.createElement("footer");
+  const updated = document.createElement("span");
+  updated.textContent = formatNoteDate(note.updated || note.created);
+  footer.append(updated);
+  if (/^https?:\/\//i.test(note.source || "")) {
+    const source = document.createElement("a");
+    source.href = note.source;
+    source.target = "_blank";
+    source.rel = "noopener";
+    source.textContent = "Open source ↗";
+    source.addEventListener("click", (event) => event.stopPropagation());
+    footer.append(source);
+  }
+  if (options.unplaced) {
+    const add = document.createElement("button");
+    add.type = "button";
+    add.className = "note-card-action";
+    add.textContent = "Add to board";
+    add.addEventListener("click", (event) => {
+      event.stopPropagation();
+      moveNoteOnBoard(note.note_id, firstBoardSectionId());
+    });
+    footer.append(add);
+  }
+  card.append(footer);
+
+  const open = () => openNoteEditor(note.note_id);
+  card.addEventListener("click", open);
+  card.addEventListener("keydown", (event) => {
+    if (event.key === "Enter" || event.key === " ") {
+      event.preventDefault();
+      open();
     }
-    if (r.relpath) {
-      tr.classList.add("note-row");
-      tr.tabIndex = 0;
-      const open = () => openNoteReader(r.relpath);
-      tr.addEventListener("click", open);
-      tr.addEventListener("keydown", (e) => { if (e.key === "Enter") open(); });
+  });
+  if (options.draggable) {
+    card.draggable = true;
+    card.addEventListener("dragstart", (event) => {
+      draggedNoteId = note.note_id;
+      card.classList.add("dragging");
+      if (event.dataTransfer) {
+        event.dataTransfer.effectAllowed = "move";
+        event.dataTransfer.setData("text/plain", note.note_id);
+      }
+    });
+    card.addEventListener("dragend", () => {
+      draggedNoteId = "";
+      card.classList.remove("dragging");
+    });
+  }
+  return card;
+}
+
+function renderNoteGrid(notes) {
+  const grid = $("notes-card-grid");
+  grid.replaceChildren();
+  for (const note of notes) grid.append(createNoteCard(note));
+}
+
+function firstBoardSectionId() {
+  return notesState.board?.sections?.[0]?.id || "now";
+}
+
+function populateBoardSectionSelect(selected = "") {
+  const select = $("ne-board-section");
+  select.replaceChildren();
+  for (const section of notesState.board?.sections || []) {
+    const option = document.createElement("option");
+    option.value = section.id;
+    option.textContent = section.title;
+    option.selected = section.id === selected;
+    select.append(option);
+  }
+  if (!select.value && select.options.length) select.value = select.options[0].value;
+}
+
+function placementFor(noteId) {
+  return (notesState.board?.placements || []).find((item) => item.note_id === noteId) || null;
+}
+
+function normalizeBoardOrders() {
+  const bySection = new Map();
+  for (const placement of notesState.board?.placements || []) {
+    if (!bySection.has(placement.section_id)) bySection.set(placement.section_id, []);
+    bySection.get(placement.section_id).push(placement);
+  }
+  for (const placements of bySection.values()) {
+    placements.sort((a, b) => Number(a.order || 0) - Number(b.order || 0));
+    placements.forEach((placement, index) => { placement.order = index; });
+  }
+}
+
+async function saveNotesBoard() {
+  if (!notesState.board) return false;
+  normalizeBoardOrders();
+  try {
+    const result = await action("notes_board_save", {
+      revision: notesState.board.revision,
+      board: notesState.board,
+    });
+    if (!result.ok) {
+      if (result.board) notesState.board = result.board;
+      setNotesStatus(result.error || "Board could not be saved.", false);
+      return false;
     }
-    body.append(tr);
+    notesState.board = result.board;
+    return true;
+  } catch (error) {
+    setNotesStatus(`Board save failed: ${error.message}`, false);
+    return false;
+  }
+}
+
+async function moveNoteOnBoard(noteId, sectionId) {
+  if (!notesState.board) return;
+  const placements = notesState.board.placements || [];
+  notesState.board.placements = placements.filter((item) => item.note_id !== noteId);
+  const order = notesState.board.placements.filter((item) => item.section_id === sectionId).length;
+  notesState.board.placements.push({
+    note_id: noteId,
+    section_id: sectionId || firstBoardSectionId(),
+    order,
+    size: "medium",
+  });
+  if (await saveNotesBoard()) renderNotesWorkspace();
+}
+
+async function removeNoteFromBoard(noteId) {
+  if (!notesState.board) return;
+  const before = notesState.board.placements || [];
+  notesState.board.placements = before.filter((item) => item.note_id !== noteId);
+  if (before.length !== notesState.board.placements.length) await saveNotesBoard();
+}
+
+async function renameBoardSection(sectionId, title) {
+  const section = (notesState.board?.sections || []).find((item) => item.id === sectionId);
+  if (!section) return;
+  section.title = String(title || "Section").trim().slice(0, 60) || "Section";
+  await saveNotesBoard();
+}
+
+async function removeBoardSection(sectionId) {
+  const sections = notesState.board?.sections || [];
+  if (sections.length <= 1) {
+    setNotesStatus("The board needs at least one section.", false);
+    return;
+  }
+  const section = sections.find((item) => item.id === sectionId);
+  if (!(await confirmDialog(`Remove the '${section?.title || "section"}' section? Its notes will move to the first section.`, "Remove section"))) {
+    return;
+  }
+  notesState.board.sections = sections.filter((item) => item.id !== sectionId);
+  const fallback = firstBoardSectionId();
+  for (const placement of notesState.board.placements || []) {
+    if (placement.section_id === sectionId) placement.section_id = fallback;
+  }
+  if (await saveNotesBoard()) renderNotesWorkspace();
+}
+
+function renderNotesBoard(notes) {
+  const board = $("notes-board");
+  board.replaceChildren();
+  const noteMap = new Map(notes.map((note) => [note.note_id, note]));
+  const placedIds = new Set();
+  for (const section of notesState.board?.sections || []) {
+    const column = document.createElement("section");
+    column.className = "notes-board-column";
+    column.dataset.sectionId = section.id;
+
+    const header = document.createElement("div");
+    header.className = "notes-board-column-head";
+    const name = document.createElement("input");
+    name.type = "text";
+    name.value = section.title;
+    name.maxLength = 60;
+    name.setAttribute("aria-label", "Board section name");
+    name.addEventListener("change", () => renameBoardSection(section.id, name.value));
+    const remove = document.createElement("button");
+    remove.type = "button";
+    remove.className = "btn btn-icon";
+    remove.title = "Remove section";
+    remove.setAttribute("aria-label", `Remove ${section.title} section`);
+    remove.textContent = "×";
+    remove.addEventListener("click", () => removeBoardSection(section.id));
+    header.append(name, remove);
+    column.append(header);
+
+    const dropzone = document.createElement("div");
+    dropzone.className = "notes-board-dropzone";
+    dropzone.dataset.sectionId = section.id;
+    dropzone.addEventListener("dragover", (event) => {
+      event.preventDefault();
+      dropzone.classList.add("drag-over");
+      if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+    });
+    dropzone.addEventListener("dragleave", () => dropzone.classList.remove("drag-over"));
+    dropzone.addEventListener("drop", (event) => {
+      event.preventDefault();
+      dropzone.classList.remove("drag-over");
+      const noteId = event.dataTransfer?.getData("text/plain") || draggedNoteId;
+      if (noteId) moveNoteOnBoard(noteId, section.id);
+    });
+
+    const placements = (notesState.board?.placements || [])
+      .filter((item) => item.section_id === section.id)
+      .sort((a, b) => Number(a.order || 0) - Number(b.order || 0));
+    for (const placement of placements) {
+      const note = noteMap.get(placement.note_id);
+      if (!note) continue;
+      placedIds.add(note.note_id);
+      dropzone.append(createNoteCard(note, { draggable: true }));
+    }
+    if (!dropzone.childElementCount) {
+      const hint = document.createElement("p");
+      hint.className = "notes-drop-hint";
+      hint.textContent = "Drag a note here";
+      dropzone.append(hint);
+    }
+    column.append(dropzone);
+    board.append(column);
+  }
+
+  const unplaced = notes.filter((note) => !placedIds.has(note.note_id));
+  const unplacedGrid = $("notes-unplaced-grid");
+  unplacedGrid.replaceChildren();
+  for (const note of unplaced) unplacedGrid.append(createNoteCard(note, { unplaced: true }));
+  $("notes-unplaced").hidden = unplaced.length === 0;
+}
+
+function renderNotesWorkspace() {
+  const meta = NOTE_VIEW_META[notesState.view] || NOTE_VIEW_META.all;
+  $("notes-view-title").textContent = meta[0];
+  $("notes-view-kicker").textContent = meta[1];
+  const notes = visibleNotes();
+  $("notes-count").textContent = `(${notes.length})`;
+  renderNotesViewButtons();
+  renderNotesFacets();
+  const boardMode = notesState.view === "board";
+  $("notes-board-view").hidden = !boardMode;
+  $("notes-card-grid").hidden = boardMode;
+  $("board-add-section").hidden = !boardMode;
+  if (boardMode) renderNotesBoard(notes);
+  else renderNoteGrid(notes);
+  const isEmpty = notes.length === 0;
+  $("notes-empty").hidden = !isEmpty;
+  if (isEmpty) {
+    $("notes-board-view").hidden = true;
+    $("notes-card-grid").hidden = true;
+  }
+  populateBoardSectionSelect(placementFor(notesState.current?.note_id)?.section_id || "");
+}
+
+function setNotesView(view) {
+  if (!NOTE_VIEW_META[view]) return;
+  notesState.view = view;
+  loadNotes(false);
+}
+
+function setEditorOpen(open) {
+  $("note-editor").hidden = !open;
+  $("notes-layout").classList.toggle("editor-open", open);
+}
+
+function populateEditorCategories(selected = INBOX_PLACEHOLDER) {
+  const categories = [
+    "inbox",
+    ...notesCategories,
+    ...(notesState.facets.categories || []),
+  ].filter((value, index, all) => value && all.indexOf(value) === index);
+  const select = $("ne-category");
+  select.replaceChildren();
+  for (const category of categories) {
+    const option = document.createElement("option");
+    option.value = category;
+    option.textContent = category;
+    option.selected = category === selected;
+    select.append(option);
+  }
+}
+
+const INBOX_PLACEHOLDER = "inbox";
+
+function setEditorReadOnly(trashed) {
+  for (const id of [
+    "ne-title", "ne-kind", "ne-status-select", "ne-body", "ne-category",
+    "ne-color", "ne-tags", "ne-due", "ne-source", "ne-pinned",
+    "ne-on-board", "ne-board-section",
+  ]) {
+    $(id).disabled = trashed;
+  }
+  $("ne-save").hidden = trashed;
+  $("ne-archive").hidden = trashed || notesState.current?.status === "archived";
+  $("ne-trash").hidden = trashed;
+  $("ne-restore").hidden = !trashed;
+  $("ne-delete").hidden = !trashed;
+}
+
+function fillNoteEditor(note) {
+  const isNew = !note;
+  const current = note || {
+    title: "",
+    body: "",
+    kind: "note",
+    status: "active",
+    category: "inbox",
+    tags: [],
+    color: "yellow",
+    due: "",
+    source: "",
+    pinned: false,
+    summary: "",
+  };
+  $("ne-kicker").textContent = isNew ? "Quick capture" : noteKindMeta(current.kind)[1];
+  $("ne-heading").textContent = isNew ? "New note" : "Edit note";
+  $("ne-title").value = current.title || "";
+  $("ne-body").value = current.body || "";
+  $("ne-kind").value = current.kind || "note";
+  $("ne-status-select").value = current.status === "trashed" ? "active" : (current.status || "active");
+  populateEditorCategories(current.category || "inbox");
+  $("ne-color").value = current.color || "yellow";
+  $("ne-tags").value = (current.tags || []).join(", ");
+  $("ne-due").value = (current.due || "").slice(0, 10);
+  $("ne-source").value = current.source || "";
+  $("ne-pinned").checked = !!current.pinned;
+  const placement = current.note_id ? placementFor(current.note_id) : null;
+  $("ne-on-board").checked = !!placement || (isNew && notesState.view === "board");
+  populateBoardSectionSelect(placement?.section_id || firstBoardSectionId());
+  $("ne-board-row").hidden = !$("ne-on-board").checked;
+  $("ne-summary").hidden = !current.summary;
+  $("ne-summary").textContent = current.summary ? `Local AI summary · ${current.summary}` : "";
+  $("ne-save").textContent = isNew ? "Create note" : "Save note";
+  setEditorReadOnly(current.status === "trashed");
+  setEditorStatus("");
+}
+
+function openNewNote(prefill = "") {
+  notesState.current = null;
+  fillNoteEditor(null);
+  const captured = String(prefill || "");
+  $("ne-body").value = captured;
+  if (/^https?:\/\/\S+$/i.test(captured.trim())) {
+    $("ne-kind").value = "read_later";
+    $("ne-source").value = captured.trim();
+  }
+  setEditorOpen(true);
+  $("ne-body").focus();
+}
+
+async function openNoteEditor(noteId) {
+  try {
+    const note = await action("note_get", { note_id: noteId });
+    if (!note.ok) {
+      setNotesStatus(note.error || "Note not found.", false);
+      return;
+    }
+    notesState.current = note;
+    fillNoteEditor(note);
+    setEditorOpen(true);
+  } catch (error) {
+    setNotesStatus(`Open failed: ${error.message}`, false);
   }
-  return results.length;
 }
 
-async function browseNotes() {
-  const query = $("note-query").value.trim();
+function closeNoteEditor() {
+  notesState.current = null;
+  setEditorOpen(false);
+}
+
+function editorNoteFields() {
+  return {
+    title: $("ne-title").value.trim(),
+    body: $("ne-body").value,
+    kind: $("ne-kind").value,
+    status: $("ne-status-select").value,
+    category: $("ne-category").value || "inbox",
+    tags: $("ne-tags").value,
+    color: $("ne-color").value,
+    due: $("ne-due").value,
+    source: $("ne-source").value.trim(),
+    pinned: $("ne-pinned").checked,
+  };
+}
+
+async function syncEditorBoardPlacement(noteId) {
+  if (!notesState.board) return;
+  if ($("ne-on-board").checked) {
+    const sectionId = $("ne-board-section").value || firstBoardSectionId();
+    const existing = placementFor(noteId);
+    if (existing) existing.section_id = sectionId;
+    else {
+      notesState.board.placements.push({
+        note_id: noteId,
+        section_id: sectionId,
+        order: notesState.board.placements.filter((item) => item.section_id === sectionId).length,
+        size: "medium",
+      });
+    }
+    await saveNotesBoard();
+  } else {
+    await removeNoteFromBoard(noteId);
+  }
+}
+
+async function saveNoteEditor() {
+  const fields = editorNoteFields();
+  if (!fields.title && !fields.body.trim() && !fields.source) {
+    setEditorStatus("Write something before saving.", false);
+    return;
+  }
+  setEditorStatus("Saving…");
   try {
-    if (query) {
-      const res = await action("note_search", { query, limit: 20 });
-      $("notes-col3").textContent = "Snippet";
-      const n = renderNotesTable(res.results || [], (r) => r.snippet || "");
-      $("notes-count").textContent = `(${res.count} match${res.count === 1 ? "" : "es"})`;
-      $("notes-empty").hidden = n > 0;
+    let saved;
+    if (notesState.current?.note_id) {
+      saved = await action("note_update", {
+        note_id: notesState.current.note_id,
+        revision: notesState.current.revision,
+        patch: fields,
+      });
     } else {
-      const res = await action("notes_list", { limit: 20 });
-      $("notes-col3").textContent = "Modified";
-      const n = renderNotesTable(res.results || [], (r) => r.modified);
-      $("notes-count").textContent = `(${res.count} total — newest 20)`;
-      $("notes-empty").hidden = n > 0;
+      saved = await action("note_create", { ...fields, captured_via: "dashboard" });
     }
-  } catch (e) {
-    fillTable("notes-body", [[`Notes unavailable: ${e.message}`, "", ""]]);
-    $("notes-empty").hidden = true;
+    if (!saved.ok) {
+      if (saved.conflict && saved.note) {
+        notesState.current = saved.note;
+        fillNoteEditor(saved.note);
+      }
+      setEditorStatus(saved.error || "Save failed.", false);
+      return;
+    }
+    await syncEditorBoardPlacement(saved.note_id);
+    notesState.current = saved;
+    await loadNotes(false);
+    fillNoteEditor(saved);
+    setEditorStatus("Saved.");
+  } catch (error) {
+    setEditorStatus(`Save failed: ${error.message}`, false);
   }
 }
 
-async function openNoteReader(relpath) {
+async function archiveCurrentNote() {
+  if (!notesState.current?.note_id) return;
   try {
-    const n = await action("note_get", { relpath });
-    if (!n.ok) { setStatus("nr-status", n.error || "note not found", false); return; }
-    currentNoteRelpath = n.relpath || relpath;
-    $("nr-title").textContent = n.title || "(untitled)";
-    $("nr-body").textContent = n.body || "";
-    const src = $("nr-source");
-    if (n.source) { src.textContent = n.source; src.href = n.source; src.hidden = false; }
-    else { src.hidden = true; src.removeAttribute("href"); }
-    // Bucket dropdown: configured categories + inbox, plus the note's current
-    // category if it isn't in the list.
-    const cats = [...notesCategories];
-    if (!cats.includes("inbox")) cats.push("inbox");
-    if (n.category && !cats.includes(n.category)) cats.unshift(n.category);
-    const sel = $("nr-bucket");
-    sel.replaceChildren();
-    for (const c of cats) {
-      const o = document.createElement("option");
-      o.value = c; o.textContent = c;
-      if (c === n.category) o.selected = true;
-      sel.append(o);
+    const result = await action("note_archive", {
+      note_id: notesState.current.note_id,
+      revision: notesState.current.revision,
+    });
+    if (!result.ok) {
+      setEditorStatus(result.error || "Archive failed.", false);
+      return;
     }
-    setStatus("nr-status", "");
-    $("note-reader").hidden = false;
-    $("note-reader").scrollIntoView({ behavior: "smooth", block: "nearest" });
-  } catch (e) {
-    setStatus("nr-status", `Open failed: ${e.message}`, false);
+    await removeNoteFromBoard(result.note_id);
+    closeNoteEditor();
+    await loadNotes(false);
+  } catch (error) {
+    setEditorStatus(`Archive failed: ${error.message}`, false);
   }
 }
 
-async function moveNoteToBucket() {
-  if (!currentNoteRelpath) return;
-  const category = $("nr-bucket").value;
+async function trashCurrentNote() {
+  if (!notesState.current?.note_id) {
+    closeNoteEditor();
+    return;
+  }
+  if (!(await confirmDialog("Move this note to Trash? You can restore it later.", "Move to Trash"))) return;
   try {
-    const res = await action("note_move", { relpath: currentNoteRelpath, category });
-    if (!res.ok) { setStatus("nr-status", res.error || "move failed", false); return; }
-    currentNoteRelpath = res.relpath || currentNoteRelpath;
-    setStatus("nr-status", `Moved to ${res.category}.`);
-    browseNotes();
-  } catch (e) {
-    setStatus("nr-status", `Move failed: ${e.message}`, false);
+    const noteId = notesState.current.note_id;
+    const result = await action("note_trash", { note_id: noteId });
+    if (!result.ok) {
+      setEditorStatus(result.error || "Move to Trash failed.", false);
+      return;
+    }
+    await removeNoteFromBoard(noteId);
+    closeNoteEditor();
+    await loadNotes(false);
+  } catch (error) {
+    setEditorStatus(`Move to Trash failed: ${error.message}`, false);
   }
 }
 
-async function deleteCurrentNote() {
-  if (!currentNoteRelpath) return;
-  if (!(await confirmDialog("Delete this note from the vault?", "Delete"))) return;
+async function restoreCurrentNote() {
+  if (!notesState.current?.note_id) return;
   try {
-    const res = await action("note_delete", { relpath: currentNoteRelpath });
-    if (!res.ok) { setStatus("nr-status", res.error || "delete failed", false); return; }
-    $("note-reader").hidden = true;
-    currentNoteRelpath = "";
-    browseNotes();
-  } catch (e) {
-    setStatus("nr-status", `Delete failed: ${e.message}`, false);
+    const result = await action("note_restore", { note_id: notesState.current.note_id });
+    if (!result.ok) {
+      setEditorStatus(result.error || "Restore failed.", false);
+      return;
+    }
+    notesState.current = result;
+    await loadNotes(false);
+    fillNoteEditor(result);
+    setEditorStatus("Restored.");
+  } catch (error) {
+    setEditorStatus(`Restore failed: ${error.message}`, false);
   }
 }
 
-async function loadNotes() {
-  browseNotes();
+async function permanentlyDeleteCurrentNote() {
+  if (!notesState.current?.note_id) return;
+  if (!(await confirmDialog("Permanently delete this note? This cannot be undone.", "Delete forever"))) return;
   try {
-    const cfg = await action("config_snapshot");
+    const result = await action("note_delete", {
+      note_id: notesState.current.note_id,
+      permanent: true,
+    });
+    if (!result.ok) {
+      setEditorStatus(result.error || "Delete failed.", false);
+      return;
+    }
+    closeNoteEditor();
+    await loadNotes(false);
+  } catch (error) {
+    setEditorStatus(`Delete failed: ${error.message}`, false);
+  }
+}
+
+async function addBoardSection() {
+  const input = $("board-section-title");
+  const title = input.value.trim();
+  if (!title || !notesState.board) return;
+  const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "section";
+  const existing = new Set(notesState.board.sections.map((section) => section.id));
+  let sectionId = base;
+  let suffix = 2;
+  while (existing.has(sectionId)) {
+    sectionId = `${base}-${suffix}`;
+    suffix += 1;
+  }
+  notesState.board.sections.push({ id: sectionId, title: title.slice(0, 60) });
+  input.value = "";
+  if (await saveNotesBoard()) renderNotesWorkspace();
+}
+
+async function loadNotes(takeStaged = true) {
+  setNotesStatus("Loading…");
+  try {
+    const [feed, boardResult, cfg] = await Promise.all([
+      action("notes_query", notesQueryArgs()),
+      action("notes_board_get"),
+      action("config_snapshot"),
+    ]);
+    notesState.results = feed.results || [];
+    notesState.facets = feed.facets || { counts: {}, categories: [], tags: [] };
+    notesState.board = boardResult.board;
     notesCategories = (cfg.notes || {}).categories || [];
-  } catch (_e) {}
+    renderNotesWorkspace();
+    setNotesStatus("");
+    if (takeStaged) {
+      const staged = await action("note_take_staged");
+      if (staged.staged) openNewNote(staged.text || "");
+    }
+  } catch (error) {
+    setNotesStatus(`Notes unavailable: ${error.message}`, false);
+    notesState.results = [];
+    renderNotesWorkspace();
+  }
 }
 
 function populateNotesConfig(notes) {
@@ -2027,13 +2671,43 @@ document.addEventListener("DOMContentLoaded", () => {
   $("refresh-btn").addEventListener("click", refreshAll);
   $("theme-btn").addEventListener("click", cycleTheme);
   applyTheme(localStorage.getItem(THEME_KEY) || "auto");
-  $("note-search-btn").addEventListener("click", browseNotes);
-  $("note-query").addEventListener("keydown", (e) => {
-    if (e.key === "Enter") browseNotes();
+  $("note-query").addEventListener("input", (event) => {
+    notesState.query = event.target.value.trim();
+    clearTimeout(notesSearchTimer);
+    notesSearchTimer = setTimeout(() => loadNotes(false), 180);
+  });
+  $("note-query").addEventListener("keydown", (event) => {
+    if (event.key === "Enter") {
+      clearTimeout(notesSearchTimer);
+      notesState.query = event.target.value.trim();
+      loadNotes(false);
+    }
+  });
+  $("notes-view-list").addEventListener("click", (event) => {
+    const button = event.target.closest("[data-notes-view]");
+    if (button) setNotesView(button.dataset.notesView);
+  });
+  $("note-new").addEventListener("click", () => openNewNote());
+  $("notes-empty-new").addEventListener("click", () => openNewNote());
+  $("ne-close").addEventListener("click", closeNoteEditor);
+  $("ne-save").addEventListener("click", saveNoteEditor);
+  $("ne-archive").addEventListener("click", archiveCurrentNote);
+  $("ne-trash").addEventListener("click", trashCurrentNote);
+  $("ne-restore").addEventListener("click", restoreCurrentNote);
+  $("ne-delete").addEventListener("click", permanentlyDeleteCurrentNote);
+  $("ne-on-board").addEventListener("change", () => {
+    $("ne-board-row").hidden = !$("ne-on-board").checked;
+  });
+  $("ne-body").addEventListener("keydown", (event) => {
+    if (event.key === "Enter" && (event.ctrlKey || event.metaKey)) {
+      event.preventDefault();
+      saveNoteEditor();
+    }
+  });
+  $("board-section-add").addEventListener("click", addBoardSection);
+  $("board-section-title").addEventListener("keydown", (event) => {
+    if (event.key === "Enter") addBoardSection();
   });
-  $("nr-move").addEventListener("click", moveNoteToBucket);
-  $("nr-delete").addEventListener("click", deleteCurrentNote);
-  $("nr-close").addEventListener("click", () => { $("note-reader").hidden = true; });
   $("history-view-telemetry").addEventListener("click", () => setHistoryView("telemetry"));
   $("history-view-exposed").addEventListener("click", () => setHistoryView("exposed"));
   $("history-storage-action").addEventListener("click", setHistoryStorageFromBanner);
diff --git a/scripts/ui/web/index.html b/scripts/ui/web/index.html
index 0ad399e..8e15fff 100644
--- a/scripts/ui/web/index.html
+++ b/scripts/ui/web/index.html
@@ -151,34 +151,153 @@ <h2>Recent activity <span class="muted small">(last 50, newest first)</span></h2
   </section>
 
   <section class="panel" id="tab-notes">
-    <div class="grid">
-      <div class="card card-wide">
-        <h2>Your notes <span class="muted small" id="notes-count"></span></h2>
-        <div class="form-row">
-          <input type="text" id="note-query" placeholder="Search notes… (leave empty to show newest)">
-          <button class="btn" id="note-search-btn">Search</button>
-        </div>
-        <table class="data-table">
-          <thead><tr><th>Title</th><th>Category</th><th id="notes-col3">Modified</th></tr></thead>
-          <tbody id="notes-body"></tbody>
-        </table>
-        <p class="muted small" id="notes-empty" hidden>No notes found.</p>
-        <p class="muted small">Click a note to read it, move it to another bucket, or delete it.</p>
-      </div>
-      <div class="card card-wide note-reader" id="note-reader" hidden>
-        <div class="card-actions reader-head">
-          <h2 id="nr-title" class="nr-title">Note</h2>
-          <button class="btn" id="nr-close" title="Close">✕</button>
+    <div class="notes-shell">
+      <header class="card notes-toolbar">
+        <div>
+          <p class="eyebrow">Your thinking space</p>
+          <h2>Notes <span class="muted small" id="notes-count"></span></h2>
         </div>
-        <p class="muted small"><a id="nr-source" href="#" target="_blank" rel="noopener" hidden></a></p>
-        <div class="form-row">
-          <label for="nr-bucket">Bucket</label>
-          <select id="nr-bucket"></select>
-          <button class="btn" id="nr-move">Move</button>
-          <button class="btn" id="nr-delete">Delete…</button>
-          <span class="muted small" id="nr-status"></span>
+        <div class="notes-toolbar-actions">
+          <input type="search" id="note-query" aria-label="Search notes" placeholder="Search notes, tags, links…">
+          <button class="btn btn-primary" id="note-new" type="button">＋ New note</button>
         </div>
-        <pre class="note-body" id="nr-body"></pre>
+      </header>
+
+      <div class="notes-layout" id="notes-layout">
+        <aside class="card notes-sidebar" aria-label="Notes views">
+          <nav class="notes-view-list" id="notes-view-list">
+            <button class="notes-view-btn active" type="button" data-notes-view="board"><span>◫</span> Vision board</button>
+            <button class="notes-view-btn" type="button" data-notes-view="all"><span>✦</span> All notes</button>
+            <button class="notes-view-btn" type="button" data-notes-view="task"><span>✓</span> Tasks</button>
+            <button class="notes-view-btn" type="button" data-notes-view="idea"><span>◇</span> Ideas</button>
+            <button class="notes-view-btn" type="button" data-notes-view="link"><span>↗</span> Links</button>
+            <button class="notes-view-btn" type="button" data-notes-view="read_later"><span>◷</span> Read later</button>
+            <button class="notes-view-btn" type="button" data-notes-view="pinned"><span>⌖</span> Pinned</button>
+            <button class="notes-view-btn" type="button" data-notes-view="archived"><span>□</span> Archive</button>
+            <button class="notes-view-btn" type="button" data-notes-view="trashed"><span>♲</span> Trash</button>
+          </nav>
+          <div class="notes-facet-block">
+            <h3>Categories</h3>
+            <div id="notes-category-list" class="notes-facet-list"></div>
+          </div>
+          <div class="notes-facet-block">
+            <h3>Tags</h3>
+            <div id="notes-tag-list" class="notes-tag-list"></div>
+          </div>
+        </aside>
+
+        <section class="notes-content" aria-live="polite">
+          <div class="notes-view-head">
+            <div>
+              <p class="eyebrow" id="notes-view-kicker">Arrange what matters</p>
+              <h2 id="notes-view-title">Vision board</h2>
+            </div>
+            <div class="board-add-section" id="board-add-section">
+              <input type="text" id="board-section-title" maxlength="60" aria-label="New board section" placeholder="New section">
+              <button class="btn" id="board-section-add" type="button">Add section</button>
+            </div>
+          </div>
+
+          <div id="notes-board-view">
+            <div class="notes-board" id="notes-board"></div>
+            <div class="notes-unplaced" id="notes-unplaced">
+              <div class="notes-view-head compact">
+                <div>
+                  <p class="eyebrow">Ready when you are</p>
+                  <h3>Unplaced notes</h3>
+                </div>
+              </div>
+              <div class="notes-card-grid" id="notes-unplaced-grid"></div>
+            </div>
+          </div>
+          <div class="notes-card-grid" id="notes-card-grid" hidden></div>
+          <div class="notes-empty card" id="notes-empty" hidden>
+            <span class="notes-empty-icon">✦</span>
+            <h3>Nothing here yet</h3>
+            <p class="muted">Capture a thought, task, idea, or link and it will appear here.</p>
+            <button class="btn btn-primary" id="notes-empty-new" type="button">Create a note</button>
+          </div>
+          <p class="muted small" id="notes-status"></p>
+        </section>
+
+        <aside class="card notes-editor" id="note-editor" hidden aria-label="Note editor">
+          <div class="notes-editor-head">
+            <div>
+              <p class="eyebrow" id="ne-kicker">Quick capture</p>
+              <h2 id="ne-heading">New note</h2>
+            </div>
+            <button class="btn btn-icon" id="ne-close" type="button" aria-label="Close editor">✕</button>
+          </div>
+          <label for="ne-title">Title</label>
+          <input type="text" id="ne-title" maxlength="120" placeholder="What is this about?">
+          <div class="notes-editor-pair">
+            <div>
+              <label for="ne-kind">Type</label>
+              <select id="ne-kind">
+                <option value="note">Note</option>
+                <option value="task">Task</option>
+                <option value="idea">Idea</option>
+                <option value="link">Link</option>
+                <option value="read_later">Read later</option>
+              </select>
+            </div>
+            <div>
+              <label for="ne-status-select">Status</label>
+              <select id="ne-status-select">
+                <option value="active">Active</option>
+                <option value="done">Done</option>
+                <option value="archived">Archived</option>
+              </select>
+            </div>
+          </div>
+          <label for="ne-body">Note</label>
+          <textarea id="ne-body" rows="12" placeholder="Write anything…"></textarea>
+          <div class="notes-editor-pair">
+            <div>
+              <label for="ne-category">Category</label>
+              <select id="ne-category"></select>
+            </div>
+            <div>
+              <label for="ne-color">Color</label>
+              <select id="ne-color">
+                <option value="yellow">Sunlight</option>
+                <option value="peach">Peach</option>
+                <option value="pink">Rose</option>
+                <option value="violet">Violet</option>
+                <option value="blue">Sky</option>
+                <option value="mint">Mint</option>
+                <option value="slate">Slate</option>
+              </select>
+            </div>
+          </div>
+          <label for="ne-tags">Tags</label>
+          <input type="text" id="ne-tags" placeholder="release, research, personal">
+          <div class="notes-editor-pair">
+            <div>
+              <label for="ne-due">Due</label>
+              <input type="date" id="ne-due">
+            </div>
+            <div>
+              <label for="ne-source">Source link</label>
+              <input type="url" id="ne-source" placeholder="https://…">
+            </div>
+          </div>
+          <label class="check-row"><input type="checkbox" id="ne-pinned"> Pin this note</label>
+          <label class="check-row"><input type="checkbox" id="ne-on-board"> Show on Vision Board</label>
+          <div class="form-row" id="ne-board-row">
+            <label for="ne-board-section">Section</label>
+            <select id="ne-board-section"></select>
+          </div>
+          <p class="notes-ai-summary" id="ne-summary" hidden></p>
+          <div class="notes-editor-actions">
+            <button class="btn btn-primary" id="ne-save" type="button">Save note</button>
+            <button class="btn" id="ne-archive" type="button">Archive</button>
+            <button class="btn" id="ne-restore" type="button" hidden>Restore</button>
+            <button class="btn btn-danger" id="ne-trash" type="button">Move to Trash</button>
+            <button class="btn btn-danger" id="ne-delete" type="button" hidden>Delete forever…</button>
+          </div>
+          <p class="muted small" id="ne-status"></p>
+        </aside>
       </div>
     </div>
   </section>
diff --git a/scripts/ui/web/styles.css b/scripts/ui/web/styles.css
index 93c30e1..d3987f4 100644
--- a/scripts/ui/web/styles.css
+++ b/scripts/ui/web/styles.css
@@ -86,6 +86,7 @@
 }
 
 * { box-sizing: border-box; }
+[hidden] { display: none !important; }
 
 html { scrollbar-gutter: stable; }
 
@@ -467,7 +468,8 @@ kbd {
 .history-notice { margin: 6px 0 10px; }
 
 /* ---- Forms (Notes, Config) ---- */
-input[type="text"], input[type="number"], textarea, select {
+input[type="text"], input[type="search"], input[type="url"], input[type="date"],
+input[type="time"], input[type="number"], textarea, select {
   background: var(--bg);
   color: var(--text);
   border: 1px solid var(--border);
@@ -812,6 +814,441 @@ footer { padding: 14px 24px 22px; }
   border-radius: 8px; padding: 12px;
 }
 
+/* ---- Notes 2.5 workspace ---- */
+.notes-shell { display: flex; flex-direction: column; gap: 14px; }
+.notes-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 15px 18px;
+  overflow: visible;
+}
+.notes-toolbar:hover, .notes-sidebar:hover, .notes-editor:hover {
+  transform: none;
+  box-shadow: var(--shadow);
+}
+.notes-toolbar h2,
+.notes-view-head h2,
+.notes-editor h2 {
+  margin: 0;
+  color: var(--text);
+  font-size: 21px;
+  font-weight: 750;
+  letter-spacing: -0.025em;
+  text-transform: none;
+}
+.eyebrow {
+  margin: 0 0 2px;
+  color: var(--accent);
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+.notes-toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  flex: 1;
+  justify-content: flex-end;
+}
+.notes-toolbar-actions input { max-width: 520px; }
+.notes-toolbar-actions .btn { white-space: nowrap; }
+.btn-icon {
+  width: 34px;
+  min-width: 34px;
+  padding: 5px;
+  display: inline-grid;
+  place-items: center;
+}
+
+.notes-layout {
+  display: grid;
+  grid-template-columns: 210px minmax(0, 1fr);
+  gap: 14px;
+  align-items: start;
+}
+.notes-layout.editor-open {
+  grid-template-columns: 190px minmax(0, 1fr) minmax(310px, 360px);
+}
+.notes-sidebar {
+  position: sticky;
+  top: 132px;
+  padding: 10px;
+  max-height: calc(100vh - 150px);
+  overflow-y: auto;
+}
+.notes-view-list { display: flex; flex-direction: column; gap: 3px; }
+.notes-view-btn {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  border: 0;
+  border-radius: 9px;
+  padding: 8px 10px;
+  background: transparent;
+  color: var(--text-muted);
+  font: inherit;
+  font-weight: 600;
+  text-align: left;
+  cursor: pointer;
+}
+.notes-view-btn span {
+  width: 18px;
+  color: var(--accent);
+  text-align: center;
+}
+.notes-view-btn:hover { background: var(--accent-soft); color: var(--text); }
+.notes-view-btn.active {
+  color: var(--text);
+  background: color-mix(in srgb, var(--accent) 13%, transparent);
+  box-shadow: inset 3px 0 0 var(--accent);
+}
+.notes-view-btn:focus-visible,
+.notes-facet-btn:focus-visible,
+.note-card:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+.notes-facet-block {
+  margin-top: 16px;
+  padding: 0 4px;
+}
+.notes-facet-block h3 {
+  margin: 0 0 6px;
+  color: var(--text-muted);
+  font-size: 10px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.notes-facet-list { display: flex; flex-direction: column; gap: 2px; }
+.notes-tag-list { display: flex; flex-wrap: wrap; gap: 5px; }
+.notes-facet-btn {
+  border: 0;
+  border-radius: 7px;
+  padding: 4px 7px;
+  background: transparent;
+  color: var(--text-muted);
+  font: inherit;
+  font-size: 12px;
+  text-align: left;
+  cursor: pointer;
+}
+.notes-facet-btn:hover,
+.notes-facet-btn.active {
+  color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.notes-content { min-width: 0; }
+.notes-view-head {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 12px;
+  margin: 2px 2px 12px;
+}
+.notes-view-head.compact { margin-top: 20px; }
+.notes-view-head h3 { margin: 0; font-size: 16px; }
+.board-add-section {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+}
+.board-add-section input { width: 150px; }
+
+.notes-card-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 12px;
+  align-items: stretch;
+}
+.note-card {
+  --note-bg: color-mix(in srgb, #facc15 17%, var(--surface));
+  --note-edge: color-mix(in srgb, #ca8a04 42%, var(--border));
+  min-height: 190px;
+  display: flex;
+  flex-direction: column;
+  padding: 14px;
+  border: 1px solid var(--note-edge);
+  border-radius: 13px 13px 13px 5px;
+  background: var(--note-bg);
+  box-shadow: 0 3px 10px color-mix(in srgb, var(--note-edge) 18%, transparent);
+  cursor: pointer;
+  transition: transform 0.15s, box-shadow 0.15s, border-color 0.15s;
+  overflow: hidden;
+}
+.note-card:hover {
+  transform: translateY(-3px) rotate(-0.25deg);
+  box-shadow: 0 9px 22px color-mix(in srgb, var(--note-edge) 25%, transparent);
+}
+.note-card.dragging { opacity: 0.48; transform: rotate(2deg); }
+.note-color-peach {
+  --note-bg: color-mix(in srgb, #fb923c 17%, var(--surface));
+  --note-edge: color-mix(in srgb, #ea580c 38%, var(--border));
+}
+.note-color-pink {
+  --note-bg: color-mix(in srgb, #f472b6 16%, var(--surface));
+  --note-edge: color-mix(in srgb, #db2777 36%, var(--border));
+}
+.note-color-violet {
+  --note-bg: color-mix(in srgb, #a78bfa 17%, var(--surface));
+  --note-edge: color-mix(in srgb, #7c3aed 36%, var(--border));
+}
+.note-color-blue {
+  --note-bg: color-mix(in srgb, #60a5fa 16%, var(--surface));
+  --note-edge: color-mix(in srgb, #2563eb 36%, var(--border));
+}
+.note-color-mint {
+  --note-bg: color-mix(in srgb, #34d399 15%, var(--surface));
+  --note-edge: color-mix(in srgb, #059669 35%, var(--border));
+}
+.note-color-slate {
+  --note-bg: color-mix(in srgb, #94a3b8 16%, var(--surface));
+  --note-edge: color-mix(in srgb, #64748b 38%, var(--border));
+}
+.note-card-top {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.note-kind {
+  color: color-mix(in srgb, var(--text) 72%, var(--accent));
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+.note-pin { color: var(--accent); font-size: 17px; }
+.note-card h3 {
+  margin: 12px 0 6px;
+  font-size: 16px;
+  line-height: 1.25;
+  letter-spacing: -0.01em;
+}
+.note-card-excerpt {
+  display: -webkit-box;
+  margin: 0 0 10px;
+  color: color-mix(in srgb, var(--text) 82%, transparent);
+  line-height: 1.43;
+  overflow: hidden;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 5;
+}
+.note-card-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: auto;
+}
+.note-chip {
+  max-width: 100%;
+  padding: 2px 6px;
+  border: 1px solid color-mix(in srgb, var(--note-edge) 55%, transparent);
+  border-radius: 999px;
+  color: var(--text-muted);
+  background: color-mix(in srgb, var(--surface) 56%, transparent);
+  font-size: 10px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.note-chip.done { color: var(--ok); }
+.note-card footer {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 7px;
+  margin-top: 10px;
+  padding-top: 8px;
+  border-top: 1px solid color-mix(in srgb, var(--note-edge) 42%, transparent);
+  color: var(--text-muted);
+  font-size: 10px;
+}
+.note-card footer a { margin-left: auto; color: var(--accent); }
+.note-card-action {
+  margin-left: auto;
+  padding: 2px 0;
+  border: 0;
+  background: transparent;
+  color: var(--accent);
+  font: inherit;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+.notes-board {
+  display: flex;
+  gap: 12px;
+  padding: 2px 2px 12px;
+  overflow-x: auto;
+  scroll-snap-type: x proximity;
+}
+.notes-board-column {
+  flex: 1 0 270px;
+  min-width: 270px;
+  max-width: 380px;
+  padding: 9px;
+  border: 1px solid var(--border);
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--surface) 74%, transparent);
+  scroll-snap-align: start;
+}
+.notes-board-column-head {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  margin-bottom: 8px;
+}
+.notes-board-column-head input {
+  border-color: transparent;
+  background: transparent;
+  padding: 4px 6px;
+  font-weight: 750;
+}
+.notes-board-column-head input:focus { background: var(--surface); border-color: var(--accent); }
+.notes-board-dropzone {
+  min-height: 180px;
+  display: flex;
+  flex-direction: column;
+  gap: 9px;
+  border-radius: 11px;
+  transition: background 0.15s, box-shadow 0.15s;
+}
+.notes-board-dropzone .note-card { min-height: 170px; }
+.notes-board-dropzone.drag-over {
+  background: color-mix(in srgb, var(--accent) 9%, transparent);
+  box-shadow: inset 0 0 0 2px var(--accent);
+}
+.notes-drop-hint {
+  display: grid;
+  min-height: 165px;
+  place-items: center;
+  margin: 0;
+  border: 1px dashed var(--border-strong);
+  border-radius: 10px;
+  color: var(--text-muted);
+  font-size: 12px;
+}
+.notes-unplaced {
+  padding-top: 4px;
+  border-top: 1px solid var(--border);
+}
+
+.notes-editor {
+  position: sticky;
+  top: 132px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  max-height: calc(100vh - 150px);
+  padding: 16px;
+  overflow-y: auto;
+}
+.notes-editor-head {
+  display: flex;
+  align-items: start;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 5px;
+}
+.notes-editor label:not(.check-row) {
+  margin-top: 5px;
+  color: var(--text-muted);
+  font-size: 11px;
+  font-weight: 700;
+}
+.notes-editor textarea {
+  min-height: 220px;
+  resize: vertical;
+  background: color-mix(in srgb, var(--bg) 65%, var(--surface));
+  font-family: "Segoe UI", system-ui, sans-serif;
+  line-height: 1.5;
+}
+.notes-editor-pair {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 8px;
+}
+.notes-editor-pair > div { min-width: 0; }
+.notes-editor-pair label { display: block; margin-bottom: 4px; }
+.notes-editor-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin-top: 8px;
+}
+.notes-ai-summary {
+  margin: 7px 0 0;
+  padding: 9px 10px;
+  border-left: 3px solid var(--accent);
+  border-radius: 6px;
+  background: var(--accent-soft);
+  color: var(--text-muted);
+  font-size: 12px;
+  white-space: pre-wrap;
+}
+.notes-empty {
+  display: grid;
+  place-items: center;
+  padding: 44px 20px;
+  text-align: center;
+}
+.notes-empty h3 { margin: 8px 0 0; }
+.notes-empty p { margin: 4px 0 16px; }
+.notes-empty-icon {
+  display: grid;
+  place-items: center;
+  width: 52px;
+  height: 52px;
+  border-radius: 16px;
+  background: var(--grad);
+  color: #fff;
+  font-size: 24px;
+  box-shadow: 0 8px 22px var(--ring);
+}
+
+@media (max-width: 1120px) {
+  .notes-layout,
+  .notes-layout.editor-open { grid-template-columns: 180px minmax(0, 1fr); }
+  .notes-editor {
+    position: relative;
+    top: auto;
+    grid-column: 1 / -1;
+    max-height: none;
+  }
+}
+
+@media (max-width: 720px) {
+  main { padding-inline: 12px; }
+  .notes-toolbar { align-items: stretch; flex-direction: column; }
+  .notes-toolbar-actions { align-items: stretch; flex-direction: column; }
+  .notes-toolbar-actions input { max-width: none; }
+  .notes-layout,
+  .notes-layout.editor-open { display: block; }
+  .notes-sidebar {
+    position: relative;
+    top: auto;
+    max-height: none;
+    margin-bottom: 12px;
+  }
+  .notes-view-list {
+    flex-direction: row;
+    overflow-x: auto;
+    padding-bottom: 3px;
+  }
+  .notes-view-btn { width: auto; flex: 0 0 auto; }
+  .notes-facet-block { display: none; }
+  .notes-view-head { align-items: stretch; flex-direction: column; }
+  .board-add-section input { flex: 1; width: auto; }
+  .notes-card-grid { grid-template-columns: 1fr; }
+  .notes-board-column { flex-basis: min(82vw, 320px); min-width: min(82vw, 320px); }
+  .notes-editor { margin-top: 12px; }
+}
+
 /* ---- In-page confirm modal (replaces native confirm/alert) ---- */
 .modal-overlay {
   position: fixed; inset: 0; z-index: 50;
diff --git a/tests/test_notes_config_location.py b/tests/test_notes_config_location.py
index bdf96e3..b12346c 100644
--- a/tests/test_notes_config_location.py
+++ b/tests/test_notes_config_location.py
@@ -32,5 +32,5 @@ def test_notes_settings_use_config_single_save_flow():
 
     assert "populateNotesConfig(cfg.notes || {})" in app
     assert "notes: notesPatch" in app
-    assert "function saveNotes" not in app
+    assert "function saveNotes()" not in app
     assert '"notes-save"' not in app
diff --git a/tests/test_notes_workspace_ui.py b/tests/test_notes_workspace_ui.py
new file mode 100644
index 0000000..fd4ab7d
--- /dev/null
+++ b/tests/test_notes_workspace_ui.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "scripts" / "ui" / "web"
+
+
+def test_notes_panel_is_a_workspace_not_a_table_or_settings_page():
+    html = (WEB / "index.html").read_text(encoding="utf-8")
+    notes_panel = html.split('id="tab-notes"', 1)[1].split('id="tab-meetings"', 1)[0]
+
+    for required_id in (
+        "notes-layout",
+        "notes-view-list",
+        "notes-board",
+        "notes-card-grid",
+        "note-editor",
+        "note-new",
+        "ne-title",
+        "ne-body",
+        "ne-kind",
+        "ne-category",
+        "ne-tags",
+        "ne-color",
+        "ne-on-board",
+        "ne-save",
+        "ne-trash",
+        "ne-restore",
+        "ne-delete",
+    ):
+        assert f'id="{required_id}"' in notes_panel
+    for removed_id in ("notes-body", "notes-col3", "note-reader", "notes-vault"):
+        assert f'id="{removed_id}"' not in notes_panel
+    assert "<table" not in notes_panel
+
+
+def test_notes_workspace_uses_v2_actions_and_safe_dom_construction():
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+
+    for action_name in (
+        "notes_query",
+        "note_get",
+        "note_create",
+        "note_update",
+        "note_archive",
+        "note_trash",
+        "note_restore",
+        "note_delete",
+        "notes_board_get",
+        "notes_board_save",
+        "note_take_staged",
+    ):
+        assert f'"{action_name}"' in app
+    assert ".innerHTML" not in app
+    assert "confirmDialog(" in app
+    assert "createNoteCard(" in app
+
+
+def test_v55_notes_workspace_has_keyboard_and_responsive_contracts():
+    html = (WEB / "index.html").read_text(encoding="utf-8")
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+    css = (WEB / "styles.css").read_text(encoding="utf-8")
+
+    assert 'aria-label="Notes views"' in html
+    assert 'aria-label="Note editor"' in html
+    assert 'event.key === "Enter" || event.key === " "' in app
+    assert "@media (max-width: 720px)" in css
+    assert ".notes-layout.editor-open" in css
+    assert ".note-card:focus-visible" in css
+
+
+def test_v56_date_only_due_values_are_parsed_in_local_time():
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+
+    assert r"/^\d{4}-\d{2}-\d{2}$/" in app
+    assert "`${raw}T12:00:00`" in app

From 204e3a8d679f9dc290af001ee8d14472340e8fd4 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:55:27 -0400
Subject: [PATCH 05/12] T35: open Notes composer from capture hotkey

Cites V53.
---
 SPEC.md                         |  2 +-
 scripts/grammarFix.ahk          | 42 +++++++++----------------
 scripts/lib/clipboard.ahk       | 33 ++++++++++++++++++++
 tests/test_ffp_notifications.py |  6 ++--
 tests/test_notes_hotkey.py      | 55 +++++++++++++++++++++++++++++++++
 5 files changed, 107 insertions(+), 31 deletions(-)
 create mode 100644 tests/test_notes_hotkey.py

diff --git a/SPEC.md b/SPEC.md
index 9383b29..1e1e5cc 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -155,7 +155,7 @@ T31|x|Notes schema v2 repository: stable ids, zero-loss migration, CRUD, Trash,
 T32|x|daemon Notes v2 actions + backward-compatible read/move/delete + staged capture|V1,V2,V3,V7,V48,V50,V53,V54
 T33|x|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
 T34|x|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55,V56
-T35|.|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
+T35|x|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
 T36|.|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 ```
 
diff --git a/scripts/grammarFix.ahk b/scripts/grammarFix.ahk
index a3ef994..6f6a6ee 100644
--- a/scripts/grammarFix.ahk
+++ b/scripts/grammarFix.ahk
@@ -449,19 +449,9 @@ ShutdownFlowkeyChildren(ExitReason := "", ExitCode := "") {
 ; ----------------------------------------------------------------------------
 ; Note capture (Ctrl+Alt+N).
 ;
-; Capture strategy (in order):
-;   1. Save the existing clipboard contents (so we can restore them and use
-;      them as a fallback).
-;   2. Try Send("^c") to copy whatever's currently selected. Some apps eat
-;      this synthetic Ctrl+C (web inputs, PDF viewers, Citrix sessions);
-;      that's an acceptable failure mode.
-;   3. If the fresh copy produced text → use it. Otherwise fall back to the
-;      clipboard contents from step 1 (lets the user copy manually first,
-;      then press Ctrl+Alt+N).
-;   4. If both are empty → toast and bail.
-;
-; Daemon writes an inbox stub instantly; LLM categorization happens in a
-; background thread and posts a follow-up toast with the final category.
+; A fresh selection is staged for the Notes quick composer. With no selection,
+; the composer still opens blank. The user's previous clipboard is never used
+; as note content, so pressing the hotkey cannot save stale text by accident.
 ; ----------------------------------------------------------------------------
 
 CaptureNote() {
@@ -477,31 +467,29 @@ CaptureNote() {
 CaptureNoteImpl() {
     captured := ""
     source := ""
-    if !CaptureTextFromSelectionOrClipboard(&captured, &source) {
-        if (source = "clipboard_busy")
-            Notify("Flowkey", "📝 Note capture: clipboard busy — try again in a moment.")
-        else
-            Notify("Flowkey", "📝 Note capture: nothing to save (no selection, clipboard empty). Copy text first, then press Ctrl+Alt+N.")
-        return
-    }
+    selectionFound := CaptureSelectedText(&captured, &source)
 
-    ; Best-effort source app (for the YAML frontmatter only).
+    ; Best-effort source app for composer context.
     sourceApp := ""
     try sourceApp := WinGetProcessName("A")
     catch
         sourceApp := ""
 
     body := '{"args":{"text":"' EscapeJson(captured)
-        . '","source_app":"' EscapeJson(sourceApp)
-        . '","url":""}}'
-    result := RunActionViaDaemon("save_note", body)
+        . '","source_app":"' EscapeJson(sourceApp) '"}}'
+    result := RunActionViaDaemon("note_stage_capture", body)
     if (result = "") {
         Notify("Flowkey", "📝 Note capture: daemon unavailable.")
         return
     }
-    ; Daemon shows the final "Saved to inbox/<category>" toast itself once
-    ; the background categorize thread finishes. This is just the AHK ack.
-    Notify("Flowkey", "📝 Note saved from " source " (" StrLen(captured) " chars) — categorizing…")
+
+    OpenWebDashboard("notes")
+    if selectionFound
+        Notify("Flowkey", "📝 Selection ready in Notes (" StrLen(captured) " chars).")
+    else if (source = "clipboard_busy")
+        Notify("Flowkey", "📝 Clipboard busy — opened a blank note.")
+    else
+        Notify("Flowkey", "📝 Blank note ready.")
 }
 
 ; ----------------------------------------------------------------------------
diff --git a/scripts/lib/clipboard.ahk b/scripts/lib/clipboard.ahk
index 5a25aa6..9d27b78 100644
--- a/scripts/lib/clipboard.ahk
+++ b/scripts/lib/clipboard.ahk
@@ -2,6 +2,39 @@
 ; clipboard.ahk — shared selection/clipboard capture for hotkey actions.
 ; ===========================================================================
 
+; Capture only text copied by a fresh synthetic Ctrl+C. This deliberately
+; never falls back to the clipboard's prior text: note capture uses it so a
+; blank selection opens a blank composer instead of silently saving something
+; the user copied earlier. The user's clipboard is restored on every path.
+CaptureSelectedText(&capturedText, &captureSource) {
+    clipSaved := ""
+    try {
+        clipSaved := ClipboardAll()
+        A_Clipboard := ""
+    } catch {
+        capturedText := ""
+        captureSource := "clipboard_busy"
+        return false
+    }
+
+    fromSelection := ""
+    try {
+        Send("^c")
+        if ClipWait(1) {
+            try
+                fromSelection := A_Clipboard
+            catch
+                fromSelection := ""
+        }
+    } finally {
+        RestoreClipboard(clipSaved)
+    }
+
+    capturedText := fromSelection
+    captureSource := (fromSelection != "") ? "selection" : "none"
+    return (fromSelection != "")
+}
+
 ; Returns true when text was captured. Sets capturedText and captureSource
 ; ("selection" or "clipboard"). Restores the user's clipboard on all paths —
 ; including exceptions mid-capture — and retries the restore briefly because
diff --git a/tests/test_ffp_notifications.py b/tests/test_ffp_notifications.py
index 632e2af..1e36165 100644
--- a/tests/test_ffp_notifications.py
+++ b/tests/test_ffp_notifications.py
@@ -48,9 +48,8 @@ def _notif(**overrides) -> dict:
     ("Flowkey", "Grammar engine not found (ffp-grammar-fix.exe / pyw.exe + grammar_fix.py).", "errors"),
     ("Flowkey", "No text returned.", "errors"),
     ("Flowkey", "Clipboard write failed.", "errors"),
-    ("Flowkey", "📝 Note capture: clipboard busy — try again in a moment.", "errors"),
-    ("Flowkey", "📝 Note capture: nothing to save (no selection, clipboard empty).", "errors"),
     ("Flowkey", "📝 Note capture: daemon unavailable.", "errors"),
+    ("Flowkey", "📝 Clipboard busy — opened a blank note.", "errors"),
     ("Flowkey", "💬 Ask: clipboard busy — try again in a moment.", "errors"),
     ("Flowkey", "💬 Ask: nothing to send (no selection, clipboard empty).", "errors"),
     ("Flowkey", "Ask: daemon unavailable.", "errors"),
@@ -83,7 +82,8 @@ def _notif(**overrides) -> dict:
     ("Flowkey", "Prompt refined.", "action_result"),
     ("Flowkey", "Grammar fixed.", "action_result"),
     ("Flowkey", "✅ summarize done. · 1.2s · 45 tok/s", "action_result"),
-    ("Flowkey", "📝 Note saved from chrome.exe (412 chars) — categorizing…", "action_result"),
+    ("Flowkey", "📝 Selection ready in Notes (412 chars).", "action_result"),
+    ("Flowkey", "📝 Blank note ready.", "action_result"),
     ("Flowkey", "💬 Sent to chat (412 chars).", "action_result"),
 ]
 
diff --git a/tests/test_notes_hotkey.py b/tests/test_notes_hotkey.py
new file mode 100644
index 0000000..10716e5
--- /dev/null
+++ b/tests/test_notes_hotkey.py
@@ -0,0 +1,55 @@
+"""Static contracts for the AutoHotkey Notes quick-capture path."""
+
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+GRAMMAR_AHK = (ROOT / "scripts" / "grammarFix.ahk").read_text(encoding="utf-8")
+CLIPBOARD_AHK = (ROOT / "scripts" / "lib" / "clipboard.ahk").read_text(encoding="utf-8")
+
+
+def _function_body(source: str, name: str) -> str:
+    match = re.search(
+        rf"(?ms)^{re.escape(name)}\([^)]*\) \{{(.*?)^\}}",
+        source,
+    )
+    assert match, f"{name} function not found"
+    return match.group(1)
+
+
+def test_note_hotkey_stages_selection_then_opens_notes_composer():
+    body = _function_body(GRAMMAR_AHK, "CaptureNoteImpl")
+
+    assert "CaptureSelectedText" in body
+    assert 'RunActionViaDaemon("note_stage_capture"' in body
+    assert 'OpenWebDashboard("notes")' in body
+    assert body.index('RunActionViaDaemon("note_stage_capture"') < body.index(
+        'OpenWebDashboard("notes")'
+    )
+
+
+def test_note_hotkey_never_uses_legacy_immediate_save_or_clipboard_fallback():
+    body = _function_body(GRAMMAR_AHK, "CaptureNoteImpl")
+
+    assert "save_note" not in body
+    assert "CaptureTextFromSelectionOrClipboard" not in body
+    assert "priorClip" not in body
+
+
+def test_selection_only_helper_restores_clipboard_without_reusing_prior_text():
+    body = _function_body(CLIPBOARD_AHK, "CaptureSelectedText")
+
+    assert "ClipboardAll()" in body
+    assert "RestoreClipboard(clipSaved)" in body
+    assert 'Send("^c")' in body
+    assert "priorClip" not in body
+    assert 'captureSource := (fromSelection != "") ? "selection" : "none"' in body
+
+
+def test_no_selection_continues_to_stage_blank_composer():
+    body = _function_body(GRAMMAR_AHK, "CaptureNoteImpl")
+
+    assert "selectionFound := CaptureSelectedText" in body
+    assert "if !CaptureSelectedText" not in body
+    assert '"text":"' in body
+    assert 'Notify("Flowkey", "📝 Blank note ready.")' in body

From a630249051f3447ef440f5f2656e6a783477ce2d Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 17:57:25 -0400
Subject: [PATCH 06/12] T36: release Notes workspace as 2.5.0

Cites V18, V20, V47, V48, V49, V50, V51, V52, V53, V54, V55.
---
 CHANGELOG.md               | 24 ++++++++++++++++++++++++
 README.md                  | 15 ++++++++++++---
 SPEC.md                    |  6 +++---
 installer/installer.iss    |  2 +-
 installer/sign.ps1         |  2 +-
 pyproject.toml             |  2 +-
 scripts/_version.py        |  2 +-
 tests/test_version_sync.py |  2 +-
 8 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3eae6b3..489240c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,30 @@
 
 ## Unreleased
 
+## 2.5.0
+
+**Notes now works like a notepad, sticky-note wall, and vision board instead of a file browser.** Capture first, shape the note in an editor, and organize it without leaving the Notes tab.
+
+### Added
+
+- **Living Notes workspace.** Notes render as responsive sticky cards with dedicated types for notes, tasks, ideas, links, and read-later items. The composer/editor supports title, body, category, tags, color, status, due date, source link, pinning, Archive, and Trash.
+- **Smart organization.** Search, type views, Pinned/Archive/Trash views, category facets, and tag facets work over an indexed vault feed.
+- **Vision Board.** Editable sections and drag-and-drop card ordering are persisted separately in `.flowkey/board.json`, keyed by stable note IDs. Removing a board placement never mutates or deletes the note.
+- **Recoverable removal.** The default delete action moves a note to Trash. Restore is immediate; permanent deletion is available only inside Trash and requires explicit confirmation.
+- **Safe schema-v2 migration.** Existing Markdown notes gain a stable `note_id` and richer metadata without losing their body, source path, or unknown frontmatter. A backup is written to `.flowkey/backups/v1/` before the first rewrite.
+- **Conflict-aware, atomic writes.** Notes and board state use atomic replacement and revisions, so a stale editor reports a conflict instead of overwriting newer work.
+
+### Changed
+
+- **The Notes tab contains notes only.** Vault, category, extraction, and local-model controls moved to Config → Notes & capture and save with the rest of Config.
+- **`Ctrl+Alt+N` opens the Notes composer.** A fresh selection prefills the draft; no selection opens a blank composer. Prior clipboard contents are never used as an implicit fallback, and capture no longer saves before review.
+- **Local-model enrichment cannot rewrite authored content.** It may fill only blank or generated metadata, preserving user-written titles and bodies.
+- **Legacy note actions remain compatible.** Existing callers can continue reading or moving by relative path while the new workspace uses stable IDs.
+
+### Fixed
+
+- **Date-only due dates keep their calendar day.** A value such as `2026-08-04` displays as August 4 in every timezone instead of shifting to the prior day west of UTC.
+
 ## 2.4.3
 
 **`prompt:` handles vague requests properly.** A request too thin to break into requirements now produces a prompt that names what is missing, instead of handing the request back reworded.
diff --git a/README.md b/README.md
index fff3b0e..8647a32 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,15 @@ Flowkey is a Windows desktop assistant that adds local-LLM hotkeys for grammar f
 
 Everything runs locally through [FastFlowLM](https://fastflowlm.com) (AMD Ryzen AI NPU) or, on machines without the NPU, through [Ollama](https://ollama.com) (CPU/GPU) as a secondary provider. No cloud service, analytics, or telemetry is used by the app.
 
-Current version: `2.4.3`
+Current version: `2.5.0`
+
+## What's new in 2.5
+
+- **Notes is now a real thinking workspace.** Capture plain notes, tasks, ideas, links, and read-later items as readable sticky cards. Search them, filter by type, category, or tag, and organize them with colors, pins, due dates, status, Archive, and a recoverable Trash.
+- **The Vision Board keeps important notes alive.** Create and rename board sections, drag cards into the order you want, and keep unplaced notes nearby. Board placement never changes or deletes the underlying note.
+- **`Ctrl+Alt+N` opens a quick composer.** Selected text is staged as an editable draft; with no selection, Flowkey opens a blank note. Nothing is saved until you choose to save it, and old clipboard text is never captured by accident.
+- **Notes settings moved to Config.** The Notes tab is only for writing and organizing. Vault location, categories, extraction limits, and local-model enrichment now live together under Config → Notes & capture.
+- **Existing Markdown notes migrate safely.** Notes receive stable IDs and richer metadata when first read. Flowkey preserves the body and unknown frontmatter, writes a v1 backup under the vault's `.flowkey/backups/v1/` directory before rewriting, and uses atomic saves with edit-conflict detection.
 
 ## What's new in 2.4
 
@@ -120,7 +128,7 @@ Launch the app with AutoHotkey v2:
 | `<custom>:` + `Ctrl+Shift+G` | Any mode you define in Dashboard → Config → Custom modes (e.g. `translate:`) |
 | `Ctrl+Alt+C` | Open chat (the Chat tab has a "My notes" toggle that grounds replies in your notes vault) |
 | `Ctrl+Shift+A` | Ask in chat with selected text |
-| `Ctrl+Alt+N` | Capture a note |
+| `Ctrl+Alt+N` | Open Notes quick capture (selected text prefills the composer; no selection opens it blank) |
 
 Prefix tip: put the keyword on the first line of your selection — `prompt: rough idea here` (or `prompt` on its own line, then the text). Without a prefix, `Ctrl+Shift+G` always runs a grammar fix.
 
@@ -135,7 +143,8 @@ The dashboard is a web page served by the local daemon — open it from the tray
 - **Models:** pull models with live progress — pick a suggestion or type any name (on Ollama, anything from the [library](https://ollama.com/library) works); set active, remove. Suggestions are hardware-aware: detected RAM/VRAM caps the model size (e.g. 32 GB RAM → ~4B on the NPU; 8 GB VRAM → ~9B on the GPU), oversized models are hidden, and free-typing one asks before pulling.
 - **Benchmark:** works on both providers — `flm bench` on FastFlowLM (~10–20 min, NPU), timed generations with native metrics on Ollama (~1–3 min, server keeps running).
 - **History:** Telemetry view shows what ran and how fast; Exposed view shows stored request/result text only for rows captured while history storage was visible. The History tab includes the same redacted/visible storage toggle as Config.
-- **Notes:** browse or search your vault.
+- **Notes:** write and organize notes, tasks, ideas, links, and read-later items; use smart views, categories, tags, pins, Archive/Trash, or arrange cards on the Vision Board.
+- **Notes settings:** Config → Notes & capture controls the vault, categories, link extraction, and optional local-model enrichment. The Notes tab itself contains no settings.
 - **Meetings:** connect the local [Quill](https://quillapp.com) app to search meetings, read AI digests (pre-computed after-hours), review action items (accept / reject), and generate a weekly review. Off by default — enable in Config → Meetings.
 - **Notifications:** per-event toggles, dedupe window, Do-Not-Disturb, and quiet hours; every toast (shown or muted) is logged to the Telemetry feed.
 
diff --git a/SPEC.md b/SPEC.md
index 1e1e5cc..9be0b3e 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -17,7 +17,7 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - LLM: FastFlowLM NPU @ `:52625` | Ollama @ `:11434`, OpenAI-compat `POST /v1/chat/completions`
 - dashboard: daemon-served `scripts/ui/web/{index.html,app.js,styles.css}`, CSP `default-src 'self'`
 - paths: `scripts/paths.py` → USER_ROOT/{config,data,logs}; `_version.py` = version src of truth
-- version: `2.4.3`; target `2.5.0` = living Notes workspace + vision board; repo `agr77one/Fastflow`
+- version: `2.5.0` = living Notes workspace + vision board; repo `agr77one/Fastflow`
 - run tree = `flowkey-pub2` (worktree, branch `live`=origin/main). old `FastFlowPrompt_Local_Setup`=1.5.0 stale.
 
 ## §I interfaces
@@ -56,7 +56,7 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - data: `data/{meeting_digests,meeting_action_status,meeting_skips,notifications,chat_threads}.jsonl`
 - autostart: HKCU Run `FastFlowPrompt` → bundled `AutoHotkey64.exe` + `grammarFix.ahk`; `FlowkeyGitSync` → `sync.ps1`
 - sched: Windows task `FlowkeyGitSync` daily 12:00 → `sync.ps1` (ff-only pull, guarded)
-- ACTIONS count = 75
+- ACTIONS count = 85
 
 ## §V invariants
 
@@ -156,7 +156,7 @@ T32|x|daemon Notes v2 actions + backward-compatible read/move/delete + staged ca
 T33|x|move vault/categories/extraction/LLM Notes settings → Config single-save; Notes tab config-free|V3,V47
 T34|x|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55,V56
 T35|x|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
-T36|.|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
+T36|x|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 ```
 
 ## §B bugs
diff --git a/installer/installer.iss b/installer/installer.iss
index 9e5a1a2..7399709 100644
--- a/installer/installer.iss
+++ b/installer/installer.iss
@@ -41,7 +41,7 @@
 #define AppURL        "https://github.com/agr77one/Fastflow"
 #define AppExeName    "Flowkey.exe"  ; symbolic — actual launchers below
 ; Keep in lockstep with scripts\_version.py.
-#define AppVersion    "2.4.3"
+#define AppVersion    "2.5.0"
 
 [Setup]
 AppId={{8A4F1E6C-9B3D-4E62-9F7A-FASTFLOW140}}
diff --git a/installer/sign.ps1 b/installer/sign.ps1
index fdd8a31..4a4d6ed 100644
--- a/installer/sign.ps1
+++ b/installer/sign.ps1
@@ -52,7 +52,7 @@
 .EXAMPLE
     # Sign the installer
     $env:FFP_SIGN_PFX_PASSWORD = "ChangeMe!"
-    .\sign.ps1 -FilePath ..\out\Flowkey-Setup-2.4.3.exe
+    .\sign.ps1 -FilePath ..\out\Flowkey-Setup-2.5.0.exe
 #>
 
 [CmdletBinding(DefaultParameterSetName = "Sign")]
diff --git a/pyproject.toml b/pyproject.toml
index f48d8c5..d30a43c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,7 +17,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastflowprompt"
-version = "2.4.3"
+version = "2.5.0"
 description = "Local-LLM-powered grammar fix, prompt rewrite, chat, and dashboard for Windows."
 readme = "README.md"
 requires-python = ">=3.11"
diff --git a/scripts/_version.py b/scripts/_version.py
index b312e02..ec7a6d0 100644
--- a/scripts/_version.py
+++ b/scripts/_version.py
@@ -1,3 +1,3 @@
 """Single source of truth for the app version. Read by grammar_fix.py."""
 
-__version__ = "2.4.3"
+__version__ = "2.5.0"
diff --git a/tests/test_version_sync.py b/tests/test_version_sync.py
index b88b3fe..4892a9b 100644
--- a/tests/test_version_sync.py
+++ b/tests/test_version_sync.py
@@ -32,4 +32,4 @@ def test_v18_release_version_is_synchronized():
         ),
     }
 
-    assert set(versions.values()) == {"2.4.3"}, versions
+    assert set(versions.values()) == {"2.5.0"}, versions

From 7bfb2408fea394289d981faa9aac25da87e228ad Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 22:40:14 -0400
Subject: [PATCH 07/12] T37: repair Quill transcript digest pipeline

---
 SPEC.md                    | 14 ++++++--
 scripts/ffp_meetings.py    | 20 ++++++++++++
 scripts/ffp_quill.py       | 55 +++++++++++++++++++++++++++++---
 tests/test_ffp_meetings.py | 50 +++++++++++++++++++++++++++++
 tests/test_ffp_quill.py    | 65 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 198 insertions(+), 6 deletions(-)

diff --git a/SPEC.md b/SPEC.md
index 9be0b3e..626559a 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -29,6 +29,7 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - action: `notes_query {query?,kind?,status?,category?,tag?,sort?,limit?,offset?}` → `{results,count,facets}`
 - action: `note_create {title?,body?,kind?,category?,tags?,color?,due?,source?}` → note
 - action: `note_update {note_id,revision,patch}` → note | conflict
+- action: `note_organize {note_id,revision?}` → note; local LLM may update category/suggested metadata only
 - action: `note_trash {note_id}` / `note_restore {note_id}` → note; `note_delete {note_id,permanent:true}` → deleted
 - action: `notes_board_get` → `{board,placements}`; `notes_board_save {revision,board}` → board | conflict
 - action: `note_stage_capture {text?,source_app?}` / `note_take_staged` → quick-capture payload
@@ -51,12 +52,12 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - action: `meeting_actions_list {range:week|month}` → `{range,items:[{id,text,owner,status,...}],counts}`
 - action: `meeting_action_set_status {id,status:pending|accepted|rejected}` → `{ok}`
 - action: `meeting_week_summary {week_offset}` → `{ok,week_label,meeting_count,summary}`
-- mcp: Quill @ `http://127.0.0.1:19532/mcp` — Streamable-HTTP, SSE `data:`, `Mcp-Session-Id` header; init→notifications/initialized→tools/call
+- mcp: Quill @ `http://127.0.0.1:19532/mcp` — Streamable-HTTP, SSE `data:`, `Mcp-Session-Id` header; init→notifications/initialized→tools/call; `get_transcript {meeting_id,include_private_notes:true}`; tool `isError` → typed failure
 - cmd: `flm serve <model> --pmode turbo --host 127.0.0.1 --port 52625`
 - data: `data/{meeting_digests,meeting_action_status,meeting_skips,notifications,chat_threads}.jsonl`
 - autostart: HKCU Run `FastFlowPrompt` → bundled `AutoHotkey64.exe` + `grammarFix.ahk`; `FlowkeyGitSync` → `sync.ps1`
 - sched: Windows task `FlowkeyGitSync` daily 12:00 → `sync.ps1` (ff-only pull, guarded)
-- ACTIONS count = 85
+- ACTIONS count = 86
 
 ## §V invariants
 
@@ -116,6 +117,10 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - V54: note writes + board writes atomic; stale `revision` → conflict, ⊥ overwrite
 - V55: note card/editor controls keyboard reachable; desktop split workspace + ≤720px stacked layout
 - V56: note `due` date-only value renders same calendar day ∀ timezone; ⊥ UTC date shift
+- V57: Quill transcript call matches discovered schema (`meeting_id` + `include_private_notes`); MCP JSON-RPC/tool `isError` ∨ validation payload → typed failure, ⊥ LLM input/cache; poisoned legacy digest → ⊥ idempotency hit, eligible reprocess
+- V58: model-created note category accepted ⟺ config opt-in ∧ `is_new` ∧ high confidence ∧ safe normalized ≤2-segment slug; accepted category atomically deduped+sorted into cfg; otherwise Inbox + suggestion; V49 holds
+- V59: Config → keyboard-accessible section nav + collapsible groups + one selected section visible + sticky Save/Revert; view state local-only persisted; ≤720px responsive
+- V60: future Activity workspace may join Telemetry+History + explicit `Save as note`; Notes remains authored knowledge; V6,V25,V26 hold
 
 ## §T tasks
 
@@ -157,6 +162,10 @@ T33|x|move vault/categories/extraction/LLM Notes settings → Config single-save
 T34|x|Notes-only card workspace: composer, editor, smart views, filters, tags, archive/Trash, vision board drag/order|V5,V47,V48,V50,V52,V54,V55,V56
 T35|x|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
 T36|x|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
+T37|x|repair Quill transcript schema/error handling + poison-cache retry + re-digest latest|V12,V14,V20,V23,V57
+T38|.|guarded local-model category creation + sorted category manager + note organize action|V3,V7,V20,V49,V58
+T39|.|compact Config section navigation + collapsible cards + sticky save|V5,V20,V55,V59
+T40|.|Activity workspace: merge Telemetry+History, card/detail UI, explicit Save as note|V5,V6,V25,V26,V60
 ```
 
 ## §B bugs
@@ -204,4 +213,5 @@ B36|2026-07-27|keep-warm thread ⊥ aware of benchmarks: warms/reloads active mo
 B37|2026-07-27|FLM returns HTTP **200** + `{"error":"Failed to load <model> model!"}`; `_call_openai_compatible`/`ffp_chat` read only `choices` ∴ real cause discarded → "Local LLM returned no usable text"|V43; surface the error body
 B34|2026-07-27|self-caught: `_active_model_health` tested membership vs `_provider_list("all")`; ollama "all" = installed+suggested (`ffp_provider_runtime:80`) ∴ never-pulled model → false `installed=True` (⊥ warn)|V39; trust `details` (unfiltered, authoritative) else re-list w/ `installed` filter
 B41|2026-07-29|Notes due `2026-08-04` parsed as UTC midnight → EDT displayed Aug 3|V56; parse date-only @ local noon
+B42|2026-07-29|Quill `get_transcript` sent `id`; live schema requires `meeting_id`+`include_private_notes`; `call_tool` ignored `isError` ∴ 133-char validation error fed to LLM + cached as digest|V57
 ```
diff --git a/scripts/ffp_meetings.py b/scripts/ffp_meetings.py
index 7272758..d03b550 100644
--- a/scripts/ffp_meetings.py
+++ b/scripts/ffp_meetings.py
@@ -140,6 +140,23 @@ def should_run_batch(meetings_cfg: dict, now_dt, idle_seconds: float | None) ->
 
 # ---------- digest store --------------------------------------------------------------
 
+def _digest_is_poisoned(rec: dict) -> bool:
+    """Recognize legacy digests generated from Quill validation-error text."""
+    digest = str(rec.get("digest_md") or "").strip().lower()
+    try:
+        context_chars = int(rec.get("context_chars") or 0)
+    except (TypeError, ValueError):
+        context_chars = 0
+    validation_marker = (
+        "validation_error" in digest
+        or "invalid meeting_id input parameter" in digest
+        or ("meeting_id" in digest and "invalid input parameter" in digest)
+    )
+    return digest.startswith("error:") or bool(
+        validation_marker and (not context_chars or context_chars <= 512)
+    )
+
+
 def load_digests() -> list[dict]:
     import json
     if not DIGESTS_PATH.exists():
@@ -158,6 +175,9 @@ def load_digests() -> list[dict]:
                 mid = row.get("meeting_id")
                 if not mid:
                     continue
+                if _digest_is_poisoned(row):
+                    log.warning("ignoring poisoned meeting digest for %s", mid)
+                    continue
                 prev = latest.get(mid)
                 if prev is None or str(row.get("processed_at") or "") >= str(prev.get("processed_at") or ""):
                     latest[mid] = row
diff --git a/scripts/ffp_quill.py b/scripts/ffp_quill.py
index dba6183..ef7fdd2 100644
--- a/scripts/ffp_quill.py
+++ b/scripts/ffp_quill.py
@@ -26,6 +26,15 @@
 PROTOCOL_VERSION = "2025-06-18"
 
 
+class QuillToolError(RuntimeError):
+    """Quill accepted the MCP request but rejected the tool invocation."""
+
+    def __init__(self, tool: str, message: str):
+        self.tool = str(tool or "")
+        self.message = str(message or "unknown Quill tool error").strip()
+        super().__init__(f"{self.tool}: {self.message}")
+
+
 def _parse_sse(body: str) -> list[dict]:
     """Extract JSON objects from SSE ``data:`` lines (Quill replies as SSE)."""
     out: list[dict] = []
@@ -93,7 +102,7 @@ def connect(self) -> bool:
             return False
 
     def call_tool(self, name: str, arguments: dict) -> str:
-        """Call an MCP tool, return its text content ('' on error/empty)."""
+        """Call an MCP tool; transport failures stay soft, tool failures do not."""
         if not self.session_id and not self.connect():
             return ""
         try:
@@ -101,8 +110,21 @@ def call_tool(self, name: str, arguments: dict) -> str:
         except Exception as exc:
             log.warning("Quill tool %s failed: %s", name, exc)
             return ""
-        content = ((res or {}).get("result") or {}).get("content") or []
-        return "\n".join(c.get("text", "") for c in content if isinstance(c, dict) and c.get("type") == "text")
+        response = res or {}
+        if response.get("error"):
+            error = response["error"]
+            message = error.get("message") if isinstance(error, dict) else str(error)
+            raise QuillToolError(name, message or "JSON-RPC error")
+        result = response.get("result") or {}
+        content = result.get("content") or []
+        text = "\n".join(
+            c.get("text", "")
+            for c in content
+            if isinstance(c, dict) and c.get("type") == "text"
+        )
+        if result.get("isError") or _is_validation_error_text(text):
+            raise QuillToolError(name, _tool_error_message(text))
+        return text
 
 
 # ---------- parsing helpers (Quill's XML-ish tool output -> dicts) --------------------
@@ -112,6 +134,28 @@ def call_tool(self, name: str, arguments: dict) -> str:
 _TITLE_RE = re.compile(r"<title>(.*?)</title>", re.DOTALL)
 
 
+def _is_validation_error_text(text: str) -> bool:
+    value = str(text or "").strip().lower()
+    return value.startswith("error:") and (
+        "validation_error" in value
+        or "invalid input parameter" in value
+        or '"invalid input"' in value
+    )
+
+
+def _tool_error_message(text: str) -> str:
+    value = str(text or "").strip()
+    if value.lower().startswith("error:"):
+        value = value[6:].strip()
+    try:
+        payload = json.loads(value)
+    except (json.JSONDecodeError, TypeError):
+        return value or "Quill tool returned an error"
+    if isinstance(payload, dict):
+        return str(payload.get("message") or payload.get("code") or value)
+    return value or "Quill tool returned an error"
+
+
 def _parse_meetings(text: str) -> list[dict]:
     meetings: list[dict] = []
     for attr_blob, inner in _MEETING_RE.findall(text or ""):
@@ -181,4 +225,7 @@ def get_minutes(meeting_id: str, *, url: str = DEFAULT_MCP_URL, client: QuillCli
 
 def get_transcript(meeting_id: str, *, url: str = DEFAULT_MCP_URL, client: QuillClient | None = None) -> str:
     c = client or QuillClient(url)
-    return clean_text(c.call_tool("get_transcript", {"id": meeting_id}))
+    return clean_text(c.call_tool(
+        "get_transcript",
+        {"meeting_id": meeting_id, "include_private_notes": True},
+    ))
diff --git a/tests/test_ffp_meetings.py b/tests/test_ffp_meetings.py
index 46c41bd..1ccdc5a 100644
--- a/tests/test_ffp_meetings.py
+++ b/tests/test_ffp_meetings.py
@@ -120,6 +120,56 @@ def test_digests_list():
     assert "digest_md" not in out["digests"][0]  # list is summary-only
 
 
+def test_poisoned_validation_digest_is_not_a_cache_hit():
+    M.save_digest({
+        "meeting_id": "poisoned",
+        "title": "Real meeting",
+        "processed_at": "2026-07-29T22:17:55",
+        "source": "transcript",
+        "context_chars": 133,
+        "digest_md": (
+            "## Summary\n- (not discussed)\n"
+            "## Goals\n- (not discussed)\n"
+            "## Action items\n"
+            "- [unassigned] Review invalid meeting_id input parameters"
+        ),
+    })
+
+    assert M.digest_exists("poisoned") is False
+    assert M.get_digest("poisoned") == {
+        "found": False,
+        "meeting_id": "poisoned",
+    }
+    assert M.list_digests() == {"digests": [], "count": 0}
+
+
+def test_batch_reprocesses_poisoned_validation_digest():
+    meeting = {
+        "id": "poisoned",
+        "title": "Real meeting",
+        "date": "2026-07-29T13:59:24Z",
+    }
+    M.save_digest({
+        "meeting_id": meeting["id"],
+        "title": meeting["title"],
+        "processed_at": "2026-07-29T22:17:55",
+        "source": "transcript",
+        "context_chars": 133,
+        "digest_md": "- [unassigned] Review invalid meeting_id input parameters",
+    })
+
+    result = M.run_batch(
+        _cfg(),
+        client=FakeQuill([meeting], minutes="## Notes\n- fixed parcel routing"),
+        llm_call=lambda messages: "## Summary\n- Fixed parcel routing",
+    )
+
+    assert result["processed"] == 1
+    assert M.get_digest("poisoned")["digest_md"] == (
+        "## Summary\n- Fixed parcel routing"
+    )
+
+
 # ---------- process / batch -----------------------------------------------------------
 
 def test_process_meeting_uses_minutes_when_available():
diff --git a/tests/test_ffp_quill.py b/tests/test_ffp_quill.py
index c1fa19c..f8ad88e 100644
--- a/tests/test_ffp_quill.py
+++ b/tests/test_ffp_quill.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import ffp_quill
+import pytest
 
 
 def test_parse_meetings():
@@ -47,3 +48,67 @@ def test_parse_sse():
     )
     objs = ffp_quill._parse_sse(body)
     assert objs == [{"result": {"ok": True}, "id": 1}]
+
+
+def test_call_tool_raises_typed_error_for_mcp_is_error(monkeypatch):
+    client = ffp_quill.QuillClient()
+    client.session_id = "test"
+    monkeypatch.setattr(
+        client,
+        "_post",
+        lambda *args, **kwargs: {
+            "result": {
+                "isError": True,
+                "content": [{
+                    "type": "text",
+                    "text": (
+                        'Error: {"code":"validation_error",'
+                        '"message":"Invalid input parameters"}'
+                    ),
+                }],
+            },
+        },
+    )
+
+    with pytest.raises(ffp_quill.QuillToolError, match="Invalid input parameters"):
+        client.call_tool("get_transcript", {"id": "old-contract"})
+
+
+def test_call_tool_rejects_validation_payload_without_is_error(monkeypatch):
+    client = ffp_quill.QuillClient()
+    client.session_id = "test"
+    monkeypatch.setattr(
+        client,
+        "_post",
+        lambda *args, **kwargs: {
+            "result": {
+                "content": [{
+                    "type": "text",
+                    "text": (
+                        'Error: {"code":"validation_error",'
+                        '"message":"Invalid input parameters"}'
+                    ),
+                }],
+            },
+        },
+    )
+
+    with pytest.raises(ffp_quill.QuillToolError):
+        client.call_tool("get_transcript", {})
+
+
+def test_get_transcript_uses_current_quill_schema():
+    class FakeClient:
+        def __init__(self):
+            self.call = None
+
+        def call_tool(self, name, arguments):
+            self.call = (name, arguments)
+            return "<transcript>real content</transcript>"
+
+    client = FakeClient()
+    assert ffp_quill.get_transcript("meeting-1", client=client) == "real content"
+    assert client.call == (
+        "get_transcript",
+        {"meeting_id": "meeting-1", "include_private_notes": True},
+    )

From e1a5705c1e162851d3af6cc642328c0be9b9f853 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 22:50:19 -0400
Subject: [PATCH 08/12] T38: add guarded smart note categories

---
 SPEC.md                                       |   2 +-
 config/grammar_hotkey.config.example.json     |   1 +
 scripts/ffp_config.py                         |  55 ++++-
 scripts/ffp_daemon.py                         |  16 +-
 scripts/grammar_fix.py                        |   1 +
 scripts/notes.py                              | 191 +++++++++++++++++-
 scripts/ui/web/app.js                         | 121 ++++++++++-
 scripts/ui/web/index.html                     |  12 +-
 scripts/ui/web/styles.css                     |  44 ++++
 .../grammar_hotkey.config.example.json        |   1 +
 setup/defaults/grammar_hotkey.config.json     |   1 +
 tests/test_config_seeds.py                    |   5 +-
 tests/test_ffp_config.py                      |  34 ++++
 tests/test_ffp_daemon.py                      |   8 +-
 tests/test_notes_capture.py                   | 110 ++++++++++
 tests/test_notes_config_location.py           |  13 ++
 tests/test_notes_daemon_actions.py            |  28 +++
 tests/test_notes_workspace_ui.py              |   2 +
 18 files changed, 608 insertions(+), 37 deletions(-)

diff --git a/SPEC.md b/SPEC.md
index 626559a..b014802 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -163,7 +163,7 @@ T34|x|Notes-only card workspace: composer, editor, smart views, filters, tags, a
 T35|x|capture hotkey → Notes quick composer w/ staged selection or blank body|V53
 T36|x|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 T37|x|repair Quill transcript schema/error handling + poison-cache retry + re-digest latest|V12,V14,V20,V23,V57
-T38|.|guarded local-model category creation + sorted category manager + note organize action|V3,V7,V20,V49,V58
+T38|x|guarded local-model category creation + sorted category manager + note organize action|V3,V7,V20,V49,V58
 T39|.|compact Config section navigation + collapsible cards + sticky save|V5,V20,V55,V59
 T40|.|Activity workspace: merge Telemetry+History, card/detail UI, explicit Save as note|V5,V6,V25,V26,V60
 ```
diff --git a/config/grammar_hotkey.config.example.json b/config/grammar_hotkey.config.example.json
index eeb97b5..941a7df 100644
--- a/config/grammar_hotkey.config.example.json
+++ b/config/grammar_hotkey.config.example.json
@@ -94,6 +94,7 @@
     "fetch_timeout_seconds": 8,
     "max_extracted_chars": 2000,
     "low_confidence_to_inbox": true,
+    "allow_new_categories": true,
     "generate_title": true,
     "generate_summary": true
   },
diff --git a/scripts/ffp_config.py b/scripts/ffp_config.py
index 08aafe3..e2e2026 100644
--- a/scripts/ffp_config.py
+++ b/scripts/ffp_config.py
@@ -17,7 +17,7 @@
 
 log = logging.getLogger("ffp.config")
 
-_config_lock = threading.Lock()
+_config_lock = threading.RLock()
 
 CLAUDE_PROMPT_SYSTEM_PROMPT_V1 = (
     "Rewrite the user text as a Claude-ready prompt. "
@@ -92,6 +92,23 @@
         "min_chunk_chars": 700,
     },
     "prompt_builder": copy.deepcopy(ffp_prompt_builder.DEFAULT_PROMPT_BUILDER_CONFIG),
+    "notes": {
+        "vault_dir": r"%USERPROFILE%\Documents\FastFlowPrompt Notes",
+        "categories": [
+            "work/technical",
+            "work/managerial",
+            "work/career",
+            "research",
+            "personal",
+            "ideas",
+        ],
+        "fetch_timeout_seconds": 8,
+        "max_extracted_chars": 2000,
+        "low_confidence_to_inbox": True,
+        "allow_new_categories": True,
+        "generate_title": True,
+        "generate_summary": True,
+    },
     "dictionary": {
         "protected_words": [],
     },
@@ -232,18 +249,35 @@ def _enforce_builtin_mode_prompts(cfg: dict) -> None:
             user_mode["system_prompt"] = default_mode["system_prompt"]
 
 
+def _save_config_unlocked(config_path: Path, cfg: dict) -> None:
+    payload = json.dumps(cfg, ensure_ascii=False, indent=2) + "\n"
+    try:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = config_path.with_suffix(config_path.suffix + ".tmp")
+        tmp.write_text(payload, encoding="utf-8")
+        os.replace(tmp, config_path)
+    except OSError as exc:
+        log.warning("failed to save config %s: %s", config_path, exc)
+        raise
+
+
 def save_config(config_path: Path, cfg: dict) -> None:
     """Atomic write with a module lock to avoid torn JSON under concurrency."""
-    payload = json.dumps(cfg, ensure_ascii=False, indent=2) + "\n"
     with _config_lock:
-        try:
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-            tmp = config_path.with_suffix(config_path.suffix + ".tmp")
-            tmp.write_text(payload, encoding="utf-8")
-            os.replace(tmp, config_path)
-        except OSError as exc:
-            log.warning("failed to save config %s: %s", config_path, exc)
-            raise
+        _save_config_unlocked(config_path, cfg)
+
+
+def update_config(config_path: Path, mutator) -> dict:
+    """Atomically load, mutate, and replace config without a stale overwrite."""
+    with _config_lock:
+        cfg = load_config(config_path)
+        replacement = mutator(cfg)
+        if replacement is not None:
+            if not isinstance(replacement, dict):
+                raise TypeError("config mutator must return a dict or None")
+            cfg = replacement
+        _save_config_unlocked(config_path, cfg)
+        return cfg
 
 
 def deep_merge(dst: dict, src: dict) -> None:
@@ -378,6 +412,7 @@ def normalize_prompt_builder_config(cfg: dict) -> dict:
     "min_chunk_chars",
 })
 _PATCH_NOTES_KEYS = frozenset({
+    "allow_new_categories",
     "categories",
     "fetch_timeout_seconds",
     "generate_summary",
diff --git a/scripts/ffp_daemon.py b/scripts/ffp_daemon.py
index 720ebbb..788178f 100644
--- a/scripts/ffp_daemon.py
+++ b/scripts/ffp_daemon.py
@@ -702,6 +702,19 @@ def _act_note_update(args: dict) -> dict:
     )
 
 
+def _act_note_organize(args: dict) -> dict:
+    import notes
+    raw_revision = args.get("revision")
+    try:
+        revision = int(raw_revision) if raw_revision is not None else None
+    except (TypeError, ValueError):
+        raise ValueError("revision must be an integer") from None
+    return notes.organize_note(
+        str(args.get("note_id") or ""),
+        revision,
+    )
+
+
 def _act_note_archive(args: dict) -> dict:
     import notes
     raw_revision = args.get("revision")
@@ -1019,6 +1032,7 @@ def _act_meeting_week_summary(args: dict) -> dict:
     "note_get": _act_note_get,
     "note_create": _act_note_create,
     "note_update": _act_note_update,
+    "note_organize": _act_note_organize,
     "note_archive": _act_note_archive,
     "note_trash": _act_note_trash,
     "note_restore": _act_note_restore,
@@ -1070,7 +1084,7 @@ def _act_meeting_week_summary(args: dict) -> dict:
     "pull_model", "remove_model", "apply_config_patch", "update_apply",
     "set_autostart", "bench_start", "pull_start",
     "chat_send", "chat_thread_delete", "chat_stage_selection", "chat_take_staged",
-    "note_create", "note_update", "note_archive", "note_trash", "note_restore",
+    "note_create", "note_update", "note_organize", "note_archive", "note_trash", "note_restore",
     "note_move", "note_delete", "notes_board_save",
     "note_stage_capture", "note_take_staged",
     "notify_gate",  # writes the notifications log + updates dedupe state
diff --git a/scripts/grammar_fix.py b/scripts/grammar_fix.py
index 8c2ef77..fdc8048 100644
--- a/scripts/grammar_fix.py
+++ b/scripts/grammar_fix.py
@@ -929,6 +929,7 @@ def build_config_snapshot() -> dict:
             "fetch_timeout_seconds": int(notes_cfg.get("fetch_timeout_seconds") or 8),
             "max_extracted_chars": int(notes_cfg.get("max_extracted_chars") or 2000),
             "low_confidence_to_inbox": bool(notes_cfg.get("low_confidence_to_inbox", True)),
+            "allow_new_categories": bool(notes_cfg.get("allow_new_categories", True)),
             "generate_title": bool(notes_cfg.get("generate_title", True)),
             "generate_summary": bool(notes_cfg.get("generate_summary", True)),
         },
diff --git a/scripts/notes.py b/scripts/notes.py
index d4791d0..117f4b1 100644
--- a/scripts/notes.py
+++ b/scripts/notes.py
@@ -43,6 +43,7 @@
 from pathlib import Path
 from typing import Any
 
+import ffp_config
 import grammar_fix
 
 log = logging.getLogger("ffp.notes")
@@ -111,10 +112,66 @@ def _categories() -> list[str]:
         if not cat or cat == INBOX:
             continue
         try:
-            out.append(_safe_category(str(cat)))
+            clean = _safe_category(str(cat))
         except ValueError:
             continue
-    return out or list(DEFAULT_CATEGORIES)
+        if clean not in out:
+            out.append(clean)
+    return sorted(out or list(DEFAULT_CATEGORIES), key=str.casefold)
+
+
+def _allow_new_categories() -> bool:
+    return bool(_notes_cfg().get("allow_new_categories", True))
+
+
+_CATEGORY_SEGMENT_RE = re.compile(r"[^a-z0-9]+")
+
+
+def _normalize_model_category(category: str) -> str:
+    """Return a safe one/two-level slug for a model-proposed category."""
+    raw = str(category or "").strip().replace("\\", "/").strip("/")
+    parts = [part.strip() for part in raw.split("/")]
+    if not parts or len(parts) > 2 or any(not part for part in parts):
+        return ""
+    normalized: list[str] = []
+    for part in parts:
+        segment = _CATEGORY_SEGMENT_RE.sub("-", part.lower()).strip("-")
+        segment = segment[:32].rstrip("-")
+        if not segment:
+            return ""
+        normalized.append(segment)
+    candidate = "/".join(normalized)
+    if candidate == INBOX or len(candidate) > 65:
+        return ""
+    try:
+        return _safe_category(candidate)
+    except ValueError:
+        return ""
+
+
+def _register_model_category(category: str) -> bool:
+    """Atomically add a guarded model-created category to user config."""
+    clean = _normalize_model_category(category)
+    if not clean:
+        return False
+
+    def add_category(cfg: dict) -> None:
+        notes_cfg = cfg.setdefault("notes", {})
+        existing: list[str] = []
+        for item in notes_cfg.get("categories") or DEFAULT_CATEGORIES:
+            try:
+                safe = _safe_category(str(item))
+            except ValueError:
+                continue
+            if safe != INBOX and safe not in existing:
+                existing.append(safe)
+        if clean not in existing:
+            existing.append(clean)
+        notes_cfg["categories"] = sorted(existing, key=str.casefold)
+
+    updated = ffp_config.update_config(grammar_fix.CONFIG_PATH, add_category)
+    grammar_fix.refresh_runtime_config()
+    return clean in ((updated.get("notes") or {}).get("categories") or [])
 
 
 def _fetch_timeout() -> int:
@@ -305,23 +362,33 @@ def _slug_tokens_from_url(url: str) -> list[str]:
 
 def _build_categorize_prompt(text: str, source_app: str, url: str,
                              slug_tokens: list[str], fetched_title: str,
-                             fetched_body: str, categories: list[str]) -> str:
+                             fetched_body: str, categories: list[str],
+                             allow_new: bool = False) -> str:
     cats_block = "\n".join(f"  - {c}" for c in categories) + f"\n  - {INBOX}"
     parts = [
         "You categorize a captured note.",
-        "Pick EXACTLY ONE folder from the list below.",
+        "Prefer EXACTLY ONE existing folder from the list below.",
         f"If you are unsure, choose '{INBOX}'.",
         "",
         "Available folders:",
         cats_block,
         "",
         "Output ONLY a JSON object matching this schema, no commentary, no Markdown fences:",
-        '{"category":"<folder>","confidence":"high|medium|low",'
+        '{"category":"<folder>","is_new":false,'
+        '"confidence":"high|medium|low",'
         '"title":"<short Sentence-case title, <=60 chars>",'
         '"summary":"<1-2 paragraph summary, third person>"}',
         "",
         f"Source app: {source_app or 'unknown'}",
     ]
+    if allow_new:
+        parts[2:2] = [
+            "If no existing folder fits, you MAY propose one new lowercase slug "
+            "with at most two levels (example: learning/python) and set is_new=true.",
+            "Only propose a new folder when confidence is high; otherwise use inbox.",
+        ]
+    else:
+        parts.insert(2, "Do not invent folders; is_new must be false.")
     if url:
         parts.append(f"URL: {url}")
     if slug_tokens:
@@ -339,10 +406,12 @@ def _llm_categorize(text: str, source_app: str, url: str,
     """Returns {category, confidence, title, summary}. Falls back gracefully on
     LLM failure or invalid JSON."""
     cats = _categories()
+    allow_new = _allow_new_categories()
     slug_tokens = _slug_tokens_from_url(url) if url else []
     user_content = _build_categorize_prompt(
         text=text, source_app=source_app, url=url, slug_tokens=slug_tokens,
         fetched_title=fetched_title, fetched_body=fetched_body, categories=cats,
+        allow_new=allow_new,
     )
     system_prompt = (
         "You are a strict categorizer. Output only valid JSON matching the schema. "
@@ -356,6 +425,8 @@ def _llm_categorize(text: str, source_app: str, url: str,
     except Exception as e:
         log.warning("categorize LLM call failed: %s", e)
         return {"category": INBOX, "confidence": "low",
+                "suggested_category": INBOX, "is_new": False,
+                "created_category": False,
                 "title": _fallback_title(text, fetched_title),
                 "summary": "(LLM unavailable; left in inbox)"}
 
@@ -363,22 +434,48 @@ def _llm_categorize(text: str, source_app: str, url: str,
     if not parsed:
         log.warning("categorize returned unparseable JSON; raw=%r", raw[:200])
         return {"category": INBOX, "confidence": "low",
+                "suggested_category": INBOX, "is_new": False,
+                "created_category": False,
                 "title": _fallback_title(text, fetched_title),
                 "summary": "(could not parse categorization output)"}
 
-    # Validate category against the allowed list.
-    chosen = str(parsed.get("category") or "").strip()
-    if chosen not in cats and chosen != INBOX:
-        log.info("LLM picked unknown category %r; falling back to inbox", chosen)
-        chosen = INBOX
     confidence = str(parsed.get("confidence") or "low").strip().lower()
     if confidence not in {"high", "medium", "low"}:
         confidence = "low"
+    raw_category = str(parsed.get("category") or "").strip().replace("\\", "/")
+    requested_new = parsed.get("is_new") is True
+    created_category = False
+    suggested = raw_category if raw_category in cats or raw_category == INBOX else (
+        _normalize_model_category(raw_category)
+    )
+    if raw_category in cats or raw_category == INBOX:
+        chosen = raw_category
+    elif (
+        requested_new
+        and allow_new
+        and confidence == "high"
+        and suggested
+        and _register_model_category(suggested)
+    ):
+        chosen = suggested
+        created_category = True
+    else:
+        log.info(
+            "LLM category %r not accepted (new=%s allow=%s confidence=%s)",
+            raw_category,
+            requested_new,
+            allow_new,
+            confidence,
+        )
+        chosen = INBOX
     if confidence == "low" and _low_conf_to_inbox():
         chosen = INBOX
 
     return {
         "category": chosen,
+        "suggested_category": suggested or INBOX,
+        "is_new": requested_new,
+        "created_category": created_category,
         "confidence": confidence,
         "title": _clean_title(parsed.get("title"), text, fetched_title),
         "summary": str(parsed.get("summary") or "").strip(),
@@ -667,6 +764,8 @@ def _note_record(path: Path, metadata: dict, body: str, include_body: bool = Fal
         "due": str(metadata.get("due") or ""),
         "source": str(metadata.get("source") or ""),
         "summary": str(metadata.get("summary") or ""),
+        "suggested_category": str(metadata.get("suggested_category") or ""),
+        "confidence": str(metadata.get("confidence") or ""),
         "created": str(metadata.get("created") or ""),
         "updated": str(metadata.get("updated") or ""),
         "excerpt": excerpt,
@@ -1063,6 +1162,72 @@ def update_note(note_id: str, revision: int | None, patch: dict) -> dict:
         return _note_record(destination, merged, new_body, include_body=True)
 
 
+def organize_note(note_id: str, revision: int | None = None) -> dict:
+    """Use the local model to re-file a note without rewriting authored text."""
+    initial = get_note(note_id)
+    if not initial.get("ok"):
+        return initial
+    if initial.get("status") == "trashed":
+        return {"ok": False, "error": "trashed notes cannot be organized"}
+    categorized = _llm_categorize(
+        text="\n\n".join(filter(None, [
+            str(initial.get("title") or ""),
+            str(initial.get("body") or ""),
+        ])),
+        source_app="dashboard",
+        url=str(initial.get("source") or ""),
+        fetched_title="",
+        fetched_body="",
+    )
+
+    with _NOTES_LOCK:
+        source_path = _find_note_path(note_id, include_trash=True)
+        if source_path is None:
+            return {"ok": False, "error": "note not found"}
+        metadata, body, text = _ensure_note_schema(source_path)
+        if metadata.get("status") == "trashed":
+            return {"ok": False, "error": "trashed notes cannot be organized"}
+        current_revision = int(metadata.get("revision") or 1)
+        if revision is not None and int(revision) != current_revision:
+            return {
+                "ok": False,
+                "error": "note changed while the local model was organizing it",
+                "conflict": True,
+                "note": _note_record(
+                    source_path,
+                    metadata,
+                    body,
+                    include_body=True,
+                ),
+            }
+
+        category = _safe_category(str(categorized.get("category") or INBOX))
+        updates = {
+            "category": category,
+            "suggested_category": str(
+                categorized.get("suggested_category") or category
+            ),
+            "confidence": str(categorized.get("confidence") or "low"),
+            "category_created": bool(categorized.get("created_category")),
+            "updated": _now_iso(),
+            "revision": current_revision + 1,
+        }
+        destination = _vault_subpath(category, source_path.name)
+        if destination.exists() and destination.resolve() != source_path.resolve():
+            destination = _vault_subpath(
+                category,
+                f"{source_path.stem}-{uuid.uuid4().hex[:6]}{source_path.suffix}",
+            )
+        rewritten = _merge_frontmatter(text, updates, body=body)
+        _atomic_write_text(destination, rewritten)
+        if destination.resolve() != source_path.resolve() and source_path.exists():
+            source_path.unlink()
+        merged = dict(metadata)
+        merged.update(updates)
+        _invalidate_index()
+        return _note_record(destination, merged, body, include_body=True)
+
+
 def archive_note(note_id: str, revision: int | None = None) -> dict:
     return update_note(note_id, revision, {"status": "archived"})
 
@@ -1422,7 +1587,11 @@ def _categorize_in_background(stub_path: Path, note_id: str, text: str,
             current_revision = int(metadata.get("revision") or 1)
             updates: dict[str, Any] = {
                 "confidence": categorized["confidence"],
-                "suggested_category": categorized["category"],
+                "suggested_category": categorized.get(
+                    "suggested_category",
+                    categorized["category"],
+                ),
+                "category_created": bool(categorized.get("created_category")),
                 "summary": categorized["summary"] if _wants_summary() else "",
                 "fetch_status": (
                     "error" if fetched and fetched.get("error")
diff --git a/scripts/ui/web/app.js b/scripts/ui/web/app.js
index e3e681c..13f4472 100644
--- a/scripts/ui/web/app.js
+++ b/scripts/ui/web/app.js
@@ -1051,6 +1051,7 @@ function setEditorReadOnly(trashed) {
     $(id).disabled = trashed;
   }
   $("ne-save").hidden = trashed;
+  $("ne-organize").disabled = trashed || !notesState.current?.note_id;
   $("ne-archive").hidden = trashed || notesState.current?.status === "archived";
   $("ne-trash").hidden = trashed;
   $("ne-restore").hidden = !trashed;
@@ -1199,6 +1200,44 @@ async function saveNoteEditor() {
   }
 }
 
+async function organizeCurrentNote() {
+  if (!notesState.current?.note_id) {
+    setEditorStatus("Save the note before organizing it.", false);
+    return;
+  }
+  const button = $("ne-organize");
+  button.disabled = true;
+  setEditorStatus("Organizing with the local model…");
+  try {
+    const organized = await action("note_organize", {
+      note_id: notesState.current.note_id,
+      revision: notesState.current.revision,
+    });
+    if (!organized.ok) {
+      if (organized.conflict && organized.note) {
+        notesState.current = organized.note;
+        fillNoteEditor(organized.note);
+      }
+      setEditorStatus(organized.error || "Organize failed.", false);
+      return;
+    }
+    notesState.current = organized;
+    await loadNotes(false);
+    fillNoteEditor(organized);
+    const suggestion = organized.suggested_category;
+    const detail = organized.category === "inbox"
+      && suggestion && suggestion !== "inbox"
+      ? ` Kept in Inbox; suggested ${suggestion}.`
+      : ` Filed in ${organized.category}.`;
+    setEditorStatus(`Organized.${detail}`);
+  } catch (error) {
+    setEditorStatus(`Organize failed: ${error.message}`, false);
+  } finally {
+    button.disabled = !notesState.current?.note_id
+      || notesState.current?.status === "trashed";
+  }
+}
+
 async function archiveCurrentNote() {
   if (!notesState.current?.note_id) return;
   try {
@@ -1320,25 +1359,87 @@ async function loadNotes(takeStaged = true) {
 function populateNotesConfig(notes) {
   const cfg = notes || {};
   $("notes-vault").value = cfg.vault_dir || "";
-  $("notes-categories").value = (cfg.categories || []).join("\n");
+  notesCategories = [...new Set((cfg.categories || [])
+    .map(normalizeConfigCategory)
+    .filter(Boolean))]
+    .sort((a, b) => a.localeCompare(b));
+  renderNotesCategoryManager();
   $("notes-fetch-timeout").value = cfg.fetch_timeout_seconds ?? 8;
   $("notes-max-chars").value = cfg.max_extracted_chars ?? 2000;
   $("notes-low-conf").checked = cfg.low_confidence_to_inbox !== false;
+  $("notes-allow-new").checked = cfg.allow_new_categories !== false;
   $("notes-gen-title").checked = cfg.generate_title !== false;
   $("notes-gen-summary").checked = cfg.generate_summary !== false;
 }
 
+function normalizeConfigCategory(value) {
+  const parts = String(value || "")
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\/+|\/+$/g, "")
+    .split("/");
+  if (parts.length < 1 || parts.length > 2) return "";
+  const normalized = parts.map((part) => part
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 32)
+    .replace(/-+$/g, ""));
+  if (normalized.some((part) => !part)) return "";
+  const category = normalized.join("/");
+  return category === "inbox" || category.length > 65 ? "" : category;
+}
+
+function renderNotesCategoryManager() {
+  const list = $("notes-categories");
+  list.replaceChildren();
+  for (const category of notesCategories) {
+    const row = document.createElement("div");
+    row.className = "config-category";
+    row.setAttribute("role", "listitem");
+    const label = document.createElement("span");
+    label.textContent = category;
+    const remove = document.createElement("button");
+    remove.type = "button";
+    remove.className = "config-category-remove";
+    remove.textContent = "×";
+    remove.setAttribute("aria-label", `Remove ${category}`);
+    remove.addEventListener("click", () => {
+      notesCategories = notesCategories.filter((item) => item !== category);
+      renderNotesCategoryManager();
+    });
+    row.append(label, remove);
+    list.append(row);
+  }
+}
+
+function addNotesCategory() {
+  const input = $("notes-category-new");
+  const category = normalizeConfigCategory(input.value);
+  if (!category) {
+    setStatus(
+      "config-status",
+      "⚠ Use one safe folder or parent/child pair, such as research or work/technical.",
+      false,
+    );
+    return;
+  }
+  if (!notesCategories.includes(category)) notesCategories.push(category);
+  notesCategories.sort((a, b) => a.localeCompare(b));
+  input.value = "";
+  renderNotesCategoryManager();
+  setStatus("config-status", "");
+}
+
 function notesConfigPatch() {
-  const categories = $("notes-categories").value
-    .split("\n")
-    .map((line) => line.trim().replace(/^\/+|\/+$/g, ""))
-    .filter(Boolean);
   return {
     vault_dir: $("notes-vault").value.trim(),
-    categories,
+    categories: [...notesCategories],
     fetch_timeout_seconds: Number($("notes-fetch-timeout").value) || 8,
     max_extracted_chars: Number($("notes-max-chars").value) || 2000,
     low_confidence_to_inbox: $("notes-low-conf").checked,
+    allow_new_categories: $("notes-allow-new").checked,
     generate_title: $("notes-gen-title").checked,
     generate_summary: $("notes-gen-summary").checked,
   };
@@ -2691,6 +2792,7 @@ document.addEventListener("DOMContentLoaded", () => {
   $("notes-empty-new").addEventListener("click", () => openNewNote());
   $("ne-close").addEventListener("click", closeNoteEditor);
   $("ne-save").addEventListener("click", saveNoteEditor);
+  $("ne-organize").addEventListener("click", organizeCurrentNote);
   $("ne-archive").addEventListener("click", archiveCurrentNote);
   $("ne-trash").addEventListener("click", trashCurrentNote);
   $("ne-restore").addEventListener("click", restoreCurrentNote);
@@ -2728,6 +2830,13 @@ document.addEventListener("DOMContentLoaded", () => {
   $("mtg-week-gen").addEventListener("click", generateWeekSummary);
   $("config-save").addEventListener("click", saveConfig);
   $("config-revert").addEventListener("click", loadConfig);
+  $("notes-category-add").addEventListener("click", addNotesCategory);
+  $("notes-category-new").addEventListener("keydown", (event) => {
+    if (event.key === "Enter") {
+      event.preventDefault();
+      addNotesCategory();
+    }
+  });
   $("cm-select").addEventListener("change", fillCustomModeForm);
   $("cm-save").addEventListener("click", saveCustomMode);
   $("cm-delete").addEventListener("click", deleteCustomMode);
diff --git a/scripts/ui/web/index.html b/scripts/ui/web/index.html
index 8e15fff..6879012 100644
--- a/scripts/ui/web/index.html
+++ b/scripts/ui/web/index.html
@@ -291,6 +291,7 @@ <h2 id="ne-heading">New note</h2>
           <p class="notes-ai-summary" id="ne-summary" hidden></p>
           <div class="notes-editor-actions">
             <button class="btn btn-primary" id="ne-save" type="button">Save note</button>
+            <button class="btn" id="ne-organize" type="button">Organize with local model</button>
             <button class="btn" id="ne-archive" type="button">Archive</button>
             <button class="btn" id="ne-restore" type="button" hidden>Restore</button>
             <button class="btn btn-danger" id="ne-trash" type="button">Move to Trash</button>
@@ -390,8 +391,14 @@ <h3 class="subhead">Storage</h3>
           <input type="text" id="notes-vault">
         </div>
         <h3 class="subhead">Organization</h3>
-        <label for="notes-categories">Categories <span class="muted small">(one per line)</span></label>
-        <textarea id="notes-categories" rows="6" spellcheck="false"></textarea>
+        <div id="notes-categories" class="config-category-list"
+             role="list" aria-label="Note categories"></div>
+        <div class="config-category-add">
+          <input type="text" id="notes-category-new"
+                 placeholder="Add category, e.g. learning/python">
+          <button class="btn" id="notes-category-add" type="button">Add</button>
+        </div>
+        <p class="muted small">Categories are kept sorted. Use one folder or a parent/child pair.</p>
         <h3 class="subhead">Link extraction &amp; enrichment</h3>
         <div class="form-row">
           <label for="notes-fetch-timeout">Fetch timeout (s)</label>
@@ -402,6 +409,7 @@ <h3 class="subhead">Link extraction &amp; enrichment</h3>
           <input type="number" id="notes-max-chars" min="100" max="100000">
         </div>
         <label class="check-row"><input type="checkbox" id="notes-low-conf"> Keep low-confidence categorizations in Inbox</label>
+        <label class="check-row"><input type="checkbox" id="notes-allow-new"> Allow the local model to create a new category when confidence is high</label>
         <label class="check-row"><input type="checkbox" id="notes-gen-title"> Suggest titles with the local model</label>
         <label class="check-row"><input type="checkbox" id="notes-gen-summary"> Generate summaries with the local model</label>
       </div>
diff --git a/scripts/ui/web/styles.css b/scripts/ui/web/styles.css
index d3987f4..6007d79 100644
--- a/scripts/ui/web/styles.css
+++ b/scripts/ui/web/styles.css
@@ -1181,6 +1181,50 @@ footer { padding: 14px 24px 22px; }
   gap: 6px;
   margin-top: 8px;
 }
+.config-category-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 7px;
+  min-height: 38px;
+  padding: 8px;
+  border: 1px solid var(--border);
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--bg) 55%, var(--surface));
+}
+.config-category {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 5px 6px 5px 9px;
+  border: 1px solid color-mix(in srgb, var(--accent) 30%, var(--border));
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--text);
+  font-size: 12px;
+}
+.config-category-remove {
+  display: grid;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  place-items: center;
+  border: 0;
+  border-radius: 50%;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+}
+.config-category-remove:hover,
+.config-category-remove:focus-visible {
+  background: color-mix(in srgb, var(--accent) 18%, transparent);
+  color: var(--accent);
+}
+.config-category-add {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 7px;
+  margin-top: 8px;
+}
 .notes-ai-summary {
   margin: 7px 0 0;
   padding: 9px 10px;
diff --git a/setup/defaults/grammar_hotkey.config.example.json b/setup/defaults/grammar_hotkey.config.example.json
index eeb97b5..941a7df 100644
--- a/setup/defaults/grammar_hotkey.config.example.json
+++ b/setup/defaults/grammar_hotkey.config.example.json
@@ -94,6 +94,7 @@
     "fetch_timeout_seconds": 8,
     "max_extracted_chars": 2000,
     "low_confidence_to_inbox": true,
+    "allow_new_categories": true,
     "generate_title": true,
     "generate_summary": true
   },
diff --git a/setup/defaults/grammar_hotkey.config.json b/setup/defaults/grammar_hotkey.config.json
index 23ed101..650a5b7 100644
--- a/setup/defaults/grammar_hotkey.config.json
+++ b/setup/defaults/grammar_hotkey.config.json
@@ -98,6 +98,7 @@
     "fetch_timeout_seconds": 8,
     "max_extracted_chars": 2000,
     "low_confidence_to_inbox": true,
+    "allow_new_categories": true,
     "generate_title": true,
     "generate_summary": true
   },
diff --git a/tests/test_config_seeds.py b/tests/test_config_seeds.py
index 144a319..47357dd 100644
--- a/tests/test_config_seeds.py
+++ b/tests/test_config_seeds.py
@@ -57,8 +57,7 @@ def test_shipped_seed_keys_do_not_silently_drift_from_schema():
         f"seed vs schema drift changed (missing from seed): {sorted(missing_from_seed)}"
     )
     # In seed, not top-level in schema: runtime/user-managed optional blocks
-    # (chat threads config, per-hotkey overrides, notes vault config) the app
-    # reads directly; DEFAULT_CONFIG doesn't declare them.
-    assert extra_in_seed == {"chat", "hotkeys", "notes"}, (
+    # (chat threads config and per-hotkey overrides) the app reads directly.
+    assert extra_in_seed == {"chat", "hotkeys"}, (
         f"seed vs schema drift changed (extra in seed): {sorted(extra_in_seed)}"
     )
diff --git a/tests/test_ffp_config.py b/tests/test_ffp_config.py
index e5c40d5..e53dfb2 100644
--- a/tests/test_ffp_config.py
+++ b/tests/test_ffp_config.py
@@ -280,6 +280,40 @@ def test_default_config_has_prompt_builder_defaults():
     assert ffp_config.DEFAULT_CONFIG["prompt_builder"] == ffp_prompt_builder.DEFAULT_PROMPT_BUILDER_CONFIG
     assert ffp_config.DEFAULT_CONFIG["server"]["warm_on_start"] is True
     assert ffp_config.DEFAULT_CONFIG["server"]["keep_warm_minutes"] == 15
+    assert ffp_config.DEFAULT_CONFIG["notes"]["allow_new_categories"] is True
+
+
+def test_filter_config_patch_accepts_guarded_note_category_setting():
+    filtered = ffp_config.filter_config_patch({
+        "notes": {
+            "categories": ["research", "work/technical"],
+            "allow_new_categories": False,
+            "unknown": "drop me",
+        },
+    })
+
+    assert filtered == {
+        "notes": {
+            "categories": ["research", "work/technical"],
+            "allow_new_categories": False,
+        },
+    }
+
+
+def test_update_config_load_mutate_write_is_atomic(tmp_path):
+    path = tmp_path / "config.json"
+    ffp_config.save_config(path, {"notes": {"categories": ["research"]}})
+
+    updated = ffp_config.update_config(
+        path,
+        lambda cfg: cfg["notes"]["categories"].append("ideas"),
+    )
+
+    assert updated["notes"]["categories"] == ["research", "ideas"]
+    assert ffp_config.load_config(path)["notes"]["categories"] == [
+        "research",
+        "ideas",
+    ]
 
 
 def test_filter_config_patch_clamps_keep_warm_settings():
diff --git a/tests/test_ffp_daemon.py b/tests/test_ffp_daemon.py
index f453051..1051c1e 100644
--- a/tests/test_ffp_daemon.py
+++ b/tests/test_ffp_daemon.py
@@ -77,12 +77,13 @@ def test_actions_count_and_expected_names(daemon_module):
     # meeting_ask -> 69; meeting_overview -> 70; meeting_actions_list /
     # meeting_action_set_status / meeting_week_summary -> 73; meeting_redigest
     # (strict re-run of a digest) -> 74; prompt_builder_preview -> 75;
-    # Notes v2 query/CRUD/Trash/board/staging adds 10 -> 85.
-    assert len(daemon_module.ACTIONS) == 85
+    # Notes v2 query/CRUD/Trash/board/staging adds 10 -> 85;
+    # local-model note organization adds one -> 86.
+    assert len(daemon_module.ACTIONS) == 86
     for a in ("chat_threads_list", "chat_thread_get", "chat_send",
               "chat_thread_delete", "chat_stage_selection", "chat_take_staged",
               "note_get", "note_move", "note_delete", "notes_query",
-              "note_create", "note_update", "note_archive", "note_trash",
+              "note_create", "note_update", "note_organize", "note_archive", "note_trash",
               "note_restore", "notes_board_get", "notes_board_save",
               "note_stage_capture", "note_take_staged",
               "notify_gate", "notifications_log",
@@ -623,6 +624,7 @@ def test_post_config_snapshot_returns_flat_dashboard_fields(daemon_server):
     }
     notes = payload["result"]["notes"]
     assert isinstance(notes.get("categories"), list)
+    assert notes["allow_new_categories"] is True
     assert payload["result"]["server"]["warm_on_start"] is True
     assert payload["result"]["server"]["keep_warm_minutes"] == 15
     assert set(payload["result"]["llm"]) >= {"provider", "base_url", "model", "configured_provider"}
diff --git a/tests/test_notes_capture.py b/tests/test_notes_capture.py
index 1dd087b..fd93e9e 100644
--- a/tests/test_notes_capture.py
+++ b/tests/test_notes_capture.py
@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import json
 import re
 
+import ffp_config
 import notes
 import pytest
 
@@ -23,6 +25,17 @@ def test_safe_category_accepts_and_normalizes(raw, expected):
     assert notes._safe_category(raw) == expected
 
 
+@pytest.mark.parametrize(("raw", "expected"), [
+    ("Learning / Python", "learning/python"),
+    ("Project Ideas", "project-ideas"),
+    ("one/two/three", ""),
+    ("../escape", ""),
+    ("inbox", ""),
+])
+def test_model_category_normalization_is_safe_and_bounded(raw, expected):
+    assert notes._normalize_model_category(raw) == expected
+
+
 # ---------- _parse_categorize_json (robust LLM-output parsing) ---------------
 
 def test_parse_categorize_json_plain_object():
@@ -44,6 +57,103 @@ def test_parse_categorize_json_returns_none_on_garbage(raw):
     assert notes._parse_categorize_json(raw) is None
 
 
+def _categorize_result(monkeypatch, payload, *, allow_new=True):
+    registered = []
+    monkeypatch.setattr(notes, "_notes_cfg", lambda: {
+        "categories": ["ideas", "research"],
+        "allow_new_categories": allow_new,
+        "low_confidence_to_inbox": True,
+    })
+    monkeypatch.setattr(
+        notes,
+        "_register_model_category",
+        lambda category: registered.append(category) or True,
+    )
+    monkeypatch.setattr(
+        notes.grammar_fix,
+        "_call_flm_api",
+        lambda *args, **kwargs: (json.dumps(payload), "local-model"),
+    )
+    return notes._llm_categorize("some note", "", "", "", ""), registered
+
+
+def test_known_category_is_selected_without_creating_one(monkeypatch):
+    result, registered = _categorize_result(monkeypatch, {
+        "category": "research",
+        "is_new": False,
+        "confidence": "high",
+        "title": "Research note",
+        "summary": "Summary",
+    })
+
+    assert result["category"] == "research"
+    assert result["created_category"] is False
+    assert registered == []
+
+
+def test_high_confidence_explicit_new_category_is_registered(monkeypatch):
+    result, registered = _categorize_result(monkeypatch, {
+        "category": "Learning / Python",
+        "is_new": True,
+        "confidence": "high",
+        "title": "Python note",
+        "summary": "Summary",
+    })
+
+    assert result["category"] == "learning/python"
+    assert result["suggested_category"] == "learning/python"
+    assert result["created_category"] is True
+    assert registered == ["learning/python"]
+
+
+@pytest.mark.parametrize(("allow_new", "is_new", "confidence"), [
+    (False, True, "high"),
+    (True, False, "high"),
+    (True, True, "medium"),
+    (True, True, "low"),
+])
+def test_unapproved_new_category_stays_in_inbox(
+    monkeypatch,
+    allow_new,
+    is_new,
+    confidence,
+):
+    result, registered = _categorize_result(
+        monkeypatch,
+        {
+            "category": "Learning / Python",
+            "is_new": is_new,
+            "confidence": confidence,
+            "title": "Python note",
+            "summary": "Summary",
+        },
+        allow_new=allow_new,
+    )
+
+    assert result["category"] == "inbox"
+    assert result["suggested_category"] == "learning/python"
+    assert result["created_category"] is False
+    assert registered == []
+
+
+def test_register_model_category_atomically_dedupes_and_sorts(tmp_path, monkeypatch):
+    config_path = tmp_path / "config.json"
+    ffp_config.save_config(config_path, {
+        "notes": {"categories": ["research", "Ideas", "research"]},
+    })
+    monkeypatch.setattr(notes.grammar_fix, "CONFIG_PATH", config_path)
+    monkeypatch.setattr(notes.grammar_fix, "refresh_runtime_config", lambda: None)
+
+    assert notes._register_model_category("learning/python") is True
+
+    saved = json.loads(config_path.read_text(encoding="utf-8"))
+    assert saved["notes"]["categories"] == [
+        "Ideas",
+        "learning/python",
+        "research",
+    ]
+
+
 # ---------- HTML extraction (stdlib parser path) -----------------------------
 
 def test_text_extractor_strips_scripts_and_keeps_title():
diff --git a/tests/test_notes_config_location.py b/tests/test_notes_config_location.py
index b12346c..9faad1b 100644
--- a/tests/test_notes_config_location.py
+++ b/tests/test_notes_config_location.py
@@ -10,6 +10,7 @@
     "notes-fetch-timeout",
     "notes-max-chars",
     "notes-low-conf",
+    "notes-allow-new",
     "notes-gen-title",
     "notes-gen-summary",
 }
@@ -34,3 +35,15 @@ def test_notes_settings_use_config_single_save_flow():
     assert "notes: notesPatch" in app
     assert "function saveNotes()" not in app
     assert '"notes-save"' not in app
+
+
+def test_category_manager_is_compact_sorted_and_model_creation_is_opt_in():
+    html = (WEB / "index.html").read_text(encoding="utf-8")
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+
+    assert 'id="notes-category-new"' in html
+    assert 'id="notes-category-add"' in html
+    assert '<textarea id="notes-categories"' not in html
+    assert "function renderNotesCategoryManager()" in app
+    assert "notesCategories.sort((a, b) => a.localeCompare(b))" in app
+    assert 'allow_new_categories: $("notes-allow-new").checked' in app
diff --git a/tests/test_notes_daemon_actions.py b/tests/test_notes_daemon_actions.py
index 89b939c..15f3a15 100644
--- a/tests/test_notes_daemon_actions.py
+++ b/tests/test_notes_daemon_actions.py
@@ -91,3 +91,31 @@ def test_notes_board_daemon_round_trip(vault):
 
     assert saved["ok"] is True
     assert saved["board"]["placements"][0]["note_id"] == note["note_id"]
+
+
+def test_note_organize_refiles_without_rewriting_authored_text(vault, monkeypatch):
+    created = ffp_daemon._act_note_create({
+        "title": "My exact title",
+        "body": "My exact body.\nSecond line.",
+        "category": "ideas",
+    })
+    monkeypatch.setattr(notes, "_llm_categorize", lambda **kwargs: {
+        "category": "research",
+        "suggested_category": "research",
+        "confidence": "high",
+        "created_category": False,
+        "title": "Model title must not be used",
+        "summary": "Model summary must not be used",
+    })
+
+    organized = ffp_daemon._act_note_organize({
+        "note_id": created["note_id"],
+        "revision": created["revision"],
+    })
+
+    assert organized["category"] == "research"
+    assert organized["suggested_category"] == "research"
+    assert organized["confidence"] == "high"
+    assert organized["title"] == "My exact title"
+    assert organized["body"] == "My exact body.\nSecond line.\n"
+    assert organized["revision"] == created["revision"] + 1
diff --git a/tests/test_notes_workspace_ui.py b/tests/test_notes_workspace_ui.py
index fd4ab7d..bf7c05c 100644
--- a/tests/test_notes_workspace_ui.py
+++ b/tests/test_notes_workspace_ui.py
@@ -25,6 +25,7 @@ def test_notes_panel_is_a_workspace_not_a_table_or_settings_page():
         "ne-color",
         "ne-on-board",
         "ne-save",
+        "ne-organize",
         "ne-trash",
         "ne-restore",
         "ne-delete",
@@ -43,6 +44,7 @@ def test_notes_workspace_uses_v2_actions_and_safe_dom_construction():
         "note_get",
         "note_create",
         "note_update",
+        "note_organize",
         "note_archive",
         "note_trash",
         "note_restore",

From 141cbcb6e33719d86b649f2a42bf8df5134a40cf Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Wed, 29 Jul 2026 23:00:42 -0400
Subject: [PATCH 09/12] T39: redesign compact Config workspace

---
 SPEC.md                           |   2 +-
 scripts/ui/web/app.js             | 127 ++++++++++++++++++++++++++++
 scripts/ui/web/index.html         |  74 +++++++++++++----
 scripts/ui/web/styles.css         | 134 ++++++++++++++++++++++++++++++
 tests/test_config_workspace_ui.py |  55 ++++++++++++
 5 files changed, 374 insertions(+), 18 deletions(-)
 create mode 100644 tests/test_config_workspace_ui.py

diff --git a/SPEC.md b/SPEC.md
index b014802..7880833 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -164,7 +164,7 @@ T35|x|capture hotkey → Notes quick composer w/ staged selection or blank body|
 T36|x|2.5.0 docs/version/migration + full release gates|V18,V20,V47,V48,V49,V50,V51,V52,V53,V54,V55
 T37|x|repair Quill transcript schema/error handling + poison-cache retry + re-digest latest|V12,V14,V20,V23,V57
 T38|x|guarded local-model category creation + sorted category manager + note organize action|V3,V7,V20,V49,V58
-T39|.|compact Config section navigation + collapsible cards + sticky save|V5,V20,V55,V59
+T39|x|compact Config section navigation + collapsible cards + sticky save|V5,V20,V55,V59
 T40|.|Activity workspace: merge Telemetry+History, card/detail UI, explicit Save as note|V5,V6,V25,V26,V60
 ```
 
diff --git a/scripts/ui/web/app.js b/scripts/ui/web/app.js
index 13f4472..98df169 100644
--- a/scripts/ui/web/app.js
+++ b/scripts/ui/web/app.js
@@ -1447,6 +1447,132 @@ function notesConfigPatch() {
 
 // ---- Config ----------------------------------------------------------------
 
+const CONFIG_SECTION_KEY = "flowkey.config.section.v1";
+const CONFIG_COLLAPSED_KEY = "flowkey.config.collapsed.v1";
+const CONFIG_SECTION_META = {
+  essentials: ["Essentials", "Everyday shortcuts, performance, privacy, and tone."],
+  models: ["Models & AI", "Choose the local provider, runtime, and active model."],
+  notes: ["Notes", "Control the vault, categories, capture, and local enrichment."],
+  prompts: ["Prompts", "Shape prompt output and create your own prefix modes."],
+  notifications: ["Notifications", "Decide which local desktop signals deserve attention."],
+  meetings: ["Meetings", "Connect Quill and schedule after-hours digest processing."],
+  advanced: ["Advanced", "Tune long-input routing and lower-level behavior."],
+};
+
+let activeConfigSection = "essentials";
+let collapsedConfigCards = new Set();
+
+function readConfigWorkspaceState() {
+  try {
+    const savedSection = localStorage.getItem(CONFIG_SECTION_KEY);
+    if (CONFIG_SECTION_META[savedSection]) activeConfigSection = savedSection;
+    const savedCollapsed = JSON.parse(
+      localStorage.getItem(CONFIG_COLLAPSED_KEY) || "[]",
+    );
+    if (Array.isArray(savedCollapsed)) {
+      collapsedConfigCards = new Set(savedCollapsed.map(String));
+    }
+  } catch {
+    activeConfigSection = "essentials";
+    collapsedConfigCards = new Set();
+  }
+}
+
+function saveCollapsedConfigCards() {
+  try {
+    localStorage.setItem(
+      CONFIG_COLLAPSED_KEY,
+      JSON.stringify([...collapsedConfigCards]),
+    );
+  } catch {
+    /* local-only view preference; safe to forget when storage is unavailable */
+  }
+}
+
+function setConfigCardCollapsed(card, collapsed) {
+  card.classList.toggle("is-collapsed", collapsed);
+  const button = card.querySelector(":scope > h2 .config-card-toggle");
+  if (!button) return;
+  const title = button.dataset.title || "settings";
+  button.textContent = collapsed ? "›" : "▾";
+  button.setAttribute("aria-expanded", String(!collapsed));
+  button.setAttribute(
+    "aria-label",
+    `${collapsed ? "Expand" : "Collapse"} ${title}`,
+  );
+}
+
+function initializeConfigCards() {
+  for (const card of document.querySelectorAll("#config-grid > .card")) {
+    card.classList.add("config-card");
+    const heading = card.querySelector(":scope > h2");
+    if (!heading || heading.querySelector(".config-card-toggle")) continue;
+    heading.classList.add("config-card-heading");
+    const title = heading.textContent.trim() || "settings";
+    const toggle = document.createElement("button");
+    toggle.type = "button";
+    toggle.className = "config-card-toggle";
+    toggle.dataset.title = title;
+    toggle.addEventListener("click", () => {
+      const collapsed = !card.classList.contains("is-collapsed");
+      if (collapsed) collapsedConfigCards.add(card.id);
+      else collapsedConfigCards.delete(card.id);
+      setConfigCardCollapsed(card, collapsed);
+      saveCollapsedConfigCards();
+    });
+    heading.append(toggle);
+    setConfigCardCollapsed(card, collapsedConfigCards.has(card.id));
+  }
+}
+
+function setConfigSection(section, focus = false) {
+  const selected = CONFIG_SECTION_META[section] ? section : "essentials";
+  activeConfigSection = selected;
+  const tabs = [...document.querySelectorAll("#config-sections [role='tab']")];
+  for (const tab of tabs) {
+    const active = tab.dataset.configSection === selected;
+    tab.classList.toggle("active", active);
+    tab.setAttribute("aria-selected", String(active));
+    tab.tabIndex = active ? 0 : -1;
+    if (active && focus) tab.focus();
+  }
+  for (const card of document.querySelectorAll("#config-grid > [data-config-section]")) {
+    card.hidden = card.dataset.configSection !== selected;
+  }
+  const [title, description] = CONFIG_SECTION_META[selected];
+  $("config-section-title").textContent = title;
+  $("config-section-description").textContent = description;
+  try {
+    localStorage.setItem(CONFIG_SECTION_KEY, selected);
+  } catch {
+    /* local-only view preference */
+  }
+}
+
+function initializeConfigWorkspace() {
+  readConfigWorkspaceState();
+  initializeConfigCards();
+  setConfigSection(activeConfigSection);
+  $("config-sections").addEventListener("click", (event) => {
+    const tab = event.target.closest("[data-config-section]");
+    if (tab) setConfigSection(tab.dataset.configSection);
+  });
+  $("config-sections").addEventListener("keydown", (event) => {
+    const tabs = [...document.querySelectorAll("#config-sections [role='tab']")];
+    const current = tabs.indexOf(event.target.closest("[role='tab']"));
+    if (current < 0) return;
+    let next = current;
+    if (event.key === "ArrowRight") next = (current + 1) % tabs.length;
+    else if (event.key === "ArrowLeft") {
+      next = (current - 1 + tabs.length) % tabs.length;
+    } else if (event.key === "Home") next = 0;
+    else if (event.key === "End") next = tabs.length - 1;
+    else return;
+    event.preventDefault();
+    setConfigSection(tabs[next].dataset.configSection, true);
+  });
+}
+
 function populatePromptBuilder(pb) {
   const cfg = { ...PROMPT_BUILDER_DEFAULTS, ...(pb || {}) };
   $("pb-version").value = cfg.prompt_version;
@@ -2755,6 +2881,7 @@ function tabFromHash() {
 }
 
 document.addEventListener("DOMContentLoaded", () => {
+  initializeConfigWorkspace();
   attachHelpMarker("history-store-help", HISTORY_STORE_HELP_TEXT);
   $("tabs").addEventListener("click", (e) => {
     const btn = e.target.closest(".tab");
diff --git a/scripts/ui/web/index.html b/scripts/ui/web/index.html
index 6879012..338df3c 100644
--- a/scripts/ui/web/index.html
+++ b/scripts/ui/web/index.html
@@ -372,8 +372,47 @@ <h2>Weekly review</h2>
   </section>
 
   <section class="panel" id="tab-config">
-    <div class="grid">
-      <div class="card">
+    <div class="config-head">
+      <div>
+        <p class="eyebrow">Settings workspace</p>
+        <h2 id="config-section-title">Essentials</h2>
+        <p class="muted" id="config-section-description">Everyday shortcuts and preferences.</p>
+      </div>
+      <nav class="config-sections" id="config-sections" role="tablist"
+           aria-label="Configuration sections">
+        <button type="button" role="tab" class="config-section-tab active"
+                data-config-section="essentials" aria-controls="config-grid"
+                aria-selected="true">Essentials</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="models" aria-controls="config-grid"
+                aria-selected="false">Models &amp; AI</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="notes" aria-controls="config-grid"
+                aria-selected="false">Notes</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="prompts" aria-controls="config-grid"
+                aria-selected="false">Prompts</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="notifications" aria-controls="config-grid"
+                aria-selected="false">Notifications</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="meetings" aria-controls="config-grid"
+                aria-selected="false">Meetings</button>
+        <button type="button" role="tab" class="config-section-tab"
+                data-config-section="advanced" aria-controls="config-grid"
+                aria-selected="false">Advanced</button>
+      </nav>
+    </div>
+    <div class="config-save-bar">
+      <span class="muted" id="config-status" aria-live="polite"></span>
+      <div class="card-actions">
+        <button class="btn" id="config-revert">Revert</button>
+        <button class="btn btn-primary" id="config-save">Save all settings</button>
+      </div>
+    </div>
+    <div class="grid config-grid" id="config-grid" role="tabpanel"
+         aria-labelledby="config-section-title">
+      <div class="card" id="config-hotkeys" data-config-section="essentials">
         <h2>Hotkeys</h2>
         <p class="muted small">Modifiers then ONE key: <kbd>^</kbd> Ctrl <kbd>+</kbd> Shift <kbd>!</kbd> Alt <kbd>#</kbd> Win. Good: ^+g · ^!n · ^+1</p>
         <div class="form-row"><label for="hk-in-grammar">Grammar / Prompt</label><input type="text" id="hk-in-grammar" class="mono"></div>
@@ -382,7 +421,8 @@ <h2>Hotkeys</h2>
         <div class="form-row"><label for="hk-in-ask">Ask in Chat</label><input type="text" id="hk-in-ask" class="mono"></div>
         <p class="muted small">Saving applies to the running app within a second (no restart).</p>
       </div>
-      <div class="card card-wide" id="config-notes">
+      <div class="card card-wide" id="config-notes"
+           data-config-section="notes" hidden>
         <h2>Notes &amp; capture</h2>
         <p class="muted small">Storage, organization, and optional local-model enrichment for the Notes workspace.</p>
         <h3 class="subhead">Storage</h3>
@@ -413,7 +453,7 @@ <h3 class="subhead">Link extraction &amp; enrichment</h3>
         <label class="check-row"><input type="checkbox" id="notes-gen-title"> Suggest titles with the local model</label>
         <label class="check-row"><input type="checkbox" id="notes-gen-summary"> Generate summaries with the local model</label>
       </div>
-      <div class="card">
+      <div class="card" id="config-provider" data-config-section="models" hidden>
         <h2>LLM provider &amp; server</h2>
         <div class="form-row">
           <label for="cfg-provider">Provider</label>
@@ -439,8 +479,8 @@ <h2>LLM provider &amp; server</h2>
         </div>
         <p class="muted small" id="warm-model-note">FastFlowLM-only; warmups run in the background.</p>
       </div>
-      <div class="card">
-        <h2 id="models-title">Models</h2>
+      <div class="card" id="config-models" data-config-section="models" hidden>
+        <h2><span id="models-title">Models</span></h2>
         <p class="model-alert" id="model-alert" hidden></p>
 
         <h3 class="subhead">Installed</h3>
@@ -474,7 +514,7 @@ <h3 class="subhead">FastFlowLM runtime</h3>
           </div>
         </div>
       </div>
-      <div class="card">
+      <div class="card" id="config-preferences" data-config-section="essentials">
         <h2>Performance &amp; history</h2>
         <div class="radio-row" id="perf-block">
           <label><input type="radio" name="perf" value="balanced"> 🟡 Balanced</label>
@@ -492,7 +532,8 @@ <h2>Tone preset <span class="muted small">(tone: prefix)</span></h2>
           <label><input type="radio" name="tone" value="friendly"> 🤝 Friendly</label>
         </div>
       </div>
-      <div class="card">
+      <div class="card" id="config-prompt-builder"
+           data-config-section="prompts" hidden>
         <h2>Prompt builder</h2>
         <p class="muted small">Controls the <code>prompt:</code> output shape without editing the locked built-in system prompt. Custom modes remain the fully custom escape hatch.</p>
         <div class="form-row">
@@ -549,7 +590,8 @@ <h2>Prompt builder</h2>
         </div>
         <pre class="note-body" id="pb-preview" hidden></pre>
       </div>
-      <div class="card">
+      <div class="card" id="config-custom-modes"
+           data-config-section="prompts" hidden>
         <h2>Custom modes</h2>
         <p class="muted small">Your own <code>prefix:</code> commands for the grammar hotkey — the mode id is the prefix (e.g. id <code>translate</code> → select text, prefix with <code>translate:</code>). Built-in modes aren't editable here.</p>
         <div class="form-row"><label for="cm-select">Mode</label><select id="cm-select"></select></div>
@@ -562,14 +604,16 @@ <h2>Custom modes</h2>
           <span class="muted" id="cm-status"></span>
         </div>
       </div>
-      <div class="card">
+      <div class="card" id="config-routing"
+           data-config-section="advanced" hidden>
         <h2>Routing</h2>
         <label class="check-row"><input type="checkbox" id="cfg-routing"> Enable chunking for long inputs</label>
         <div class="form-row"><label for="cfg-long-thr">Long threshold</label><input type="number" id="cfg-long-thr" min="200" max="5000"></div>
         <div class="form-row"><label for="cfg-chunk-size">Chunk size</label><input type="number" id="cfg-chunk-size" min="200" max="4000"></div>
         <div class="form-row"><label for="cfg-min-chunk">Min chunk</label><input type="number" id="cfg-min-chunk" min="100" max="2000"></div>
       </div>
-      <div class="card card-wide">
+      <div class="card card-wide" id="config-notifications"
+           data-config-section="notifications" hidden>
         <h2>Notifications</h2>
         <p class="muted small">Choose which desktop toasts appear, mute duplicates, and set quiet hours. Errors &amp; warnings always come through while Do&nbsp;Not&nbsp;Disturb or quiet hours are on. Every notification — shown or muted — is recorded in the Telemetry tab's feed.</p>
         <label class="check-row"><input type="checkbox" id="ntf-enabled"> Show desktop notifications <span class="muted small">— master switch; off mutes everything</span></label>
@@ -592,7 +636,8 @@ <h2>Per-event</h2>
         <label class="check-row"><input type="checkbox" id="ntf-cat-lifecycle"> App lifecycle <span class="muted small">— app ready, config reloaded</span></label>
         <label class="check-row"><input type="checkbox" id="ntf-cat-errors"> Errors &amp; warnings <span class="muted small">— always shown when DND / quiet hours are on</span></label>
       </div>
-      <div class="card card-wide">
+      <div class="card card-wide" id="config-meetings"
+           data-config-section="meetings" hidden>
         <h2>Meetings &amp; after-hours processing <span class="muted small" id="mtg-cfg-status"></span></h2>
         <p class="muted small">Connect the local <strong>Quill</strong> note app over MCP to search meetings and ask about them. During the idle window below, Flowkey pre-computes each meeting's summary + action items on the local model so daytime reads are instant (a full transcript costs ~15&nbsp;s of prefill — paid once, after hours).</p>
         <label class="check-row"><input type="checkbox" id="mtg-enabled"> Enable Quill integration</label>
@@ -621,11 +666,6 @@ <h2>After-hours batch</h2>
           <span class="muted small" id="mtg-run-status"></span>
         </div>
       </div>
-      <div class="card-actions card-wide">
-        <button class="btn btn-primary" id="config-save">Save all settings</button>
-        <button class="btn" id="config-revert">Revert</button>
-        <span class="muted" id="config-status"></span>
-      </div>
     </div>
   </section>
 
diff --git a/scripts/ui/web/styles.css b/scripts/ui/web/styles.css
index 6007d79..73054c3 100644
--- a/scripts/ui/web/styles.css
+++ b/scripts/ui/web/styles.css
@@ -293,6 +293,140 @@ main { padding: 18px 24px 24px; }
   margin: 0 0 12px;
 }
 
+/* ---- Config workspace ---------------------------------------------------- */
+.config-head {
+  display: grid;
+  grid-template-columns: minmax(210px, 0.42fr) minmax(0, 1.58fr);
+  align-items: end;
+  gap: 22px;
+  margin-bottom: 14px;
+}
+.config-head h2 {
+  margin: 0;
+  color: var(--text);
+  font-size: clamp(22px, 3vw, 30px);
+  letter-spacing: -0.035em;
+}
+.config-head p:last-child { margin: 2px 0 0; }
+.config-sections {
+  display: flex;
+  justify-content: flex-end;
+  gap: 4px;
+  max-width: 100%;
+  padding: 4px;
+  overflow-x: auto;
+  border: 1px solid var(--border);
+  border-radius: 13px;
+  background: var(--surface-glass);
+  box-shadow: var(--shadow);
+  scrollbar-width: thin;
+}
+.config-section-tab {
+  flex: 0 0 auto;
+  padding: 7px 11px;
+  border: 0;
+  border-radius: 9px;
+  background: transparent;
+  color: var(--text-muted);
+  font: inherit;
+  font-size: 12px;
+  font-weight: 650;
+  white-space: nowrap;
+  cursor: pointer;
+}
+.config-section-tab:hover {
+  background: var(--kbd-bg);
+  color: var(--text);
+}
+.config-section-tab.active {
+  background: var(--accent-soft);
+  color: var(--accent);
+  box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--accent) 24%, transparent);
+}
+.config-grid {
+  align-items: start;
+  min-height: min(460px, 55vh);
+}
+.config-card {
+  animation: config-card-in 0.18s ease-out;
+}
+.config-card:hover { transform: none; }
+@keyframes config-card-in {
+  from { opacity: 0; transform: translateY(4px); }
+  to { opacity: 1; transform: none; }
+}
+.config-card > .config-card-heading {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  margin-bottom: 12px;
+}
+.config-card-toggle {
+  display: grid;
+  flex: 0 0 28px;
+  width: 28px;
+  height: 28px;
+  margin: -6px -7px -6px auto;
+  padding: 0;
+  place-items: center;
+  border: 0;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--text-muted);
+  font: 700 20px/1 "Segoe UI Symbol", "Segoe UI", sans-serif;
+  cursor: pointer;
+}
+.config-card-toggle:hover,
+.config-card-toggle:focus-visible {
+  background: var(--accent-soft);
+  color: var(--accent);
+}
+.config-card.is-collapsed {
+  padding-block: 14px;
+}
+.config-card.is-collapsed > :not(.config-card-heading) {
+  display: none !important;
+}
+.config-card.is-collapsed > .config-card-heading { margin-bottom: 0; }
+.config-save-bar {
+  position: sticky;
+  z-index: 8;
+  top: 70px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  min-height: 58px;
+  margin: 0 0 16px;
+  padding: 10px 12px 10px 16px;
+  border: 1px solid var(--border-strong);
+  border-radius: 14px;
+  background: var(--surface-glass);
+  box-shadow: var(--shadow-lift);
+  backdrop-filter: blur(14px) saturate(1.25);
+  -webkit-backdrop-filter: blur(14px) saturate(1.25);
+}
+.config-save-bar .card-actions {
+  flex: 0 0 auto;
+  margin-top: 0;
+}
+@media (max-width: 960px) {
+  .config-head { grid-template-columns: 1fr; gap: 10px; }
+  .config-sections { justify-content: flex-start; }
+}
+@media (max-width: 720px) {
+  .config-grid {
+    grid-template-columns: 1fr;
+    min-height: 380px;
+  }
+  .config-save-bar {
+    top: 104px;
+    align-items: stretch;
+    flex-direction: column;
+  }
+  .config-save-bar .card-actions { justify-content: flex-end; }
+}
+
 dl {
   display: grid;
   grid-template-columns: 110px 1fr;
diff --git a/tests/test_config_workspace_ui.py b/tests/test_config_workspace_ui.py
new file mode 100644
index 0000000..c479f92
--- /dev/null
+++ b/tests/test_config_workspace_ui.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+WEB = ROOT / "scripts" / "ui" / "web"
+
+
+def test_config_is_sectioned_instead_of_one_long_grid():
+    html = (WEB / "index.html").read_text(encoding="utf-8")
+    config = html.split('id="tab-config"', 1)[1].split(
+        'id="tab-benchmark"',
+        1,
+    )[0]
+
+    assert 'id="config-sections"' in config
+    assert 'role="tablist"' in config
+    assert 'id="config-grid"' in config
+    for section in (
+        "essentials",
+        "models",
+        "notes",
+        "prompts",
+        "notifications",
+        "meetings",
+        "advanced",
+    ):
+        assert f'data-config-section="{section}"' in config
+    assert 'id="config-save"' in config
+    assert 'id="config-revert"' in config
+    assert 'class="config-save-bar"' in config
+
+
+def test_config_sections_and_collapsed_cards_persist_locally():
+    app = (WEB / "app.js").read_text(encoding="utf-8")
+
+    assert 'const CONFIG_SECTION_KEY = "flowkey.config.section.v1"' in app
+    assert 'const CONFIG_COLLAPSED_KEY = "flowkey.config.collapsed.v1"' in app
+    assert "function setConfigSection(section, focus = false)" in app
+    assert "function setConfigCardCollapsed(card, collapsed)" in app
+    assert 'event.key === "ArrowRight"' in app
+    assert 'event.key === "ArrowLeft"' in app
+    assert 'button.setAttribute("aria-expanded", String(!collapsed))' in app
+    assert "localStorage.setItem(CONFIG_SECTION_KEY, selected)" in app
+    assert ".innerHTML" not in app
+
+
+def test_config_workspace_is_sticky_and_responsive():
+    css = (WEB / "styles.css").read_text(encoding="utf-8")
+
+    assert ".config-save-bar {" in css
+    assert "position: sticky;" in css
+    assert ".config-card.is-collapsed > :not(.config-card-heading)" in css
+    assert "@media (max-width: 720px)" in css
+    assert ".config-sections" in css

From 908d497d0e2825258717ff2b7ba5f12725d3c073 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Thu, 30 Jul 2026 04:04:43 -0400
Subject: [PATCH 10/12] B43: isolate Notes daemon tests from real vault

---
 SPEC.md                            | 1 +
 tests/test_notes_daemon_actions.py | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/SPEC.md b/SPEC.md
index 7880833..e996c5b 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -214,4 +214,5 @@ B37|2026-07-27|FLM returns HTTP **200** + `{"error":"Failed to load <model> mode
 B34|2026-07-27|self-caught: `_active_model_health` tested membership vs `_provider_list("all")`; ollama "all" = installed+suggested (`ffp_provider_runtime:80`) ∴ never-pulled model → false `installed=True` (⊥ warn)|V39; trust `details` (unfiltered, authoritative) else re-list w/ `installed` filter
 B41|2026-07-29|Notes due `2026-08-04` parsed as UTC midnight → EDT displayed Aug 3|V56; parse date-only @ local noon
 B42|2026-07-29|Quill `get_transcript` sent `id`; live schema requires `meeting_id`+`include_private_notes`; `call_tool` ignored `isError` ∴ 133-char validation error fed to LLM + cached as digest|V57
+B43|2026-07-29|`fresh_modules` teardown popped `notes` after test collection; later daemon-action tests patched a stale module while action-local `import notes` resolved a new module ∴ tests touched the real vault + became order-dependent|rebind `sys.modules["notes"]` to the isolated test module; V20 full-suite gate
 ```
diff --git a/tests/test_notes_daemon_actions.py b/tests/test_notes_daemon_actions.py
index 15f3a15..a9e39ef 100644
--- a/tests/test_notes_daemon_actions.py
+++ b/tests/test_notes_daemon_actions.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import sys
+
 import ffp_daemon
 import notes
 import pytest
@@ -7,6 +9,10 @@
 
 @pytest.fixture
 def vault(tmp_path, monkeypatch):
+    # `fresh_modules` tests intentionally pop/reimport modules. Pytest imports
+    # this file during collection, so keep action-local `import notes` calls
+    # bound to the same isolated module object this fixture patches.
+    monkeypatch.setitem(sys.modules, "notes", notes)
     monkeypatch.setattr(notes, "_vault_dir", lambda: tmp_path / "vault")
     notes._invalidate_index()
     return tmp_path / "vault"

From 1a032fd24558fa39d6d315099137096d91e9527a Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Thu, 30 Jul 2026 08:05:29 -0400
Subject: [PATCH 11/12] T38: sort note categories in config snapshots

---
 scripts/grammar_fix.py   | 9 ++++++++-
 tests/test_ffp_daemon.py | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/scripts/grammar_fix.py b/scripts/grammar_fix.py
index fdc8048..1392344 100644
--- a/scripts/grammar_fix.py
+++ b/scripts/grammar_fix.py
@@ -925,7 +925,14 @@ def build_config_snapshot() -> dict:
         ).to_dict(),
         "notes": {
             "vault_dir": str(notes_cfg.get("vault_dir") or r"%USERPROFILE%\Documents\FastFlowPrompt Notes"),
-            "categories": list(notes_cfg.get("categories") or []),
+            "categories": sorted(
+                {
+                    str(category).strip().replace("\\", "/").strip("/")
+                    for category in (notes_cfg.get("categories") or [])
+                    if str(category).strip()
+                },
+                key=str.casefold,
+            ),
             "fetch_timeout_seconds": int(notes_cfg.get("fetch_timeout_seconds") or 8),
             "max_extracted_chars": int(notes_cfg.get("max_extracted_chars") or 2000),
             "low_confidence_to_inbox": bool(notes_cfg.get("low_confidence_to_inbox", True)),
diff --git a/tests/test_ffp_daemon.py b/tests/test_ffp_daemon.py
index 1051c1e..1052015 100644
--- a/tests/test_ffp_daemon.py
+++ b/tests/test_ffp_daemon.py
@@ -624,6 +624,7 @@ def test_post_config_snapshot_returns_flat_dashboard_fields(daemon_server):
     }
     notes = payload["result"]["notes"]
     assert isinstance(notes.get("categories"), list)
+    assert notes["categories"] == sorted(notes["categories"], key=str.casefold)
     assert notes["allow_new_categories"] is True
     assert payload["result"]["server"]["warm_on_start"] is True
     assert payload["result"]["server"]["keep_warm_minutes"] == 15

From 53dbdecd6c0f0c4cf481c82efc15267d2a59f2f6 Mon Sep 17 00:00:00 2001
From: agrechenkov <arseniy.grechenkov@cyclelabs.io>
Date: Thu, 13 Aug 2026 11:27:27 -0400
Subject: [PATCH 12/12] B44-B46: pre-release fixes for Notes v2 and Quill error
 handling

- Serialize note schema migration writes under _NOTES_LOCK and fall back to
  an unmigrated read instead of silently dropping a note when the migration
  write fails (V61).
- Restore ffp_quill's documented fail-soft contract: get_minutes/
  get_transcript/search_meetings/list_recent_meetings catch QuillToolError
  instead of letting it propagate, which was silently no-oping scheduled
  meeting batches and breaking the permanent-skip path for dead meetings
  (V62).
- Add the missing optimistic-concurrency revision check to trash_note, and
  guard the two remaining bare int() revision parses in the daemon.

Found via code-review skill pass across 8 angles before shipping 2.5.0.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 CHANGELOG.md                  |   3 +
 SPEC.md                       |   5 ++
 scripts/ffp_daemon.py         |  17 ++++-
 scripts/ffp_quill.py          |  32 ++++++--
 scripts/notes.py              | 135 ++++++++++++++++++++++------------
 scripts/ui/web/app.js         |   5 +-
 tests/test_ffp_quill.py       |  26 +++++++
 tests/test_notes_workspace.py |  27 +++++++
 8 files changed, 191 insertions(+), 59 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 489240c..13d2617 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,9 @@
 ### Fixed
 
 - **Date-only due dates keep their calendar day.** A value such as `2026-08-04` displays as August 4 in every timezone instead of shifting to the prior day west of UTC.
+- **Note migration no longer races concurrent edits or vanishes notes.** Upgrading a pre-2.5 note to the new schema is now serialized against other note writes, and a note whose file can't be rewritten (e.g. a read-only location) still appears in search and listings instead of silently disappearing.
+- **"Move to Trash" respects the same conflict check as every other note action.** If a note changed since you opened it, trashing it now reports the conflict instead of acting on stale data.
+- **A Quill hiccup no longer breaks Meetings.** A transient error from Quill during a scheduled digest run, the Overview widget, or a meeting Q&A now degrades gracefully instead of surfacing as an error or silently skipping a whole batch.
 
 ## 2.4.3
 
diff --git a/SPEC.md b/SPEC.md
index e996c5b..69b9d27 100644
--- a/SPEC.md
+++ b/SPEC.md
@@ -121,6 +121,8 @@ Caveman-encoded (compression, not amputation). Paths / ids / action names / numb
 - V58: model-created note category accepted ⟺ config opt-in ∧ `is_new` ∧ high confidence ∧ safe normalized ≤2-segment slug; accepted category atomically deduped+sorted into cfg; otherwise Inbox + suggestion; V49 holds
 - V59: Config → keyboard-accessible section nav + collapsible groups + one selected section visible + sticky Save/Revert; view state local-only persisted; ≤720px responsive
 - V60: future Activity workspace may join Telemetry+History + explicit `Save as note`; Notes remains authored knowledge; V6,V25,V26 hold
+- V61: note schema-migration write ∈ `_NOTES_LOCK` (double-checked, serialized vs concurrent note writes); migration-write failure → index/lookup fall back to unmigrated read, ⊥ silently drop note
+- V62: `ffp_quill` public read fns (`get_minutes`,`get_transcript`,`search_meetings`,`list_recent_meetings`) catch `QuillToolError` → soft-degrade (empty text/list); V57's typed-failure raise stays internal to `call_tool`, ⊥ leaks past the public API
 
 ## §T tasks
 
@@ -215,4 +217,7 @@ B34|2026-07-27|self-caught: `_active_model_health` tested membership vs `_provid
 B41|2026-07-29|Notes due `2026-08-04` parsed as UTC midnight → EDT displayed Aug 3|V56; parse date-only @ local noon
 B42|2026-07-29|Quill `get_transcript` sent `id`; live schema requires `meeting_id`+`include_private_notes`; `call_tool` ignored `isError` ∴ 133-char validation error fed to LLM + cached as digest|V57
 B43|2026-07-29|`fresh_modules` teardown popped `notes` after test collection; later daemon-action tests patched a stale module while action-local `import notes` resolved a new module ∴ tests touched the real vault + became order-dependent|rebind `sys.modules["notes"]` to the isolated test module; V20 full-suite gate
+B44|2026-08-13|pre-release review: V57's `call_tool` raise (the B42 fix) went ⊥ caught by `get_minutes`/`get_transcript`/`search_meetings`/`list_recent_meetings`; `run_batch`'s pagination loop, `meeting_overview`, and `process_meeting`'s `NoContentError` skip-path all broke on any Quill tool error: scheduled batch could silently no-op (status never updated), Overview widget 500'd instead of `reachable=False`, dead meetings retried forever instead of perma-skip|V62; catch `QuillToolError` in the 4 public read fns, restore module's documented fail-soft contract
+B45|2026-08-13|pre-release review: `_ensure_note_schema`'s migration write ran outside `_NOTES_LOCK` ∴ could race a locked `note_update`/`note_organize` on the same file (dueling `uuid4()` note_id, last-writer-wins corruption); `_load_note_index`/`_find_note_path` silently dropped a note from every listing/lookup on migration-write failure (e.g. read-only file)|V61; lock + double-check inside `_ensure_note_schema`; index/lookup fall back to unmigrated read on failure instead of dropping the note
+B46|2026-08-13|pre-release review: `trash_note` was the only note-mutating fn ⊥ taking a `revision` param ∴ "Move to Trash" could silently act on a note that changed since the editor loaded it, unlike update/organize/archive; also `_act_note_archive`/`_act_notes_board_save` used a bare `int()` revision parse (raw 500 on bad input) unlike `_act_note_update`/`_act_note_organize`'s guarded parse|V54; add revision param + conflict check to `trash_note` + daemon action + app.js call site; guard the two bare `int()` parses to match the others
 ```
diff --git a/scripts/ffp_daemon.py b/scripts/ffp_daemon.py
index 788178f..5f4d25e 100644
--- a/scripts/ffp_daemon.py
+++ b/scripts/ffp_daemon.py
@@ -718,13 +718,21 @@ def _act_note_organize(args: dict) -> dict:
 def _act_note_archive(args: dict) -> dict:
     import notes
     raw_revision = args.get("revision")
-    revision = int(raw_revision) if raw_revision is not None else None
+    try:
+        revision = int(raw_revision) if raw_revision is not None else None
+    except (TypeError, ValueError):
+        raise ValueError("revision must be an integer") from None
     return notes.archive_note(str(args.get("note_id") or ""), revision)
 
 
 def _act_note_trash(args: dict) -> dict:
     import notes
-    return notes.trash_note(str(args.get("note_id") or ""))
+    raw_revision = args.get("revision")
+    try:
+        revision = int(raw_revision) if raw_revision is not None else None
+    except (TypeError, ValueError):
+        raise ValueError("revision must be an integer") from None
+    return notes.trash_note(str(args.get("note_id") or ""), revision)
 
 
 def _act_note_restore(args: dict) -> dict:
@@ -760,7 +768,10 @@ def _act_notes_board_get(_args: dict) -> dict:
 def _act_notes_board_save(args: dict) -> dict:
     import notes
     raw_revision = args.get("revision")
-    revision = int(raw_revision) if raw_revision is not None else None
+    try:
+        revision = int(raw_revision) if raw_revision is not None else None
+    except (TypeError, ValueError):
+        raise ValueError("revision must be an integer") from None
     return notes.save_board(
         args.get("board") if isinstance(args.get("board"), dict) else {},
         revision,
diff --git a/scripts/ffp_quill.py b/scripts/ffp_quill.py
index ef7fdd2..c8b0e87 100644
--- a/scripts/ffp_quill.py
+++ b/scripts/ffp_quill.py
@@ -203,7 +203,11 @@ def search_meetings(query: str, limit: int = 10, offset: int = 0, *, url: str =
         args["query"] = str(query)
     if offset:
         args["offset"] = int(offset)
-    text = c.call_tool("search_meetings", args)
+    try:
+        text = c.call_tool("search_meetings", args)
+    except QuillToolError as exc:
+        log.warning("Quill search_meetings failed: %s", exc)
+        text = ""
     return {"meetings": _parse_meetings(text), "reachable": bool(c.session_id)}
 
 
@@ -212,12 +216,21 @@ def list_recent_meetings(limit: int = 30, offset: int = 0, *, url: str = DEFAULT
     args: dict = {"limit": max(1, min(int(limit or 30), 30))}
     if offset:
         args["offset"] = int(offset)
-    return _parse_meetings(c.call_tool("search_meetings", args))
+    try:
+        text = c.call_tool("search_meetings", args)
+    except QuillToolError as exc:
+        log.warning("Quill search_meetings failed: %s", exc)
+        text = ""
+    return _parse_meetings(text)
 
 
 def get_minutes(meeting_id: str, *, url: str = DEFAULT_MCP_URL, client: QuillClient | None = None) -> str:
     c = client or QuillClient(url)
-    text = c.call_tool("get_minutes", {"meeting_id": meeting_id})
+    try:
+        text = c.call_tool("get_minutes", {"meeting_id": meeting_id})
+    except QuillToolError as exc:
+        log.warning("Quill get_minutes failed: %s", exc)
+        return ""
     if not text or "No minutes found" in text:
         return ""
     return clean_text(text)
@@ -225,7 +238,12 @@ def get_minutes(meeting_id: str, *, url: str = DEFAULT_MCP_URL, client: QuillCli
 
 def get_transcript(meeting_id: str, *, url: str = DEFAULT_MCP_URL, client: QuillClient | None = None) -> str:
     c = client or QuillClient(url)
-    return clean_text(c.call_tool(
-        "get_transcript",
-        {"meeting_id": meeting_id, "include_private_notes": True},
-    ))
+    try:
+        text = c.call_tool(
+            "get_transcript",
+            {"meeting_id": meeting_id, "include_private_notes": True},
+        )
+    except QuillToolError as exc:
+        log.warning("Quill get_transcript failed: %s", exc)
+        return ""
+    return clean_text(text)
diff --git a/scripts/notes.py b/scripts/notes.py
index 117f4b1..e1438db 100644
--- a/scripts/notes.py
+++ b/scripts/notes.py
@@ -668,48 +668,63 @@ def _ensure_note_schema(path: Path) -> tuple[dict, str, str]:
     if schema >= SCHEMA_VERSION and note_id:
         return metadata, body, text
 
-    stat = path.stat()
-    created = str(metadata.get("created") or time.strftime(
-        "%Y-%m-%dT%H:%M:%S", time.localtime(stat.st_mtime)
-    ))
-    source = str(metadata.get("source") or "")
-    kind = str(metadata.get("kind") or ("link" if source else "note"))
-    if kind not in NOTE_KINDS:
-        kind = "note"
-    status = str(metadata.get("status") or (
-        "trashed" if TRASH_DIR in path.parts else "active"
-    ))
-    if status not in NOTE_STATUSES:
-        status = "active"
-    try:
-        revision = max(1, int(metadata.get("revision") or 1))
-    except (TypeError, ValueError):
-        revision = 1
-    updates = {
-        "schema_version": SCHEMA_VERSION,
-        "note_id": note_id or uuid.uuid4().hex,
-        "kind": kind,
-        "status": status,
-        "tags": metadata.get("tags") if isinstance(metadata.get("tags"), list) else [],
-        "color": (
-            metadata.get("color")
-            if metadata.get("color") in NOTE_COLORS
-            else DEFAULT_COLOR
-        ),
-        "pinned": bool(metadata.get("pinned", False)),
-        "due": str(metadata.get("due") or ""),
-        "created": created,
-        "updated": str(metadata.get("updated") or created),
-        "revision": revision,
-        "category": _note_category(path, metadata),
-    }
-    _backup_before_migration(path)
-    migrated = _merge_frontmatter(text, updates)
-    _atomic_write_text(path, migrated)
-    merged = dict(metadata)
-    merged.update(updates)
-    _invalidate_index()
-    return merged, body, migrated
+    with _NOTES_LOCK:
+        # Re-read under the lock: this is a write (migration), so it must be
+        # serialized against every other note write, not just other readers.
+        # Re-check the "already migrated" condition too, in case another
+        # thread migrated this exact file while we were waiting for the lock.
+        text = path.read_text(encoding="utf-8", errors="replace")
+        metadata, body, _lines = _note_parts(text)
+        try:
+            schema = int(metadata.get("schema_version") or 0)
+        except (TypeError, ValueError):
+            schema = 0
+        note_id = str(metadata.get("note_id") or "").strip()
+        if schema >= SCHEMA_VERSION and note_id:
+            return metadata, body, text
+
+        stat = path.stat()
+        created = str(metadata.get("created") or time.strftime(
+            "%Y-%m-%dT%H:%M:%S", time.localtime(stat.st_mtime)
+        ))
+        source = str(metadata.get("source") or "")
+        kind = str(metadata.get("kind") or ("link" if source else "note"))
+        if kind not in NOTE_KINDS:
+            kind = "note"
+        status = str(metadata.get("status") or (
+            "trashed" if TRASH_DIR in path.parts else "active"
+        ))
+        if status not in NOTE_STATUSES:
+            status = "active"
+        try:
+            revision = max(1, int(metadata.get("revision") or 1))
+        except (TypeError, ValueError):
+            revision = 1
+        updates = {
+            "schema_version": SCHEMA_VERSION,
+            "note_id": note_id or uuid.uuid4().hex,
+            "kind": kind,
+            "status": status,
+            "tags": metadata.get("tags") if isinstance(metadata.get("tags"), list) else [],
+            "color": (
+                metadata.get("color")
+                if metadata.get("color") in NOTE_COLORS
+                else DEFAULT_COLOR
+            ),
+            "pinned": bool(metadata.get("pinned", False)),
+            "due": str(metadata.get("due") or ""),
+            "created": created,
+            "updated": str(metadata.get("updated") or created),
+            "revision": revision,
+            "category": _note_category(path, metadata),
+        }
+        _backup_before_migration(path)
+        migrated = _merge_frontmatter(text, updates)
+        _atomic_write_text(path, migrated)
+        merged = dict(metadata)
+        merged.update(updates)
+        _invalidate_index()
+        return merged, body, migrated
 
 
 def _iter_note_paths(include_trash: bool = False) -> list[Path]:
@@ -801,9 +816,15 @@ def _load_note_index(include_trash: bool = False) -> list[dict]:
     for path in paths:
         try:
             metadata, body, _text = _ensure_note_schema(path)
-            records.append(_note_record(path, metadata, body))
         except (OSError, ValueError):
-            log.exception("could not index note %s", path)
+            log.exception("could not migrate note %s; indexing it unmigrated", path)
+            try:
+                text = path.read_text(encoding="utf-8", errors="replace")
+                metadata, body, _lines = _note_parts(text)
+            except OSError:
+                log.exception("could not read note %s", path)
+                continue
+        records.append(_note_record(path, metadata, body))
     final_signature = _index_signature(paths)
     _INDEX_CACHE[cache_key] = (final_signature, [dict(item) for item in records])
     return records
@@ -823,7 +844,12 @@ def _find_note_path(identifier: str, include_trash: bool = True) -> Path | None:
             try:
                 metadata, _body, _text = _ensure_note_schema(path)
             except OSError:
-                continue
+                log.exception("could not migrate note %s; matching it unmigrated", path)
+                try:
+                    text = path.read_text(encoding="utf-8", errors="replace")
+                    metadata, _body, _lines = _note_parts(text)
+                except OSError:
+                    continue
             if str(metadata.get("note_id") or "") == raw:
                 return path
     return None
@@ -1023,7 +1049,12 @@ def get_note(relpath: str) -> dict:
     target = _find_note_path(relpath, include_trash=True)
     if target is None:
         return {"ok": False, "error": "note not found"}
-    metadata, body, _text = _ensure_note_schema(target)
+    try:
+        metadata, body, _text = _ensure_note_schema(target)
+    except (OSError, ValueError):
+        log.exception("could not migrate note %s; reading it unmigrated", target)
+        text = target.read_text(encoding="utf-8", errors="replace")
+        metadata, body, _lines = _note_parts(text)
     return _note_record(target, metadata, body, include_body=True)
 
 
@@ -1232,14 +1263,22 @@ def archive_note(note_id: str, revision: int | None = None) -> dict:
     return update_note(note_id, revision, {"status": "archived"})
 
 
-def trash_note(note_id: str) -> dict:
+def trash_note(note_id: str, revision: int | None = None) -> dict:
     """Move a note into the recoverable vault-local Trash."""
     with _NOTES_LOCK:
         source = _find_note_path(note_id, include_trash=False)
         if source is None:
             return {"ok": False, "error": "note not found"}
         metadata, body, text = _ensure_note_schema(source)
-        revision = int(metadata.get("revision") or 1)
+        current_revision = int(metadata.get("revision") or 1)
+        if revision is not None and int(revision) != current_revision:
+            return {
+                "ok": False,
+                "error": "note changed since it was opened",
+                "conflict": True,
+                "note": _note_record(source, metadata, body, include_body=True),
+            }
+        revision = current_revision
         relpath = str(source.relative_to(_vault_dir())).replace("\\", "/")
         updates = {
             "status": "trashed",
diff --git a/scripts/ui/web/app.js b/scripts/ui/web/app.js
index 98df169..f277b33 100644
--- a/scripts/ui/web/app.js
+++ b/scripts/ui/web/app.js
@@ -1265,7 +1265,10 @@ async function trashCurrentNote() {
   if (!(await confirmDialog("Move this note to Trash? You can restore it later.", "Move to Trash"))) return;
   try {
     const noteId = notesState.current.note_id;
-    const result = await action("note_trash", { note_id: noteId });
+    const result = await action("note_trash", {
+      note_id: noteId,
+      revision: notesState.current.revision,
+    });
     if (!result.ok) {
       setEditorStatus(result.error || "Move to Trash failed.", false);
       return;
diff --git a/tests/test_ffp_quill.py b/tests/test_ffp_quill.py
index f8ad88e..b996613 100644
--- a/tests/test_ffp_quill.py
+++ b/tests/test_ffp_quill.py
@@ -112,3 +112,29 @@ def call_tool(self, name, arguments):
         "get_transcript",
         {"meeting_id": "meeting-1", "include_private_notes": True},
     )
+
+
+class _RaisingClient:
+    """call_tool always raises, like a real Quill tool-level error (V57)."""
+
+    session_id = "test"
+
+    def call_tool(self, name, arguments):
+        raise ffp_quill.QuillToolError(name, "boom")
+
+
+def test_get_minutes_degrades_on_quill_tool_error():
+    assert ffp_quill.get_minutes("meeting-1", client=_RaisingClient()) == ""
+
+
+def test_get_transcript_degrades_on_quill_tool_error():
+    assert ffp_quill.get_transcript("meeting-1", client=_RaisingClient()) == ""
+
+
+def test_search_meetings_degrades_on_quill_tool_error():
+    result = ffp_quill.search_meetings("q", client=_RaisingClient())
+    assert result == {"meetings": [], "reachable": True}
+
+
+def test_list_recent_meetings_degrades_on_quill_tool_error():
+    assert ffp_quill.list_recent_meetings(client=_RaisingClient()) == []
diff --git a/tests/test_notes_workspace.py b/tests/test_notes_workspace.py
index e66d48e..c87cbc7 100644
--- a/tests/test_notes_workspace.py
+++ b/tests/test_notes_workspace.py
@@ -43,6 +43,22 @@ def test_v51_migration_preserves_body_unknown_metadata_and_backup(vault):
     assert "schema_version" not in backup.read_text(encoding="utf-8")
 
 
+def test_v61_migration_write_failure_keeps_note_visible(vault, monkeypatch):
+    _legacy_note(vault)
+
+    def _boom(path, text):
+        raise OSError("read-only mount")
+
+    monkeypatch.setattr(notes, "_atomic_write_text", _boom)
+
+    listed = notes.query_notes()
+    found = notes.get_note("inbox/legacy.md")
+
+    assert any(r["relpath"] == "inbox/legacy.md" for r in listed["results"])
+    assert found["ok"] is True
+    assert found["body"] == "Original body\n"
+
+
 def test_v48_stable_note_id_survives_category_move(vault):
     _legacy_note(vault)
     before = notes.get_note("inbox/legacy.md")
@@ -76,6 +92,17 @@ def test_v54_create_update_and_stale_revision_conflict(vault):
     assert not list(vault.rglob("*.tmp"))
 
 
+def test_v54_trash_rejects_stale_revision(vault):
+    created = notes.create_note(title="Recover me", body="x", category="ideas")
+    notes.update_note(created["note_id"], created["revision"], {"pinned": True})
+
+    conflict = notes.trash_note(created["note_id"], created["revision"])
+    trashed = notes.trash_note(created["note_id"], conflict["note"]["revision"])
+
+    assert conflict["conflict"] is True
+    assert trashed["status"] == "trashed"
+
+
 def test_v50_trash_restore_and_explicit_permanent_delete(vault):
     created = notes.create_note(title="Recover me", body="x", category="ideas")