diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index f5c8353c..75703951 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/desktop",
   "productName": "ZenNotes",
-  "version": "2.45.0",
+  "version": "2.46.0",
   "description": "ZenNotes desktop shell",
   "private": true,
   "main": "./out/main/index.js",
diff --git a/apps/desktop/src/cli/backend.ts b/apps/desktop/src/cli/backend.ts
index bf45889c..6bc4ab23 100644
--- a/apps/desktop/src/cli/backend.ts
+++ b/apps/desktop/src/cli/backend.ts
@@ -40,6 +40,7 @@ import {
   prependToNote,
   readDatabaseVaultLayout,
   readNote,
+  readNoteComments,
   readPrimaryNotesLocation,
   readVaultFileTextOrNull,
   renameFolder,
@@ -55,7 +56,10 @@ import {
   toggleTaskInBody,
   unarchiveNote,
   writeNote,
+  writeNoteComments,
   writeVaultFileText,
+  type NoteComment,
+  type NoteCommentInput,
   type NoteContent,
   type NoteFolder,
   type NoteMeta,
@@ -148,6 +152,9 @@ export interface VaultBackend {
   backlinks(rel: string): Promise<NoteMeta[]>
   scanAllTasks(opts?: { includeExcluded?: boolean }): Promise<VaultTask[]>
   toggleTask(taskId: string): Promise<VaultTask | null>
+  /** A note's comments as stored (#738); `writeComments` replaces the list. */
+  listComments(rel: string): Promise<NoteComment[]>
+  writeComments(rel: string, comments: NoteCommentInput[]): Promise<NoteComment[]>
   /** Database (`.base`) operations, composed from this backend's file IO via
    *  @shared/database-ops — the same composition the web and desktop remote
    *  clients use, so `zn base` writes the identical on-disk format. (#556) */
@@ -270,6 +277,9 @@ class LocalBackend implements VaultBackend {
   scanAllTasks = (opts?: { includeExcluded?: boolean }): Promise<VaultTask[]> =>
     scanAllTasks(this.root, opts)
   toggleTask = (taskId: string): Promise<VaultTask | null> => toggleTask(this.root, taskId)
+  listComments = (rel: string): Promise<NoteComment[]> => readNoteComments(this.root, rel)
+  writeComments = (rel: string, comments: NoteCommentInput[]): Promise<NoteComment[]> =>
+    writeNoteComments(this.root, rel, comments)
 
   private dbOps: DatabaseOps | null = null
   databaseOps = (): DatabaseOps => {
@@ -417,6 +427,11 @@ class RemoteBackend implements VaultBackend {
   scanAllTasks = (opts?: { includeExcluded?: boolean }): Promise<VaultTask[]> =>
     this.client.scanTasks(opts)
 
+  listComments = (rel: string): Promise<NoteComment[]> =>
+    this.client.readComments(normalizeRelPath(rel))
+  writeComments = (rel: string, comments: NoteCommentInput[]): Promise<NoteComment[]> =>
+    this.client.writeComments(normalizeRelPath(rel), comments)
+
   /** No task-toggle endpoint exists, so the note is read, the same transform a
    *  local toggle applies is applied here, and the server re-parses the result
    *  — which keeps the Go and TypeScript task parsers honest with each other. */
diff --git a/apps/desktop/src/cli/commands/comments.test.ts b/apps/desktop/src/cli/commands/comments.test.ts
new file mode 100644
index 00000000..908d27df
--- /dev/null
+++ b/apps/desktop/src/cli/commands/comments.test.ts
@@ -0,0 +1,84 @@
+import { promises as fsp } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { createBackend, type VaultBackend } from '../backend'
+import type { ParsedArgs } from '../args'
+import { cmdCommentAdd, cmdCommentList, cmdCommentReply, cmdCommentResolve } from './comments'
+
+// `zn comment` (#738) against a folder vault: the same sidecar the app and
+// the MCP tools read, so a thread started here shows up in the panel.
+
+function args(positionals: string[], flags: Array<[string, string]> = []): ParsedArgs {
+  return { positionals, flags: new Map(flags.map(([k, v]) => [k, [v]])) }
+}
+
+let root: string
+let backend: VaultBackend
+let out: string[]
+
+beforeEach(async () => {
+  root = await fsp.mkdtemp(path.join(os.tmpdir(), 'zen-comment-cli-'))
+  await fsp.mkdir(path.join(root, 'inbox'), { recursive: true })
+  await fsp.writeFile(path.join(root, 'inbox', 'Plan.md'), '# Plan\n\nShip the beta in October.\n')
+  backend = createBackend({ kind: 'local', root })
+  out = []
+  vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
+    out.push(String(chunk))
+    return true
+  })
+})
+
+afterEach(async () => {
+  vi.restoreAllMocks()
+  await fsp.rm(root, { recursive: true, force: true })
+})
+
+describe('zn comment', () => {
+  it('adds, lists, answers and resolves a thread', async () => {
+    await cmdCommentAdd(
+      backend,
+      args(['inbox/Plan.md', 'Still realistic?'], [['anchor', 'Ship the beta in October.']])
+    )
+    expect(out.join('')).toMatch(/Commented on inbox\/Plan\.md \(.+, line 3\)/)
+
+    out = []
+    await cmdCommentList(backend, args(['inbox/Plan.md'], [['json', 'true']]))
+    const threads = JSON.parse(out.join('')) as Array<{ id: string; author: string | null; line: number }>
+    expect(threads).toHaveLength(1)
+    expect(threads[0].author).toBeNull()
+    expect(threads[0].line).toBe(3)
+
+    out = []
+    await cmdCommentReply(
+      backend,
+      args(['inbox/Plan.md', threads[0].id, 'Yes, the blocker runs at night.'], [['author', 'Claude']])
+    )
+    expect(out.join('')).toContain('Replied in')
+
+    out = []
+    await cmdCommentList(backend, args(['inbox/Plan.md']))
+    const text = out.join('')
+    expect(text).toContain('You')
+    expect(text).toContain('> Ship the beta in October.')
+    expect(text).toContain('Claude')
+    expect(text).toContain('Yes, the blocker runs at night.')
+
+    out = []
+    await cmdCommentResolve(backend, args(['inbox/Plan.md', threads[0].id]))
+    expect(out.join('')).toContain('Resolved')
+    out = []
+    await cmdCommentList(backend, args(['inbox/Plan.md']))
+    expect(out.join('')).toContain('No open comments')
+    out = []
+    await cmdCommentList(backend, args(['inbox/Plan.md'], [['all', 'true']]))
+    expect(out.join('')).toContain('(resolved)')
+  })
+
+  it('explains usage when the path or body is missing', async () => {
+    await expect(cmdCommentAdd(backend, args([]))).rejects.toThrow(/Usage: zn comment add/)
+    await expect(cmdCommentAdd(backend, args(['inbox/Plan.md']))).rejects.toThrow(/Usage: zn comment add/)
+    await expect(cmdCommentReply(backend, args(['inbox/Plan.md']))).rejects.toThrow(/Usage: zn comment reply/)
+    await expect(cmdCommentResolve(backend, args(['inbox/Plan.md']))).rejects.toThrow(/Usage: zn comment resolve/)
+  })
+})
diff --git a/apps/desktop/src/cli/commands/comments.ts b/apps/desktop/src/cli/commands/comments.ts
new file mode 100644
index 00000000..5dfef00e
--- /dev/null
+++ b/apps/desktop/src/cli/commands/comments.ts
@@ -0,0 +1,106 @@
+/**
+ * `zn comment ...` (#738): list, add, reply to and resolve the comments on a
+ * note, the same operations the MCP tools expose, so a script or an agent
+ * without MCP can join a review thread.
+ */
+
+import type { VaultBackend } from '../backend.js'
+import { getBool, getString, type ParsedArgs } from '../args.js'
+import { emitJson, emitLine, emitOk } from '../format.js'
+import {
+  addComment,
+  listCommentThreads,
+  replyToComment,
+  resolveComment,
+  type CommentThreadView
+} from '../../mcp/comment-ops.js'
+
+function requirePath(args: ParsedArgs, usage: string): string {
+  const rel = getString(args, 'path') ?? args.positionals[0]
+  if (!rel) throw new Error(`Usage: ${usage}`)
+  return rel
+}
+
+function requireBody(args: ParsedArgs, positionalIndex: number, usage: string): string {
+  const body = getString(args, 'body') ?? args.positionals[positionalIndex]
+  if (!body || !body.trim()) throw new Error(`Usage: ${usage}`)
+  return body
+}
+
+function when(ms: number): string {
+  return new Date(ms).toISOString().replace('T', ' ').slice(0, 16)
+}
+
+function printThread(thread: CommentThreadView): void {
+  const who = thread.author ?? 'You'
+  const state = thread.resolved ? '  (resolved)' : ''
+  emitLine(`${thread.id}  ${who}  ${when(thread.createdAt)}  line ${thread.line}${state}`)
+  if (thread.anchorText) emitLine(`  > ${thread.anchorText}`)
+  emitLine(`  ${thread.body.replace(/\n/g, '\n  ')}`)
+  for (const reply of thread.replies) {
+    emitLine(`    ${reply.id}  ${reply.author ?? 'You'}  ${when(reply.createdAt)}`)
+    emitLine(`      ${reply.body.replace(/\n/g, '\n      ')}`)
+  }
+}
+
+export async function cmdCommentList(vault: VaultBackend, args: ParsedArgs): Promise<void> {
+  const rel = requirePath(args, 'zn comment list <path> [--all] [--json]')
+  const threads = await listCommentThreads(vault, rel, { includeResolved: getBool(args, 'all') })
+  if (getBool(args, 'json')) {
+    emitJson(threads)
+    return
+  }
+  if (threads.length === 0) {
+    emitLine(getBool(args, 'all') ? 'No comments.' : 'No open comments. Pass --all to include resolved ones.')
+    return
+  }
+  threads.forEach((thread, index) => {
+    if (index > 0) emitLine('')
+    printThread(thread)
+  })
+}
+
+export async function cmdCommentAdd(vault: VaultBackend, args: ParsedArgs): Promise<void> {
+  const usage = 'zn comment add <path> "<body>" [--anchor "<text from the note>"] [--author <name>]'
+  const rel = requirePath(args, usage)
+  const body = requireBody(args, 1, usage)
+  const thread = await addComment(vault, {
+    path: rel,
+    body,
+    anchorText: getString(args, 'anchor'),
+    author: getString(args, 'author')
+  })
+  if (getBool(args, 'json')) {
+    emitJson(thread)
+    return
+  }
+  emitOk(`Commented on ${rel} (${thread.id}${thread.anchorText ? `, line ${thread.line}` : ''})`)
+}
+
+export async function cmdCommentReply(vault: VaultBackend, args: ParsedArgs): Promise<void> {
+  const usage = 'zn comment reply <path> <id> "<body>" [--author <name>]'
+  const rel = requirePath(args, usage)
+  const id = getString(args, 'id') ?? args.positionals[1]
+  if (!id) throw new Error(`Usage: ${usage}`)
+  const body = requireBody(args, 2, usage)
+  const thread = await replyToComment(vault, { path: rel, id, body, author: getString(args, 'author') })
+  if (getBool(args, 'json')) {
+    emitJson(thread)
+    return
+  }
+  emitOk(`Replied in ${thread.id} on ${rel} (${thread.replies.length} ${thread.replies.length === 1 ? 'reply' : 'replies'})`)
+}
+
+export async function cmdCommentResolve(vault: VaultBackend, args: ParsedArgs): Promise<void> {
+  const usage = 'zn comment resolve <path> <id> [--reopen]'
+  const rel = requirePath(args, usage)
+  const id = getString(args, 'id') ?? args.positionals[1]
+  if (!id) throw new Error(`Usage: ${usage}`)
+  const reopen = getBool(args, 'reopen')
+  const thread = await resolveComment(vault, { path: rel, id, resolved: !reopen })
+  if (getBool(args, 'json')) {
+    emitJson(thread)
+    return
+  }
+  emitOk(`${reopen ? 'Reopened' : 'Resolved'} ${thread.id} on ${rel}`)
+}
diff --git a/apps/desktop/src/cli/help.ts b/apps/desktop/src/cli/help.ts
index f342354a..8b7c51e6 100644
--- a/apps/desktop/src/cli/help.ts
+++ b/apps/desktop/src/cli/help.ts
@@ -138,6 +138,15 @@ const SECTIONS: Array<{ heading: string; rows: CommandRow[] }> = [
       { name: 'task toggle <id>', description: 'Flip a task checkbox by stable id' }
     ]
   },
+  {
+    heading: 'COMMENTS',
+    rows: [
+      { name: 'comment list <path>', description: 'Comment threads on a note, with anchors and replies', flags: '--all  --json' },
+      { name: 'comment add <path> "<body>"', description: 'Start a thread, optionally anchored to text from the note', flags: '--anchor <text>  --author <name>  --json' },
+      { name: 'comment reply <path> <id> "<body>"', description: 'Answer in a thread', flags: '--author <name>  --json' },
+      { name: 'comment resolve <path> <id>', description: 'Resolve a thread (or reopen it)', flags: '--reopen  --json' }
+    ]
+  },
   {
     heading: 'VAULT',
     rows: [
@@ -203,6 +212,8 @@ const EXAMPLES: string[] = [
   'zn list --server home                # a self-hosted ZenNotes server',
   'zn capture "from CI" --server https://notes.example.com',
   'zn task list --unchecked --tag work',
+  'zn comment list inbox/Plan.md',
+  'zn comment reply inbox/Plan.md <id> "Agreed, fixed in the second paragraph." --author Claude',
   'zn open ~/Downloads/notes.md',
   'zn open ~/code/project/docs   # focus a folder as a session'
 ]
diff --git a/apps/desktop/src/cli/index.ts b/apps/desktop/src/cli/index.ts
index 79e37e26..7e07e8dc 100644
--- a/apps/desktop/src/cli/index.ts
+++ b/apps/desktop/src/cli/index.ts
@@ -45,6 +45,12 @@ import {
   cmdFolderRename
 } from './commands/folders.js'
 import { cmdTaskList, cmdTaskToggle } from './commands/tasks.js'
+import {
+  cmdCommentAdd,
+  cmdCommentList,
+  cmdCommentReply,
+  cmdCommentResolve
+} from './commands/comments.js'
 import { cmdTagFind, cmdTagList } from './commands/tags.js'
 import { cmdVaultInfo, cmdVaultList } from './commands/vault.js'
 import { cmdCapture } from './commands/capture.js'
@@ -132,6 +138,10 @@ async function main(argv: string[]): Promise<number> {
     'tag find': cmdTagFind,
     'task list': cmdTaskList,
     'task toggle': cmdTaskToggle,
+    'comment list': cmdCommentList,
+    'comment add': cmdCommentAdd,
+    'comment reply': cmdCommentReply,
+    'comment resolve': cmdCommentResolve,
     'vault info': cmdVaultInfo,
     'base list': cmdBaseList,
     'base create': cmdBaseCreate,
@@ -163,6 +173,7 @@ function peelSubcommand(
     folder: ['list', 'create', 'rename', 'delete'],
     tag: ['list', 'find'],
     task: ['list', 'toggle'],
+    comment: ['list', 'add', 'reply', 'resolve'],
     vault: ['info', 'list'],
     base: ['list', 'create', 'rows', 'get', 'add', 'set']
   }
diff --git a/apps/desktop/src/cli/remote/client.ts b/apps/desktop/src/cli/remote/client.ts
index 4a3a165f..5f7006b0 100644
--- a/apps/desktop/src/cli/remote/client.ts
+++ b/apps/desktop/src/cli/remote/client.ts
@@ -14,6 +14,8 @@
 
 import { remoteJsonRequest } from '../../main/remote/connection.js'
 import type {
+  NoteComment,
+  NoteCommentInput,
   NoteContent,
   NoteFolder,
   NoteMeta,
@@ -85,6 +87,16 @@ export class CliRemoteClient {
     return this.get<VaultTextSearchMatch[]>(`/api/search/text?${params.toString()}`)
   }
 
+  /** A note's comment sidecar, through the same two routes the desktop
+   *  remote client and the web client use (#738). */
+  readComments(relPath: string): Promise<NoteComment[]> {
+    return this.get<NoteComment[]>(`/api/comments/read?path=${encodeURIComponent(relPath)}`)
+  }
+
+  writeComments(relPath: string, comments: NoteCommentInput[]): Promise<NoteComment[]> {
+    return this.post<NoteComment[]>('/api/comments/write', { path: relPath, comments })
+  }
+
   scanTasks(opts?: { includeExcluded?: boolean }): Promise<VaultTask[]> {
     return this.get<VaultTask[]>(
       opts?.includeExcluded ? '/api/tasks?includeExcluded=1' : '/api/tasks'
diff --git a/apps/desktop/src/main/app-config.test.ts b/apps/desktop/src/main/app-config.test.ts
index f091f471..bb107de1 100644
--- a/apps/desktop/src/main/app-config.test.ts
+++ b/apps/desktop/src/main/app-config.test.ts
@@ -111,7 +111,11 @@ describe('TOML serialization', () => {
       quickNoteTitlePrefix: 'Quick Note',
       keymapOverrides: { 'global.searchNotes': 'Mod+P' },
       kanbanColumnTitles: { 'status:todo': 'To Do' },
-      systemFolderLabels: { inbox: 'In' }
+      systemFolderLabels: { inbox: 'In' },
+      savedTaskFilters: { 'Project alpha': '@project:alpha', Blocked: '@status:blocked' },
+      kanbanGroupBy: 'folder',
+      kanbanFolderRoot: 'Projects',
+      ignoredKeys: ['KanaMode', 'F24']
     }
 
     const text = serializeConfig(portable)
@@ -135,6 +139,18 @@ describe('TOML serialization', () => {
     expect(round.keymapOverrides).toEqual({ 'global.searchNotes': 'Mod+P' })
     expect(round.kanbanColumnTitles).toEqual({ 'status:todo': 'To Do' })
     expect(round.systemFolderLabels).toEqual({ inbox: 'In' })
+    // The [saved_filters] table keeps the order the chips show (#731).
+    expect(text).toContain('kanban_folder_root = "Projects"')
+    expect(round.kanbanGroupBy).toBe('folder')
+    expect(round.kanbanFolderRoot).toBe('Projects')
+    expect(text).toContain('ignored_keys = ["KanaMode", "F24"]')
+    expect(round.ignoredKeys).toEqual(['KanaMode', 'F24'])
+    expect(text).toContain('[saved_filters]')
+    expect(text).toContain('"Project alpha" = "@project:alpha"')
+    expect(Object.entries(round.savedTaskFilters as Record<string, string>)).toEqual([
+      ['Project alpha', '@project:alpha'],
+      ['Blocked', '@status:blocked']
+    ])
   })
 
   it('persists null as empty string and reads it back as null', () => {
@@ -281,3 +297,17 @@ describe('file watching', () => {
     expect(changes.at(-1)?.editorFontSize).toBe(22)
   }, 10000)
 })
+
+describe('unbound keymaps in config.toml', () => {
+  it('writes an unbind as an empty binding, marks it, and reads it back as ""', () => {
+    const text = serializeConfig({ keymapOverrides: { 'global.zoomIn': '' } })
+    expect(text).toContain('"global.zoomIn" = ""  # unbound')
+    // The reference list explains the convention and no longer repeats the
+    // overridden action as a commented default.
+    expect(text).toContain('# An empty binding ("") removes the key entirely')
+    expect(text).not.toContain('# "global.zoomIn" = "Mod+="')
+
+    const { portable } = deserializeConfig(text)
+    expect(portable.keymapOverrides).toEqual({ 'global.zoomIn': '' })
+  })
+})
diff --git a/apps/desktop/src/main/app-config.ts b/apps/desktop/src/main/app-config.ts
index da3ebf41..b6a1da47 100644
--- a/apps/desktop/src/main/app-config.ts
+++ b/apps/desktop/src/main/app-config.ts
@@ -373,7 +373,13 @@ const SCALAR_FIELDS: Partial<Record<PortablePrefKey, ScalarFieldMap>> = {
   kanbanGroupBy: {
     section: 'view',
     tomlKey: 'kanban_group_by',
-    comment: 'status | priority | folder'
+    comment: 'status | priority | folder (each note\'s own folder; see kanban_folder_root) | field:<key>'
+  },
+  kanbanFolderRoot: {
+    section: 'view',
+    tomlKey: 'kanban_folder_root',
+    comment:
+      'folder board: group by the children of this folder, e.g. "Projects" (deeper notes roll up, notes outside it share one column); "" = each note\'s own folder'
   }
 }
 
@@ -388,6 +394,12 @@ interface ListFieldMap {
 
 // List (ordered string[]) portable prefs → [section].key = ["a", "b"].
 const LIST_FIELDS: Partial<Record<PortablePrefKey, ListFieldMap>> = {
+  ignoredKeys: {
+    section: 'editor',
+    tomlKey: 'ignored_keys',
+    comment:
+      'keys the app ignores entirely, by DOM key or code, e.g. ["KanaMode"] for the no-op a Kanata/QMK tap-hold layer sends with every keystroke'
+  },
   kanbanStatuses: {
     section: 'view',
     tomlKey: 'kanban_statuses',
@@ -416,6 +428,7 @@ const MAP_TABLE_FIELDS: Partial<Record<PortablePrefKey, MapTableField>> = {
     table: 'keymaps',
     comment: [
       'Keymap overrides — only list the bindings you want to change.',
+      'Set a binding to "" to remove the key entirely.',
       'Find the full list of action IDs in Settings → Keymaps.'
     ],
     example: '"global.searchNotes" = "Mod+P"'
@@ -444,6 +457,15 @@ const MAP_TABLE_FIELDS: Partial<Record<PortablePrefKey, MapTableField>> = {
     table: 'text_replacements',
     comment: ['Text replacements expanded while typing, keyed by trigger.'],
     example: '"->" = "→"'
+  },
+  savedTaskFilters: {
+    table: 'saved_filters',
+    comment: [
+      'Saved Tasks filters: a name you pick = the filter query it stands for.',
+      'Recall one from the chips above the task list, the command palette,',
+      'or `:filter <name>` in the Tasks view; `:savefilter <name>` adds one.'
+    ],
+    example: '"Project alpha" = "@project:alpha"'
   }
 }
 
@@ -606,11 +628,14 @@ function keymapSectionLines(rawOverrides: unknown): string[] {
     '# Keymap overrides. Add or uncomment "<action.id>" = "<binding>" lines.',
     '# Binding syntax: "Mod+P" = Cmd/Ctrl+P, "Shift+Mod+K", "Ctrl+W", "Space",',
     '# or a two-key sequence like "g g". Uncomment a reference line to remap it.',
+    '# An empty binding ("") removes the key entirely: nothing triggers that',
+    '# action until you give it a key again or delete the line.',
     '[keymaps]'
   ]
 
   for (const [key, value] of Object.entries(overrides)) {
-    lines.push(`${tomlKey(key)} = ${tomlValue(value)}`)
+    const line = `${tomlKey(key)} = ${tomlValue(value)}`
+    lines.push(value === '' ? `${line}  # unbound` : line)
   }
 
   lines.push('', '# --- All actions (defaults shown; uncomment + edit to override) ---')
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index 2cb126de..3eb65213 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -3448,18 +3448,36 @@ function registerIpc(): void {
     return await deleteWorkflowRuns(v.root, workflowId);
   });
 
-  // Custom templates live on the local filesystem only; remote vaults fall
-  // back to built-in templates (renderer constants), so list returns empty and
-  // mutations are rejected.
+  // Custom templates are the vault's .zennotes/templates/ on both sides of
+  // the bridge: a local vault reads the disk, and a remote workspace asks the
+  // server, which serves the same files through its /templates routes since
+  // 2.46 (#723). An older server has no such routes: it lists nothing, keeps
+  // the built-in templates (renderer constants), and names the remedy on a
+  // write instead of answering a bare 404.
+  const requireRemoteTemplates = (action: string): RemoteServerClient => {
+    const client = requireRemoteWorkspaceClient();
+    if (!remoteServerCapabilities?.supportsCustomTemplates) {
+      throw new Error(
+        `${action} needs ZenNotes server 2.46 or later. Update the server and reconnect this workspace.`,
+      );
+    }
+    return client;
+  };
+
   handle(IPC.VAULT_LIST_TEMPLATES, async () => {
-    if (isRemoteWorkspaceActive()) return [];
+    if (isRemoteWorkspaceActive()) {
+      if (!remoteServerCapabilities?.supportsCustomTemplates) return [];
+      return await requireRemoteWorkspaceClient().listTemplates();
+    }
     const v = requireVault();
     return await listCustomTemplates(v.root);
   });
 
   handle(IPC.VAULT_READ_TEMPLATE, async (_e, sourcePath: string) => {
     if (isRemoteWorkspaceActive()) {
-      throw new Error("Custom templates are unavailable on remote vaults");
+      return await requireRemoteTemplates("Editing a custom template").readTemplate(
+        sourcePath,
+      );
     }
     const v = requireVault();
     return await readCustomTemplate(v.root, sourcePath);
@@ -3467,7 +3485,9 @@ function registerIpc(): void {
 
   handle(IPC.VAULT_WRITE_TEMPLATE, async (_e, input: WriteTemplateInput) => {
     if (isRemoteWorkspaceActive()) {
-      throw new Error("Custom templates are unavailable on remote vaults");
+      return await requireRemoteTemplates("Saving a custom template").writeTemplate(
+        input,
+      );
     }
     const v = requireVault();
     return await writeCustomTemplate(v.root, input);
@@ -3475,7 +3495,9 @@ function registerIpc(): void {
 
   handle(IPC.VAULT_DELETE_TEMPLATE, async (_e, sourcePath: string) => {
     if (isRemoteWorkspaceActive()) {
-      throw new Error("Custom templates are unavailable on remote vaults");
+      return await requireRemoteTemplates("Deleting a custom template").deleteTemplate(
+        sourcePath,
+      );
     }
     const v = requireVault();
     return await deleteCustomTemplate(v.root, sourcePath);
diff --git a/apps/desktop/src/main/remote/server-client.test.ts b/apps/desktop/src/main/remote/server-client.test.ts
index faa6a7a8..141c3a8f 100644
--- a/apps/desktop/src/main/remote/server-client.test.ts
+++ b/apps/desktop/src/main/remote/server-client.test.ts
@@ -311,3 +311,93 @@ describe('a 404 for a path this app asked to change (#734)', () => {
     }
   })
 })
+
+describe('custom templates on a remote vault (#723)', () => {
+  interface TemplateServer {
+    port: number
+    close: () => Promise<void>
+    requests: Array<{ method: string; url: string; body: string }>
+  }
+
+  async function templateServer(capabilities: Record<string, unknown>): Promise<TemplateServer> {
+    const requests: TemplateServer['requests'] = []
+    const server = http.createServer((req, res) => {
+      let body = ''
+      req.on('data', (chunk) => (body += chunk))
+      req.on('end', () => {
+        requests.push({ method: req.method ?? '', url: req.url ?? '', body })
+        const send = (status: number, payload: unknown): void => {
+          res.writeHead(status, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify(payload))
+        }
+        if (req.url === '/api/capabilities') return send(200, capabilities)
+        if (req.url === '/api/templates') {
+          return send(200, [{ sourcePath: '.zennotes/templates/adr.md', raw: '---\nname: ADR\n---\n' }])
+        }
+        if (req.url?.startsWith('/api/templates/read?')) return send(200, { raw: '# raw body' })
+        if (req.url === '/api/templates/write') {
+          const input = JSON.parse(body) as { slug: string; raw: string }
+          return send(200, { sourcePath: `.zennotes/templates/${input.slug}.md`, raw: input.raw })
+        }
+        if (req.url === '/api/templates/delete') return send(200, { ok: true })
+        res.writeHead(404)
+        res.end('not found')
+      })
+    })
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+    const { port } = server.address() as AddressInfo
+    return { port, requests, close: () => new Promise((resolve) => server.close(() => resolve())) }
+  }
+
+  it('reads the capability flag, and its absence means an older server', async () => {
+    const supporting = await templateServer({ supportsCustomTemplates: true })
+    const older = await templateServer({ supportsWorkflows: true })
+    try {
+      const withRoutes = new RemoteServerClient({ baseUrl: `http://127.0.0.1:${supporting.port}` })
+      const without = new RemoteServerClient({ baseUrl: `http://127.0.0.1:${older.port}` })
+      expect(await withRoutes.supportsCustomTemplates()).toBe(true)
+      expect(await without.supportsCustomTemplates()).toBe(false)
+    } finally {
+      await supporting.close()
+      await older.close()
+    }
+  })
+
+  it('drives the four template routes with the bridge contract shapes', async () => {
+    const server = await templateServer({ supportsCustomTemplates: true })
+    try {
+      const client = new RemoteServerClient({
+        baseUrl: `http://127.0.0.1:${server.port}`,
+        authToken: 'tok'
+      })
+      const listed = await client.listTemplates()
+      expect(listed).toEqual([{ sourcePath: '.zennotes/templates/adr.md', raw: '---\nname: ADR\n---\n' }])
+
+      expect(await client.readTemplate('.zennotes/templates/adr.md')).toBe('# raw body')
+
+      const written = await client.writeTemplate({
+        slug: 'weekly',
+        raw: '# weekly',
+        previousSourcePath: '.zennotes/templates/adr.md'
+      })
+      expect(written).toEqual({ sourcePath: '.zennotes/templates/weekly.md', raw: '# weekly' })
+
+      await client.deleteTemplate('.zennotes/templates/weekly.md')
+
+      expect(server.requests.map((r) => `${r.method} ${r.url}`)).toEqual([
+        'GET /api/templates',
+        'GET /api/templates/read?path=.zennotes%2Ftemplates%2Fadr.md',
+        'POST /api/templates/write',
+        'POST /api/templates/delete'
+      ])
+      expect(JSON.parse(server.requests[2].body)).toEqual({
+        slug: 'weekly',
+        raw: '# weekly',
+        previousSourcePath: '.zennotes/templates/adr.md'
+      })
+      expect(JSON.parse(server.requests[3].body)).toEqual({ sourcePath: '.zennotes/templates/weekly.md' })
+    } finally {
+      await server.close()
+    }
+  })
+})
diff --git a/apps/desktop/src/main/remote/server-client.ts b/apps/desktop/src/main/remote/server-client.ts
index eea39912..0dc33f0e 100644
--- a/apps/desktop/src/main/remote/server-client.ts
+++ b/apps/desktop/src/main/remote/server-client.ts
@@ -20,6 +20,7 @@ import type {
   VaultTextSearchToolPaths
 } from '@shared/ipc'
 import type { VaultTask } from '@shared/tasks'
+import type { CustomTemplateFile, WriteTemplateInput } from '@zennotes/bridge-contract/templates'
 import WebSocket from 'ws'
 import {
   connectionErrorMessage,
@@ -172,6 +173,36 @@ export class RemoteServerClient {
     await this.jsonRequest('/api/workflows/delete', { method: 'POST', body: { sourcePath } })
   }
 
+  /** True when the connected server advertises the custom-template routes
+   *  from 2.46 (#723). An older server keeps Settings, Templates read-only,
+   *  exactly like the web client against it. */
+  async supportsCustomTemplates(): Promise<boolean> {
+    const caps = await this.getCapabilities()
+    return caps?.supportsCustomTemplates === true
+  }
+
+  async listTemplates(): Promise<CustomTemplateFile[]> {
+    return this.jsonRequest<CustomTemplateFile[]>('/api/templates')
+  }
+
+  async readTemplate(sourcePath: string): Promise<string> {
+    const result = await this.jsonRequest<{ raw: string }>(
+      `/api/templates/read?path=${encodeURIComponent(sourcePath)}`
+    )
+    return result.raw
+  }
+
+  async writeTemplate(input: WriteTemplateInput): Promise<CustomTemplateFile> {
+    return this.jsonRequest<CustomTemplateFile>('/api/templates/write', {
+      method: 'POST',
+      body: input as unknown as Record<string, unknown>
+    })
+  }
+
+  async deleteTemplate(sourcePath: string): Promise<void> {
+    await this.jsonRequest('/api/templates/delete', { method: 'POST', body: { sourcePath } })
+  }
+
   /** Prepare on this side (reads through the server), apply transactionally on
    *  the server — the same split the web bridge ships for #608. */
   async applyWorkflow(input: ApplyWorkflowInput): Promise<WorkflowRunReceipt> {
diff --git a/apps/desktop/src/main/vault.ts b/apps/desktop/src/main/vault.ts
index de4e608e..47832097 100644
--- a/apps/desktop/src/main/vault.ts
+++ b/apps/desktop/src/main/vault.ts
@@ -53,6 +53,7 @@ import {
   VaultInfo
 } from '@shared/ipc'
 import { DEMO_TOUR_DIR } from '@shared/demo-tour'
+import { normalizeNoteComments } from '@shared/note-comments'
 import { FRONTMATTER_BLOCK_RE, frontmatterTags } from '@shared/frontmatter'
 import { IMAGE_FILE_EXTENSIONS, pastedImageFilename } from '@shared/pasted-image'
 import {
@@ -3135,59 +3136,6 @@ export async function writeNote(root: string, rel: string, body: string): Promis
   return await readMeta(root, abs, folder)
 }
 
-function normalizeNoteComment(input: NoteCommentInput, notePath: string): NoteComment | null {
-  const body = typeof input.body === 'string' ? input.body.trim() : ''
-  if (!body) return null
-  const now = Date.now()
-  const rawStart = Number.isFinite(input.anchorStart) ? Math.max(0, Math.floor(input.anchorStart)) : 0
-  const rawEnd = Number.isFinite(input.anchorEnd) ? Math.max(0, Math.floor(input.anchorEnd)) : rawStart
-  const anchorStart = Math.min(rawStart, rawEnd)
-  const anchorEnd = Math.max(rawStart, rawEnd)
-  const anchorText =
-    typeof input.anchorText === 'string'
-      ? input.anchorText.replace(/\s+/g, ' ').trim().slice(0, 500)
-      : ''
-  return {
-    id: typeof input.id === 'string' && input.id.trim() ? input.id.trim() : randomUUID(),
-    notePath,
-    anchorStart,
-    anchorEnd,
-    anchorText,
-    body,
-    createdAt:
-      typeof input.createdAt === 'number' && Number.isFinite(input.createdAt)
-        ? input.createdAt
-        : now,
-    updatedAt:
-      typeof input.updatedAt === 'number' && Number.isFinite(input.updatedAt)
-        ? input.updatedAt
-        : now,
-    resolvedAt:
-      typeof input.resolvedAt === 'number' && Number.isFinite(input.resolvedAt)
-        ? input.resolvedAt
-        : null
-  }
-}
-
-function normalizeNoteComments(raw: unknown, notePath: string): NoteComment[] {
-  const values = Array.isArray(raw)
-    ? raw
-    : raw && typeof raw === 'object' && Array.isArray((raw as { comments?: unknown }).comments)
-      ? (raw as { comments: unknown[] }).comments
-      : []
-  const seen = new Set<string>()
-  const comments: NoteComment[] = []
-  for (const value of values) {
-    if (!value || typeof value !== 'object') continue
-    const comment = normalizeNoteComment(value as NoteCommentInput, notePath)
-    if (!comment || seen.has(comment.id)) continue
-    seen.add(comment.id)
-    comments.push(comment)
-  }
-  comments.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id))
-  return comments
-}
-
 export async function readNoteComments(root: string, rel: string): Promise<NoteComment[]> {
   const notePath = toPosix(rel)
   const abs = noteCommentsPath(root, notePath)
diff --git a/apps/desktop/src/main/watcher.test.ts b/apps/desktop/src/main/watcher.test.ts
index 5ffdcd28..f938291b 100644
--- a/apps/desktop/src/main/watcher.test.ts
+++ b/apps/desktop/src/main/watcher.test.ts
@@ -124,3 +124,35 @@ describe('VaultWatcher atomic saves', () => {
     20_000
   )
 })
+
+describe('VaultWatcher custom templates (#723)', () => {
+  it(
+    'announces a template file under its own scope, and ignores what is not a template',
+    async () => {
+      const root = await makeVault()
+      const events: VaultChangeEvent[] = []
+      const watcher = new VaultWatcher(() => Promise.resolve(settingsWithArchiveRemap()))
+      watchers.push(watcher)
+      watcher.start(root, (ev) => events.push(ev))
+      await sleep(400)
+
+      const dir = path.join(root, '.zennotes', 'templates')
+      await mkdir(dir, { recursive: true })
+      await writeFile(path.join(dir, 'adr.md'), '---\nname: ADR\n---\n')
+      const event = await waitForEvent(events)
+      expect(event).toEqual({
+        kind: 'add',
+        path: '.zennotes/templates/adr.md',
+        folder: 'inbox',
+        scope: 'templates'
+      })
+
+      events.length = 0
+      await writeFile(path.join(dir, '.draft.md'), 'hidden')
+      await writeFile(path.join(dir, 'notes.txt'), 'text')
+      await sleep(600)
+      expect(events).toEqual([])
+    },
+    15_000
+  )
+})
diff --git a/apps/desktop/src/main/watcher.ts b/apps/desktop/src/main/watcher.ts
index 549f9f01..04b3e5d2 100644
--- a/apps/desktop/src/main/watcher.ts
+++ b/apps/desktop/src/main/watcher.ts
@@ -9,6 +9,7 @@ const INTERNAL_VAULT_DIR = '.zennotes'
 const VAULT_SETTINGS_RELATIVE_PATH = `${INTERNAL_VAULT_DIR}/vault.json`
 const NOTE_COMMENTS_PREFIX = `${INTERNAL_VAULT_DIR}/comments/`
 const NOTE_COMMENTS_SUFFIX = '.comments.json'
+const TEMPLATES_PREFIX = `${INTERNAL_VAULT_DIR}/templates/`
 
 function toPosix(p: string): string {
   return p.split(path.sep).join('/')
@@ -36,6 +37,19 @@ function commentsNotePath(root: string, abs: string): string | null {
   return rel.slice(NOTE_COMMENTS_PREFIX.length, -NOTE_COMMENTS_SUFFIX.length)
 }
 
+/** A custom template: a `.md` file directly inside `.zennotes/templates/`,
+ *  the flat directory the template module serves. Dotfiles and nested paths
+ *  are not templates there either. Mirrors templatePath in the Go watcher. */
+function templatePath(root: string, abs: string): string | null {
+  const rel = relativeVaultPath(root, abs)
+  if (!rel.startsWith(TEMPLATES_PREFIX)) return null
+  const name = rel.slice(TEMPLATES_PREFIX.length)
+  if (!name || name.includes('/') || name.startsWith('.') || !name.toLowerCase().endsWith('.md')) {
+    return null
+  }
+  return rel
+}
+
 export class VaultWatcher {
   private watcher: FSWatcher | null = null
   private root: string | null = null
@@ -129,6 +143,14 @@ export class VaultWatcher {
         )
         return
       }
+      // A template is not a note: its own scope has the renderer re-list
+      // templates instead of the note tree (#723). Another window on this
+      // vault, or a synced dotfile, is how one changes behind the app's back.
+      const templateSourcePath = templatePath(this.root, absPath)
+      if (templateSourcePath) {
+        onEvent({ kind, path: templateSourcePath, folder: 'inbox', scope: 'templates' })
+        return
+      }
       // Any database file — `<Name>.base/data.csv` or `schema.json` (or a legacy
       // loose `.csv`/sidecar) — normalizes to the canonical `data.csv` path so
       // the renderer re-hydrates the right database. (Record-page `.md` notes in
diff --git a/apps/desktop/src/mcp/comment-ops.test.ts b/apps/desktop/src/mcp/comment-ops.test.ts
new file mode 100644
index 00000000..471c1353
--- /dev/null
+++ b/apps/desktop/src/mcp/comment-ops.test.ts
@@ -0,0 +1,116 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { createBackend, type VaultBackend } from '../cli/backend'
+import { addComment, anchorForText, listCommentThreads, replyToComment, resolveComment } from './comment-ops'
+
+// The comment operations behind the MCP tools and `zn comment` (#738), run
+// against a real folder through the local backend so the sidecar the app
+// reads is exactly what these write.
+
+let root: string
+let backend: VaultBackend
+const NOTE = 'inbox/Plan.md'
+
+beforeEach(async () => {
+  root = await mkdtemp(path.join(os.tmpdir(), 'zennotes-comment-ops-'))
+  await mkdir(path.join(root, 'inbox'), { recursive: true })
+  await writeFile(
+    path.join(root, 'inbox', 'Plan.md'),
+    '# Plan\n\nShip the beta in October.\n\nThe migration runs at night.\n'
+  )
+  backend = createBackend({ kind: 'local', root })
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('anchorForText', () => {
+  const doc = 'Alpha beta\nGamma Delta\n'
+  it('finds the passage exactly, then ignoring case, and refuses what is not there', () => {
+    expect(anchorForText(doc, 'Gamma')).toEqual({ anchorStart: 11, anchorEnd: 16, anchorText: 'Gamma' })
+    expect(anchorForText(doc, 'gamma delta')).toEqual({ anchorStart: 11, anchorEnd: 22, anchorText: 'Gamma Delta' })
+    expect(anchorForText(doc, undefined)).toEqual({ anchorStart: 0, anchorEnd: 0, anchorText: '' })
+    expect(() => anchorForText(doc, 'omega')).toThrow(/anchor_text was not found/)
+  })
+})
+
+describe('comment threads on a note', () => {
+  it('adds an anchored comment, answers it in a thread, and resolves it', async () => {
+    const thread = await addComment(backend, {
+      path: NOTE,
+      body: 'Is October still realistic?',
+      anchorText: 'Ship the beta in October.',
+      author: undefined
+    })
+    expect(thread.author).toBeNull()
+    expect(thread.line).toBe(3)
+    expect(thread.anchorText).toBe('Ship the beta in October.')
+    expect(thread.replies).toEqual([])
+
+    const answered = await replyToComment(backend, {
+      path: NOTE,
+      id: thread.id,
+      body: 'Yes: the migration is the only blocker and it runs at night.',
+      author: 'Claude Code'
+    })
+    expect(answered.id).toBe(thread.id)
+    expect(answered.replies).toHaveLength(1)
+    expect(answered.replies[0].author).toBe('Claude Code')
+
+    // A reply to the reply lands in the same thread, one level deep.
+    const again = await replyToComment(backend, {
+      path: NOTE,
+      id: answered.replies[0].id,
+      body: 'Agreed, keep October.'
+    })
+    expect(again.id).toBe(thread.id)
+    expect(again.replies.map((r) => r.author)).toEqual(['Claude Code', null])
+
+    const open = await listCommentThreads(backend, NOTE)
+    expect(open.map((t) => t.id)).toEqual([thread.id])
+
+    const done = await resolveComment(backend, { path: NOTE, id: again.replies[1].id })
+    expect(done.id).toBe(thread.id)
+    expect(done.resolved).toBe(true)
+    expect(await listCommentThreads(backend, NOTE)).toEqual([])
+    expect((await listCommentThreads(backend, NOTE, { includeResolved: true }))[0].resolved).toBe(true)
+
+    const reopened = await resolveComment(backend, { path: NOTE, id: thread.id, resolved: false })
+    expect(reopened.resolved).toBe(false)
+
+    // The sidecar is where the app reads: same path, same envelope.
+    const sidecar = JSON.parse(
+      await readFile(path.join(root, '.zennotes', 'comments', 'inbox', 'Plan.md.comments.json'), 'utf8')
+    ) as { version: number; comments: Array<Record<string, unknown>> }
+    expect(sidecar.version).toBe(1)
+    expect(sidecar.comments).toHaveLength(3)
+    expect(sidecar.comments[1]).toMatchObject({ parentId: thread.id, author: 'Claude Code' })
+    expect(sidecar.comments[0]).not.toHaveProperty('author')
+  })
+
+  it('reports the line an anchor sits on after the note moved', async () => {
+    const thread = await addComment(backend, {
+      path: NOTE,
+      body: 'Night runs need a rollback plan.',
+      anchorText: 'The migration runs at night.'
+    })
+    expect(thread.line).toBe(5)
+    await writeFile(
+      path.join(root, 'inbox', 'Plan.md'),
+      '# Plan\n\nA new paragraph first.\n\nShip the beta in October.\n\nThe migration runs at night.\n'
+    )
+    const [moved] = await listCommentThreads(backend, NOTE)
+    expect(moved.line).toBe(7)
+  })
+
+  it('refuses an empty body, an unknown id, and text that is not in the note', async () => {
+    await expect(addComment(backend, { path: NOTE, body: '   ' })).rejects.toThrow(/empty/)
+    await expect(addComment(backend, { path: NOTE, body: 'x', anchorText: 'not here' })).rejects.toThrow(/not found/)
+    await expect(replyToComment(backend, { path: NOTE, id: 'nope', body: 'x' })).rejects.toThrow(/No comment with id/)
+    await expect(resolveComment(backend, { path: NOTE, id: 'nope' })).rejects.toThrow(/No comment with id/)
+    expect(await listCommentThreads(backend, NOTE)).toEqual([])
+  })
+})
diff --git a/apps/desktop/src/mcp/comment-ops.ts b/apps/desktop/src/mcp/comment-ops.ts
new file mode 100644
index 00000000..d56cd81e
--- /dev/null
+++ b/apps/desktop/src/mcp/comment-ops.ts
@@ -0,0 +1,161 @@
+/**
+ * Comment operations for the MCP tools and `zn comment` (#738), composed
+ * from a backend's note read and comment read/write so a local folder and a
+ * ZenNotes server behave the same. The shapes here are what a model sees:
+ * threads (a top-level comment with its replies), the anchored text and the
+ * line it sits on today, and who said what.
+ */
+
+import {
+  lineOfOffset,
+  resolveCommentAnchor,
+  threadNoteComments,
+  threadRootOf
+} from '@shared/note-comments'
+import type { NoteComment, NoteCommentInput } from '@shared/ipc'
+import type { VaultBackend } from '../cli/backend.js'
+
+export interface CommentView {
+  id: string
+  author: string | null
+  body: string
+  createdAt: number
+  updatedAt: number
+}
+
+export interface CommentThreadView extends CommentView {
+  /** The text the comment was written on, as stored. Empty for a note-level comment. */
+  anchorText: string
+  /** 1-based line the anchor sits on in the note as it is now. */
+  line: number
+  resolved: boolean
+  resolvedAt: number | null
+  replies: CommentView[]
+}
+
+function view(comment: NoteComment): CommentView {
+  return {
+    id: comment.id,
+    author: comment.author ?? null,
+    body: comment.body,
+    createdAt: comment.createdAt,
+    updatedAt: comment.updatedAt
+  }
+}
+
+export async function listCommentThreads(
+  backend: VaultBackend,
+  rel: string,
+  opts: { includeResolved?: boolean } = {}
+): Promise<CommentThreadView[]> {
+  const [note, comments] = await Promise.all([backend.readNote(rel), backend.listComments(rel)])
+  const doc = note.body
+  return threadNoteComments(comments)
+    .filter((thread) => opts.includeResolved || thread.comment.resolvedAt == null)
+    .map((thread) => ({
+      ...view(thread.comment),
+      anchorText: thread.comment.anchorText,
+      line: lineOfOffset(doc, resolveCommentAnchor(thread.comment, doc).from),
+      resolved: thread.comment.resolvedAt != null,
+      resolvedAt: thread.comment.resolvedAt,
+      replies: thread.replies.map(view)
+    }))
+}
+
+/**
+ * Where a new comment attaches. `anchorText` must appear in the note as
+ * written (an exact match first, then one ignoring case); without it the
+ * comment is note-level, anchored at the top.
+ */
+export function anchorForText(
+  doc: string,
+  anchorText: string | undefined
+): Pick<NoteComment, 'anchorStart' | 'anchorEnd' | 'anchorText'> {
+  const wanted = (anchorText ?? '').trim()
+  if (!wanted) return { anchorStart: 0, anchorEnd: 0, anchorText: '' }
+  let at = doc.indexOf(wanted)
+  if (at < 0) at = doc.toLowerCase().indexOf(wanted.toLowerCase())
+  if (at < 0) {
+    throw new Error(
+      `anchor_text was not found in the note. Pass the text exactly as it appears (read_note shows it), or omit it for a note-level comment.`
+    )
+  }
+  return {
+    anchorStart: at,
+    anchorEnd: at + wanted.length,
+    anchorText: doc.slice(at, at + wanted.length).replace(/\s+/g, ' ').trim().slice(0, 500)
+  }
+}
+
+export async function addComment(
+  backend: VaultBackend,
+  input: { path: string; body: string; anchorText?: string; author?: string }
+): Promise<CommentThreadView> {
+  const body = input.body.trim()
+  if (!body) throw new Error('body must not be empty')
+  const note = await backend.readNote(input.path)
+  const anchor = anchorForText(note.body, input.anchorText)
+  const now = Date.now()
+  const current = await backend.listComments(input.path)
+  const draft: NoteCommentInput = {
+    notePath: input.path,
+    ...anchor,
+    body,
+    author: input.author,
+    createdAt: now,
+    updatedAt: now,
+    resolvedAt: null
+  }
+  const written = await backend.writeComments(input.path, [...current, draft])
+  const created = written.find((c) => c.createdAt === now && c.body === body) ?? written[written.length - 1]
+  const threads = await listCommentThreads(backend, input.path, { includeResolved: true })
+  return threads.find((t) => t.id === created.id) ?? threads[threads.length - 1]
+}
+
+export async function replyToComment(
+  backend: VaultBackend,
+  input: { path: string; id: string; body: string; author?: string }
+): Promise<CommentThreadView> {
+  const body = input.body.trim()
+  if (!body) throw new Error('body must not be empty')
+  const current = await backend.listComments(input.path)
+  const root = threadRootOf(current, input.id)
+  if (!root) throw new Error(`No comment with id ${input.id} on ${input.path}. Use list_comments to find ids.`)
+  const now = Date.now()
+  const draft: NoteCommentInput = {
+    notePath: input.path,
+    anchorStart: root.anchorStart,
+    anchorEnd: root.anchorEnd,
+    anchorText: root.anchorText,
+    body,
+    author: input.author,
+    parentId: root.id,
+    createdAt: now,
+    updatedAt: now,
+    resolvedAt: null
+  }
+  await backend.writeComments(input.path, [...current, draft])
+  const threads = await listCommentThreads(backend, input.path, { includeResolved: true })
+  const thread = threads.find((t) => t.id === root.id)
+  if (!thread) throw new Error(`Thread ${root.id} vanished while replying`)
+  return thread
+}
+
+export async function resolveComment(
+  backend: VaultBackend,
+  input: { path: string; id: string; resolved?: boolean }
+): Promise<CommentThreadView> {
+  const current = await backend.listComments(input.path)
+  const root = threadRootOf(current, input.id)
+  if (!root) throw new Error(`No comment with id ${input.id} on ${input.path}. Use list_comments to find ids.`)
+  const resolved = input.resolved ?? true
+  const now = Date.now()
+  const next = current.map((c) =>
+    c.id === root.id ? { ...c, resolvedAt: resolved ? now : null, updatedAt: now } : c
+  )
+  await backend.writeComments(input.path, next)
+  const threads = await listCommentThreads(backend, input.path, { includeResolved: true })
+  const thread = threads.find((t) => t.id === root.id)
+  if (!thread) throw new Error(`Thread ${root.id} vanished while resolving`)
+  return thread
+}
diff --git a/apps/desktop/src/mcp/instructions.ts b/apps/desktop/src/mcp/instructions.ts
index aef9ea1b..aab786c5 100644
--- a/apps/desktop/src/mcp/instructions.ts
+++ b/apps/desktop/src/mcp/instructions.ts
@@ -213,6 +213,28 @@ when the folder is \`Linear Algebra/\`), synonyms, and feeling tags
   \`tasks: false\`/\`note\`, excluded folders). Pass
   includeExcluded: true only when the user asks for everything.
 
+## Comments: reviewing a note together
+
+Notes carry comment threads, kept beside the note and shown in the app's
+Comments panel. A user who asks you to review, answer, or discuss a note
+usually means through those threads, like a pull request, not by editing
+the body.
+
+- Start with \`list_comments\` on the note. Each thread shows the passage it
+  is anchored to, the line it sits on now, who wrote what (\`author\` is
+  null for the user), and the replies so far.
+- Answer a thread with \`reply_to_comment\`; it lands under the user's
+  comment, signed with your name. Reply to every open thread you were asked
+  about, one reply per thread, and keep replies short and concrete.
+- Raise something new with \`add_comment\`, passing \`anchor_text\` copied
+  verbatim from the note so the comment highlights that passage in the app.
+  Omit it only for a note-level remark.
+- Change the note body only when the user asks for the change; when a thread
+  ends in "do it", make the edit with the editing tools, then reply in the
+  thread saying what changed.
+- \`resolve_comment\` only when the user says the thread is settled or asks
+  you to close it. Resolved threads stay in the note's history.
+
 ## Self-check before every write
 
 Scan the markdown before sending it. Fix, don\u2019t ship:
diff --git a/apps/desktop/src/mcp/server.test.ts b/apps/desktop/src/mcp/server.test.ts
index 9fcfdf6b..3b1708ae 100644
--- a/apps/desktop/src/mcp/server.test.ts
+++ b/apps/desktop/src/mcp/server.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import type { VaultBackend } from '../cli/backend'
 import { RemoteRequestError } from '../main/remote/connection'
-import { callTool, describeToolError, listToolNames } from './server'
+import { callTool, commentAuthorForClient, describeToolError, listToolNames } from './server'
 
 // Only the members a given test reaches are implemented; the cast keeps the
 // stubs honest about being partial.
@@ -116,7 +116,11 @@ describe('tools run through the backend', () => {
       'append_to_note',
       'prepend_to_note',
       'insert_at_line',
-      'replace_in_note'
+      'replace_in_note',
+      'list_comments',
+      'add_comment',
+      'reply_to_comment',
+      'resolve_comment'
     ])
   })
 })
@@ -134,3 +138,55 @@ describe('describeToolError', () => {
     expect(describeToolError(new RemoteRequestError('nope', 500))).toBe('nope')
   })
 })
+
+describe('comment tools (#738)', () => {
+  it('lists the four comment tools', () => {
+    const names = listToolNames()
+    for (const name of ['list_comments', 'add_comment', 'reply_to_comment', 'resolve_comment']) {
+      expect(names).toContain(name)
+    }
+  })
+
+  it('signs a comment with the connected client, readably', () => {
+    expect(commentAuthorForClient('claude-code')).toBe('Claude Code')
+    expect(commentAuthorForClient('claude-ai')).toBe('Claude')
+    expect(commentAuthorForClient('codex-cli')).toBe('Codex')
+    expect(commentAuthorForClient('my_custom-agent')).toBe('My Custom Agent')
+    expect(commentAuthorForClient(null)).toBe('Assistant')
+    expect(commentAuthorForClient('  ')).toBe('Assistant')
+  })
+
+  it('reply_to_comment threads under the top-level comment with the author', async () => {
+    let stored: Array<Record<string, unknown>> = [
+      {
+        id: 'c1',
+        notePath: 'inbox/Plan.md',
+        anchorStart: 8,
+        anchorEnd: 33,
+        anchorText: 'Ship the beta in October.',
+        body: 'Still realistic?',
+        createdAt: 1,
+        updatedAt: 1,
+        resolvedAt: null
+      }
+    ]
+    const result = (await callTool(
+      'reply_to_comment',
+      { path: 'inbox/Plan.md', id: 'c1', body: 'Yes, the blocker runs at night.' },
+      backend({
+        readNote: async () =>
+          ({ path: 'inbox/Plan.md', body: '# Plan\n\nShip the beta in October.\n' }) as never,
+        listComments: async () => stored as never,
+        writeComments: async (_rel, comments) => {
+          stored = comments.map((c, i) => ({ ...c, id: (c as { id?: string }).id ?? `c${i + 1}` }))
+          return stored as never
+        }
+      })
+    )) as { id: string; replies: Array<{ author: string | null; body: string }> }
+    expect(result.id).toBe('c1')
+    expect(result.replies).toEqual([
+      expect.objectContaining({ author: 'Assistant', body: 'Yes, the blocker runs at night.' })
+    ])
+    expect(stored[1]).toMatchObject({ parentId: 'c1', anchorText: 'Ship the beta in October.' })
+  })
+})
diff --git a/apps/desktop/src/mcp/server.ts b/apps/desktop/src/mcp/server.ts
index c7caef8e..cb67b9c9 100644
--- a/apps/desktop/src/mcp/server.ts
+++ b/apps/desktop/src/mcp/server.ts
@@ -22,12 +22,45 @@ import { createBackend, type VaultBackend } from '../cli/backend.js'
 import { resolveDefaultTarget } from '../cli/vault-target.js'
 import { RemoteRequestError } from '../main/remote/connection.js'
 import type { NoteFolder } from './vault-ops.js'
+import { addComment, listCommentThreads, replyToComment, resolveComment } from './comment-ops.js'
 
 interface ToolDef {
   schema: Tool
   handler: (args: Record<string, unknown>, backend: VaultBackend) => Promise<unknown>
 }
 
+/* ---------- Comment authorship ---------------------------------------- */
+
+// The MCP client's name from the initialize handshake ("claude-code",
+// "claude-ai", "codex-cli"), read as a display name so a comment left by an
+// assistant says who left it. Set once the session is initialized; the
+// fallback covers direct callTool use and clients that send nothing.
+let connectedClientName: string | null = null
+
+const CLIENT_DISPLAY_NAMES: Record<string, string> = {
+  'claude-ai': 'Claude',
+  'claude-code': 'Claude Code',
+  'claude-desktop': 'Claude',
+  'codex-cli': 'Codex',
+  codex: 'Codex'
+}
+
+export function commentAuthorForClient(clientName: string | null | undefined): string {
+  const raw = (clientName ?? '').trim()
+  if (!raw) return 'Assistant'
+  const known = CLIENT_DISPLAY_NAMES[raw.toLowerCase()]
+  if (known) return known
+  return raw
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((word) => word[0].toUpperCase() + word.slice(1))
+    .join(' ')
+}
+
+function defaultCommentAuthor(): string {
+  return commentAuthorForClient(connectedClientName)
+}
+
 /* ---------- Argument helpers ----------------------------------------- */
 
 function requireString(args: Record<string, unknown>, key: string): string {
@@ -53,6 +86,13 @@ function requireFolder(args: Record<string, unknown>, key: string): NoteFolder {
   return value
 }
 
+function optionalBoolean(args: Record<string, unknown>, key: string): boolean | undefined {
+  const value = args[key]
+  if (value == null) return undefined
+  if (typeof value !== 'boolean') throw new Error(`${key} must be a boolean`)
+  return value
+}
+
 function optionalNumber(args: Record<string, unknown>, key: string): number | undefined {
   const value = args[key]
   if (value == null) return undefined
@@ -789,6 +829,104 @@ const TOOLS: ToolDef[] = [
       const occurrence = (optionalString(args, 'occurrence') as 'first' | 'all' | undefined) ?? 'first'
       return await backend.replaceInNote(rel, find, replace, occurrence)
     }
+  },
+  {
+    schema: {
+      name: 'list_comments',
+      description:
+        'The comment threads on a note: each top-level comment with the text it is anchored to, the line that text sits on now, who wrote it (author is null for the vault owner), and its replies in order. Read this before reviewing or answering a discussion; unresolved threads only unless include_resolved is true.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Vault-relative note path.' },
+          include_resolved: { type: 'boolean', description: 'Also list resolved threads. Default false.' }
+        },
+        required: ['path']
+      }
+    },
+    handler: async (args, backend) =>
+      await listCommentThreads(backend, requireString(args, 'path'), {
+        includeResolved: optionalBoolean(args, 'include_resolved') ?? false
+      })
+  },
+  {
+    schema: {
+      name: 'add_comment',
+      description:
+        'Start a new comment thread on a note, attributed to you. Pass anchor_text, a passage copied exactly from the note, to attach the comment to it (the app highlights it and jumps there); omit it for a note-level comment. Markdown is fine in the body. Returns the new thread.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Vault-relative note path.' },
+          body: { type: 'string', description: 'The comment, in Markdown.' },
+          anchor_text: {
+            type: 'string',
+            description: 'Text from the note the comment is about, verbatim. Omit for a note-level comment.'
+          },
+          author: {
+            type: 'string',
+            description: 'Display name to sign with. Defaults to the connected client (e.g. "Claude Code").'
+          }
+        },
+        required: ['path', 'body']
+      }
+    },
+    handler: async (args, backend) =>
+      await addComment(backend, {
+        path: requireString(args, 'path'),
+        body: requireString(args, 'body'),
+        anchorText: optionalString(args, 'anchor_text'),
+        author: optionalString(args, 'author') ?? defaultCommentAuthor()
+      })
+  },
+  {
+    schema: {
+      name: 'reply_to_comment',
+      description:
+        'Answer a comment in its thread, attributed to you. id is a thread id (or any reply id in it) from list_comments; the reply keeps the thread\u2019s anchor. Use this to respond to the user\u2019s comments the way you would on a pull request, instead of editing the note body. Returns the updated thread.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Vault-relative note path.' },
+          id: { type: 'string', description: 'A comment id from list_comments.' },
+          body: { type: 'string', description: 'The reply, in Markdown.' },
+          author: {
+            type: 'string',
+            description: 'Display name to sign with. Defaults to the connected client.'
+          }
+        },
+        required: ['path', 'id', 'body']
+      }
+    },
+    handler: async (args, backend) =>
+      await replyToComment(backend, {
+        path: requireString(args, 'path'),
+        id: requireString(args, 'id'),
+        body: requireString(args, 'body'),
+        author: optionalString(args, 'author') ?? defaultCommentAuthor()
+      })
+  },
+  {
+    schema: {
+      name: 'resolve_comment',
+      description:
+        'Mark a comment thread resolved (or reopen it with resolved: false). Resolve only when the discussion is settled or the user asks; the thread stays in the note\u2019s history and moves to the Resolved section of the app\u2019s Comments panel.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Vault-relative note path.' },
+          id: { type: 'string', description: 'A comment id from list_comments.' },
+          resolved: { type: 'boolean', description: 'false reopens the thread. Default true.' }
+        },
+        required: ['path', 'id']
+      }
+    },
+    handler: async (args, backend) =>
+      await resolveComment(backend, {
+        path: requireString(args, 'path'),
+        id: requireString(args, 'id'),
+        resolved: optionalBoolean(args, 'resolved') ?? true
+      })
   }
 ]
 
@@ -853,6 +991,10 @@ export async function runMcpServer(): Promise<void> {
     }
   )
 
+  server.oninitialized = () => {
+    connectedClientName = server.getClientVersion()?.name ?? null
+  }
+
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOLS.map((t) => t.schema)
   }))
diff --git a/apps/desktop/src/mcp/vault-ops.test.ts b/apps/desktop/src/mcp/vault-ops.test.ts
index 271d4f1f..15169c2b 100644
--- a/apps/desktop/src/mcp/vault-ops.test.ts
+++ b/apps/desktop/src/mcp/vault-ops.test.ts
@@ -7,6 +7,7 @@ import {
   createNote,
   insertAtLineInBody,
   listNotes,
+  readPrimaryNotesLocation,
   renameNote,
   replaceInBody,
   scanAllTasks,
@@ -242,3 +243,49 @@ describe('pure body edits shared with the remote backend (#688)', () => {
     expect(insertAtLineInBody('one', -5, 'top')).toBe('top\none')
   })
 })
+
+// The app treats an explicit primaryNotesLocation as the answer and infers
+// from the layout only when vault.json leaves it unstated. The CLI and MCP
+// used to let the layout outrank the file, so a vault switched to root mode
+// whose old notes still sat in inbox/ kept getting new notes filed there
+// (#745). The seeded inbox/GitHub note is exactly that leftover.
+describe('primary notes location follows vault.json (#745)', () => {
+  it('files a new note at the root when vault.json says root, old inbox notes or not', async () => {
+    await mkdir(path.join(root, '.zennotes'), { recursive: true })
+    await writeFile(
+      path.join(root, '.zennotes', 'vault.json'),
+      JSON.stringify({ primaryNotesLocation: 'root' })
+    )
+    expect(await readPrimaryNotesLocation(root)).toBe('root')
+
+    const meta = await createNote(root, 'inbox', 'Test', '', 'test')
+    expect(meta.path).toBe('Test.md')
+    expect(meta.folder).toBe('inbox')
+    expect(await readFile(path.join(root, 'Test.md'), 'utf8')).toBe('test')
+  })
+
+  it('keeps filing into inbox/ when vault.json says inbox, whatever sits at the root', async () => {
+    await mkdir(path.join(root, '.zennotes'), { recursive: true })
+    await writeFile(
+      path.join(root, '.zennotes', 'vault.json'),
+      JSON.stringify({ primaryNotesLocation: 'inbox' })
+    )
+    await writeFile(path.join(root, 'Loose.md'), '# Loose\n')
+    expect(await readPrimaryNotesLocation(root)).toBe('inbox')
+
+    const meta = await createNote(root, 'inbox', 'Test')
+    expect(meta.path).toBe('inbox/Test.md')
+  })
+
+  it('infers from the layout only when vault.json leaves the question open', async () => {
+    // No vault.json and notes only in inbox/: a classic ZenNotes vault.
+    expect(await readPrimaryNotesLocation(root)).toBe('inbox')
+    // A loose root note flips the inference to a flat vault.
+    await writeFile(path.join(root, 'Loose.md'), '# Loose\n')
+    expect(await readPrimaryNotesLocation(root)).toBe('root')
+    // A vault.json that is silent about it changes nothing.
+    await mkdir(path.join(root, '.zennotes'), { recursive: true })
+    await writeFile(path.join(root, '.zennotes', 'vault.json'), JSON.stringify({ systemFolderPaths: {} }))
+    expect(await readPrimaryNotesLocation(root)).toBe('root')
+  })
+})
diff --git a/apps/desktop/src/mcp/vault-ops.ts b/apps/desktop/src/mcp/vault-ops.ts
index 2942d5e2..266137ef 100644
--- a/apps/desktop/src/mcp/vault-ops.ts
+++ b/apps/desktop/src/mcp/vault-ops.ts
@@ -13,6 +13,13 @@ import path from 'node:path'
 import os from 'node:os'
 import { parse as parseToml } from 'smol-toml'
 import { retitleLeadingHeading } from '@shared/note-heading-sync'
+import {
+  NOTE_COMMENTS_DIR,
+  NOTE_COMMENTS_SUFFIX,
+  normalizeNoteComments
+} from '@shared/note-comments'
+import type { NoteComment, NoteCommentInput } from '@shared/ipc'
+export type { NoteComment, NoteCommentInput }
 import { noteTasksMode, type NoteTasksMode } from '@shared/tasks'
 import {
   isPathExcludedFromTasks,
@@ -188,61 +195,29 @@ async function countLooseRootContent(root: string, paths: SystemFolderPathsMap):
   return count
 }
 
-/** Recursively count .md files under a given directory. Used to see
- *  whether `<root>/inbox/` actually has content. */
-async function countMdFilesRecursively(dir: string): Promise<number> {
-  let entries: import('node:fs').Dirent[]
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true })
-  } catch {
-    return 0
-  }
-  let count = 0
-  for (const entry of entries) {
-    if (entry.name.startsWith('.')) continue
-    const full = path.join(dir, entry.name)
-    if (entry.isDirectory()) count += await countMdFilesRecursively(full)
-    else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) count += 1
-  }
-  return count
-}
-
-/** Decide whether this vault uses inbox-mode or root-mode for its
- *  primary notes area. The vault's on-disk layout is the strongest
- *  signal — the explicit `vault.json` setting is consulted only when
- *  the layout is genuinely ambiguous (a fresh, empty vault).
- *
- *  This deliberately ignores `vault.json` when it disagrees with the
- *  layout so that:
+/** Decide whether this vault keeps its primary notes in `inbox/` or at the
+ *  vault root. An explicit `primaryNotesLocation` in vault.json is the
+ *  answer, exactly as it is for the app (`getVaultSettings` in
+ *  main/vault.ts): the layout is consulted only when the file leaves the
+ *  question open, because it is missing, unreadable (a TCC-restricted child
+ *  process), or silent about it.
  *
- *  - A user who switched modes in Settings but whose vault hasn't
- *    been migrated yet still gets notes filed where their existing
- *    notes live.
- *  - A user whose `vault.json` was never created (or was deleted /
- *    restored from a sync) still gets correct behavior.
- *  - Sandboxed / TCC-restricted child processes that can't read
- *    `vault.json` still pick the right answer from `readdir` calls
- *    that succeeded.
+ *  This used to be the other way round, with the layout outranking the file
+ *  so that a vault switched to root mode but not yet migrated kept filing new
+ *  notes next to its old ones in inbox/. That put the CLI and MCP at odds
+ *  with the app on the very same vault: Settings said root, the app created
+ *  notes at the root, and `zn create` and `create_note` kept writing into
+ *  inbox/ while `vault_info` reported inbox (#745). The file wins now, on
+ *  every side of the bridge.
  */
 export async function readPrimaryNotesLocation(root: string): Promise<PrimaryNotesLocation> {
+  const explicit = await readExplicitPrimaryNotesLocation(root)
+  if (explicit) return explicit
+  // Loose .md files or user folders at the root mean a flat, Obsidian-style
+  // vault; anything else defaults to inbox, as a fresh ZenNotes vault does.
+  // Mirrors inferPrimaryNotesLocation in main/vault.ts.
   const paths = await readSystemFolderPaths(root)
-  const [rootContent, inboxNotes, explicit] = await Promise.all([
-    countLooseRootContent(root, paths),
-    countMdFilesRecursively(path.join(root, resolvedFolderDirName('inbox', paths))),
-    readExplicitPrimaryNotesLocation(root)
-  ])
-
-  // Strong layout signal — root has user-organized content (loose
-  // .md files, custom subfolders). The vault is laid out flat.
-  if (rootContent >= 1) return 'root'
-
-  // Strong layout signal — only inbox/ has notes, root is empty or
-  // just system folders. Classic ZenNotes lifecycle layout.
-  if (inboxNotes >= 1) return 'inbox'
-
-  // Ambiguous (empty vault). Trust the explicit setting if present,
-  // otherwise default to inbox (matches a fresh ZenNotes install).
-  return explicit ?? 'inbox'
+  return (await countLooseRootContent(root, paths)) >= 1 ? 'root' : 'inbox'
 }
 
 /** The absolute directory that holds notes for a given top-level
@@ -1925,6 +1900,46 @@ export async function insertAtLine(
 
 /* ---------- Backlinks ------------------------------------------------- */
 
+/* ---------- Note comments (#738) --------------------------------------- */
+
+/** The sidecar beside a note: `.zennotes/comments/<rel>.comments.json`, the
+ *  same path the desktop and the Go server use, validated against escapes. */
+function noteCommentsPath(root: string, rel: string): string {
+  const commentsRoot = path.join(root, INTERNAL_VAULT_DIR, NOTE_COMMENTS_DIR)
+  return resolveSafe(commentsRoot, `${toPosix(rel)}${NOTE_COMMENTS_SUFFIX}`)
+}
+
+export async function readNoteComments(root: string, rel: string): Promise<NoteComment[]> {
+  const notePath = toPosix(rel)
+  try {
+    const raw = await fs.readFile(noteCommentsPath(root, notePath), 'utf8')
+    return normalizeNoteComments(JSON.parse(raw), notePath)
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return []
+    if (err instanceof SyntaxError) return []
+    throw err
+  }
+}
+
+/** Replace a note's comments. An empty list removes the sidecar, as the app
+ *  does, so a note with no comments leaves nothing behind. */
+export async function writeNoteComments(
+  root: string,
+  rel: string,
+  comments: NoteCommentInput[]
+): Promise<NoteComment[]> {
+  const notePath = toPosix(rel)
+  const normalized = normalizeNoteComments(comments, notePath)
+  const abs = noteCommentsPath(root, notePath)
+  if (normalized.length === 0) {
+    await fs.rm(abs, { force: true })
+    return []
+  }
+  await fs.mkdir(path.dirname(abs), { recursive: true })
+  await fs.writeFile(abs, JSON.stringify({ version: 1, comments: normalized }, null, 2), 'utf8')
+  return normalized
+}
+
 export async function backlinks(root: string, rel: string): Promise<NoteMeta[]> {
   const abs = resolveSafe(root, rel)
   const all = await listNotes(root)
diff --git a/apps/server/internal/httpserver/server.go b/apps/server/internal/httpserver/server.go
index 0fc1d558..9b4ffafb 100644
--- a/apps/server/internal/httpserver/server.go
+++ b/apps/server/internal/httpserver/server.go
@@ -221,6 +221,11 @@ func (s *Server) registerProtectedRoutes(r chi.Router) {
 	r.Post("/folders/delete", s.deleteFolder)
 	r.Post("/folders/duplicate", s.duplicateFolder)
 
+	r.Get("/templates", s.listTemplates)
+	r.Get("/templates/read", s.readTemplate)
+	r.Post("/templates/write", s.writeTemplate)
+	r.Post("/templates/delete", s.deleteTemplate)
+
 	r.Get("/search/capabilities", s.searchCapabilities)
 	r.Get("/search/text", s.searchText)
 
@@ -297,7 +302,7 @@ func writeError(w http.ResponseWriter, err error) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	if errors.Is(err, vault.ErrInvalidWorkflow) {
+	if errors.Is(err, vault.ErrInvalidWorkflow) || errors.Is(err, vault.ErrInvalidTemplate) {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
@@ -415,6 +420,11 @@ func (s *Server) capabilities(w http.ResponseWriter, _ *http.Request) {
 		// prepared-run endpoint applies them under the same vault lock as note
 		// writes. Its presence lets bundled web clients enable authoring and Run.
 		"supportsWorkflows": true,
+		// Custom-template CRUD under .zennotes/templates/ (the /templates
+		// routes), the same files the desktop keeps for a local vault. Absent
+		// before 2.46: the web client and a desktop on a remote vault hide New
+		// template and Edit there and say the server needs an update.
+		"supportsCustomTemplates": true,
 		// Says out loud that a missing file answers 404 rather than 500.
 		// Databases are composed from file reads where "absent" and "failed"
 		// mean opposite things (see remote-absence.ts), and a server that
diff --git a/apps/server/internal/httpserver/templates.go b/apps/server/internal/httpserver/templates.go
new file mode 100644
index 00000000..3ba65fd4
--- /dev/null
+++ b/apps/server/internal/httpserver/templates.go
@@ -0,0 +1,77 @@
+package httpserver
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/ZenNotes/zennotes/apps/server/internal/vault"
+)
+
+// Custom-template routes: the server half of Settings, Templates for the web
+// client and for a desktop connected to a remote vault. Clients gate on the
+// supportsCustomTemplates capability, so an older server answers a bare 404
+// here and they say the server needs an update instead.
+
+const maxTemplateMetadataRequestBytes = 64 << 10
+
+func (s *Server) listTemplates(w http.ResponseWriter, _ *http.Request) {
+	files, err := s.currentVault().ListTemplates()
+	if err != nil {
+		writeError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, files)
+}
+
+func (s *Server) readTemplate(w http.ResponseWriter, r *http.Request) {
+	raw, err := s.currentVault().ReadTemplate(r.URL.Query().Get("path"))
+	if err != nil {
+		writeError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"raw": raw})
+}
+
+func (s *Server) writeTemplate(w http.ResponseWriter, r *http.Request) {
+	cfg := s.currentConfig()
+	r.Body = http.MaxBytesReader(w, r.Body, cfg.MaxNoteBytes+jsonEnvelopeBytes)
+	var input vault.WriteTemplateInput
+	if err := readJSON(r, &input); err != nil {
+		var tooLarge *http.MaxBytesError
+		if errors.As(err, &tooLarge) {
+			http.Error(w, "template exceeds the configured note size limit", http.StatusRequestEntityTooLarge)
+			return
+		}
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	// The envelope allowance above is for field names and JSON escaping, not
+	// for the template: a body that fits the reader can still unescape to a
+	// raw string past the note limit, and a template is a note in waiting.
+	if cfg.MaxNoteBytes > 0 && int64(len(input.Raw)) > cfg.MaxNoteBytes {
+		http.Error(w, "template exceeds the configured note size limit", http.StatusRequestEntityTooLarge)
+		return
+	}
+	file, err := s.currentVault().WriteTemplate(input)
+	if err != nil {
+		writeError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, file)
+}
+
+func (s *Server) deleteTemplate(w http.ResponseWriter, r *http.Request) {
+	r.Body = http.MaxBytesReader(w, r.Body, maxTemplateMetadataRequestBytes)
+	var request struct {
+		SourcePath string `json:"sourcePath"`
+	}
+	if err := readJSON(r, &request); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if err := s.currentVault().DeleteTemplate(request.SourcePath); err != nil {
+		writeError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]bool{"ok": true})
+}
diff --git a/apps/server/internal/httpserver/templates_test.go b/apps/server/internal/httpserver/templates_test.go
new file mode 100644
index 00000000..9a6c4266
--- /dev/null
+++ b/apps/server/internal/httpserver/templates_test.go
@@ -0,0 +1,225 @@
+package httpserver
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/ZenNotes/zennotes/apps/server/internal/config"
+	"github.com/ZenNotes/zennotes/apps/server/internal/vault"
+)
+
+const templateTestToken = "template-token"
+
+func templateTestServer(t *testing.T, maxNoteBytes int64) (*httptest.Server, string) {
+	t.Helper()
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "inbox"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "inbox", "Note.md"), []byte("# Note\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	server, _ := newTestServer(t, config.Config{
+		VaultPath:        root,
+		DefaultVaultPath: root,
+		Bind:             "127.0.0.1:7878",
+		AuthToken:        templateTestToken,
+		BrowseRoots:      []string{root},
+		MaxNoteBytes:     maxNoteBytes,
+	})
+	return server, root
+}
+
+func templateRequest(t *testing.T, method, url string, body any, token string) *http.Response {
+	t.Helper()
+	var reader io.Reader
+	if body != nil {
+		raw, err := json.Marshal(body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		reader = bytes.NewReader(raw)
+	}
+	req, err := http.NewRequest(method, url, reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	if token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("%s %s: %v", method, url, err)
+	}
+	return resp
+}
+
+func decodeBody[T any](t *testing.T, resp *http.Response) T {
+	t.Helper()
+	defer resp.Body.Close()
+	var out T
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+	return out
+}
+
+func TestTemplateRoutesRequireAuth(t *testing.T) {
+	server, _ := templateTestServer(t, 10<<20)
+	for _, route := range []struct{ method, path string }{
+		{http.MethodGet, "/api/templates"},
+		{http.MethodGet, "/api/templates/read?path=.zennotes/templates/adr.md"},
+		{http.MethodPost, "/api/templates/write"},
+		{http.MethodPost, "/api/templates/delete"},
+	} {
+		resp := templateRequest(t, route.method, server.URL+route.path, map[string]string{}, "")
+		resp.Body.Close()
+		if resp.StatusCode != http.StatusUnauthorized {
+			t.Fatalf("%s %s without a token: %d, want 401", route.method, route.path, resp.StatusCode)
+		}
+	}
+	resp := templateRequest(t, http.MethodGet, server.URL+"/api/templates", nil, templateTestToken)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("list with a token: %d", resp.StatusCode)
+	}
+	if files := decodeBody[[]vault.CustomTemplateFile](t, resp); len(files) != 0 {
+		t.Fatalf("fresh vault lists %+v", files)
+	}
+}
+
+func TestTemplateRoutesWriteListReadDelete(t *testing.T) {
+	server, root := templateTestServer(t, 10<<20)
+	raw := "---\nname: Weekly\n---\n# {{title}}\n"
+
+	resp := templateRequest(t, http.MethodPost, server.URL+"/api/templates/write", map[string]string{
+		"slug": "Réunion Hebdo!", "raw": raw,
+	}, templateTestToken)
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("write: %d", resp.StatusCode)
+	}
+	written := decodeBody[vault.CustomTemplateFile](t, resp)
+	if written.SourcePath != ".zennotes/templates/r-union-hebdo.md" || written.Raw != raw {
+		t.Fatalf("written = %+v", written)
+	}
+	if body, err := os.ReadFile(filepath.Join(root, ".zennotes", "templates", "r-union-hebdo.md")); err != nil || string(body) != raw {
+		t.Fatalf("file on disk: %q (%v)", body, err)
+	}
+
+	files := decodeBody[[]vault.CustomTemplateFile](t, templateRequest(t, http.MethodGet, server.URL+"/api/templates", nil, templateTestToken))
+	if len(files) != 1 || files[0].SourcePath != written.SourcePath || files[0].Raw != raw {
+		t.Fatalf("list = %+v", files)
+	}
+
+	read := decodeBody[map[string]string](t, templateRequest(t, http.MethodGet, server.URL+"/api/templates/read?path="+written.SourcePath, nil, templateTestToken))
+	if read["raw"] != raw {
+		t.Fatalf("read = %+v", read)
+	}
+
+	renamed := decodeBody[vault.CustomTemplateFile](t, templateRequest(t, http.MethodPost, server.URL+"/api/templates/write", map[string]string{
+		"slug": "weekly", "raw": raw + "\nmore", "previousSourcePath": written.SourcePath,
+	}, templateTestToken))
+	if renamed.SourcePath != ".zennotes/templates/weekly.md" {
+		t.Fatalf("renamed = %+v", renamed)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".zennotes", "templates", "r-union-hebdo.md")); !os.IsNotExist(err) {
+		t.Fatalf("rename left the old file: %v", err)
+	}
+
+	del := templateRequest(t, http.MethodPost, server.URL+"/api/templates/delete", map[string]string{"sourcePath": renamed.SourcePath}, templateTestToken)
+	del.Body.Close()
+	if del.StatusCode != http.StatusOK {
+		t.Fatalf("delete: %d", del.StatusCode)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".zennotes", "templates", "weekly.md")); !os.IsNotExist(err) {
+		t.Fatalf("delete left the file: %v", err)
+	}
+	gone := templateRequest(t, http.MethodGet, server.URL+"/api/templates/read?path="+renamed.SourcePath, nil, templateTestToken)
+	gone.Body.Close()
+	if gone.StatusCode != http.StatusNotFound {
+		t.Fatalf("read after delete: %d, want 404", gone.StatusCode)
+	}
+}
+
+func TestTemplateRoutesRejectUnsafePaths(t *testing.T) {
+	server, root := templateTestServer(t, 10<<20)
+	for _, path := range []string{
+		"../../etc/passwd",
+		".zennotes/templates/../../inbox/Note.md",
+		".zennotes/templates/sub/dir.md",
+		".zennotes/templates/not-markdown.txt",
+		"inbox/Note.md",
+	} {
+		resp := templateRequest(t, http.MethodGet, server.URL+"/api/templates/read?path="+path, nil, templateTestToken)
+		resp.Body.Close()
+		if resp.StatusCode != http.StatusBadRequest {
+			t.Errorf("read %q: %d, want 400", path, resp.StatusCode)
+		}
+		del := templateRequest(t, http.MethodPost, server.URL+"/api/templates/delete", map[string]string{"sourcePath": path}, templateTestToken)
+		del.Body.Close()
+		if del.StatusCode != http.StatusBadRequest {
+			t.Errorf("delete %q: %d, want 400", path, del.StatusCode)
+		}
+	}
+	if _, err := os.Stat(filepath.Join(root, "inbox", "Note.md")); err != nil {
+		t.Fatalf("a template delete reached a note: %v", err)
+	}
+}
+
+func TestTemplateWriteRespectsNoteSizeLimit(t *testing.T) {
+	server, root := templateTestServer(t, 64)
+	// Past the note limit but inside the JSON envelope allowance: the explicit
+	// check answers.
+	resp := templateRequest(t, http.MethodPost, server.URL+"/api/templates/write", map[string]string{
+		"slug": "big", "raw": strings.Repeat("x", 200),
+	}, templateTestToken)
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusRequestEntityTooLarge {
+		t.Fatalf("200-byte template with a 64-byte limit: %d, want 413", resp.StatusCode)
+	}
+	// Past the reader itself.
+	resp = templateRequest(t, http.MethodPost, server.URL+"/api/templates/write", map[string]string{
+		"slug": "huge", "raw": strings.Repeat("x", 70<<10),
+	}, templateTestToken)
+	resp.Body.Close()
+	if resp.StatusCode != http.StatusRequestEntityTooLarge {
+		t.Fatalf("70 KiB template with a 64-byte limit: %d, want 413", resp.StatusCode)
+	}
+	if entries, _ := os.ReadDir(filepath.Join(root, ".zennotes", "templates")); len(entries) != 0 {
+		t.Fatalf("rejected writes left files: %v", entries)
+	}
+	ok := templateRequest(t, http.MethodPost, server.URL+"/api/templates/write", map[string]string{
+		"slug": "small", "raw": "fits",
+	}, templateTestToken)
+	ok.Body.Close()
+	if ok.StatusCode != http.StatusOK {
+		t.Fatalf("small template: %d", ok.StatusCode)
+	}
+}
+
+func TestCapabilitiesAdvertiseCustomTemplateSupport(t *testing.T) {
+	root := t.TempDir()
+	server, _ := newTestServer(t, config.Config{
+		VaultPath:        root,
+		DefaultVaultPath: root,
+		Bind:             "127.0.0.1:7878",
+		BrowseRoots:      []string{root},
+	})
+	resp, err := http.Get(server.URL + "/api/capabilities")
+	if err != nil {
+		t.Fatal(err)
+	}
+	caps := decodeBody[map[string]any](t, resp)
+	if caps["supportsCustomTemplates"] != true {
+		t.Fatalf("supportsCustomTemplates = %v, want true", caps["supportsCustomTemplates"])
+	}
+}
diff --git a/apps/server/internal/vault/templates.go b/apps/server/internal/vault/templates.go
new file mode 100644
index 00000000..0cf9c752
--- /dev/null
+++ b/apps/server/internal/vault/templates.go
@@ -0,0 +1,229 @@
+package vault
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Custom-template file I/O for a vault served over HTTP. Templates are plain
+// `.md` files in the flat `.zennotes/templates/` directory, and this layer is
+// deliberately parse-free: it moves raw bytes, and the client owns the
+// frontmatter format (`packages/shared-domain/src/template-files.ts`).
+//
+// SYNCED COPY: the filename rules here (safeTemplateSlug, uniqueTemplateSlug,
+// resolveTemplatePath) mirror `apps/desktop/src/main/templates.ts` byte for
+// byte. A vault served remotely today is opened locally tomorrow, and a
+// template's id is `custom:<filename stem>`, so both sides must land the same
+// bytes on the same filename. Change one, change both.
+
+const templatesRelDir = ".zennotes/templates"
+
+var ErrInvalidTemplate = errors.New("invalid template request")
+
+// CustomTemplateFile matches bridge-contract's CustomTemplateFile.
+type CustomTemplateFile struct {
+	SourcePath string `json:"sourcePath"`
+	Raw        string `json:"raw"`
+}
+
+// WriteTemplateInput matches bridge-contract's WriteTemplateInput.
+type WriteTemplateInput struct {
+	Slug               string `json:"slug"`
+	Raw                string `json:"raw"`
+	PreviousSourcePath string `json:"previousSourcePath,omitempty"`
+}
+
+func templateDir(root string) string {
+	return filepath.Join(root, ".zennotes", "templates")
+}
+
+func templateSourcePath(name string) string {
+	return templatesRelDir + "/" + name
+}
+
+func templateFilenameStem(sourcePath string) string {
+	name := sourcePath[strings.LastIndex(sourcePath, "/")+1:]
+	if strings.EqualFold(filepath.Ext(name), ".md") {
+		return name[:len(name)-len(".md")]
+	}
+	return name
+}
+
+// safeTemplateSlug keeps lowercase letters, digits and dashes; every run of
+// anything else becomes one dash, and leading and trailing dashes go. Dashes
+// that were already there stay as typed (`a--b` remains `a--b`): that is what
+// the desktop does, and the renderer's slugifyTemplateName has collapsed them
+// before the request is made anyway.
+func safeTemplateSlug(slug string) string {
+	var out strings.Builder
+	inRun := false
+	for _, r := range strings.ToLower(slug) {
+		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '-' {
+			if inRun {
+				out.WriteByte('-')
+				inRun = false
+			}
+			out.WriteRune(r)
+			continue
+		}
+		inRun = true
+	}
+	if inRun {
+		out.WriteByte('-')
+	}
+	cleaned := strings.Trim(out.String(), "-")
+	if cleaned == "" {
+		return "template"
+	}
+	return cleaned
+}
+
+// resolveTemplatePath turns a vault-relative sourcePath into an absolute one,
+// refusing anything outside the flat templates directory (no traversal, no
+// subdirectories, no symlinked escape) and anything that is not a `.md` file.
+func (v *Vault) resolveTemplatePath(sourcePath string) (string, error) {
+	abs, err := SafeJoin(v.root, sourcePath)
+	if err != nil {
+		return "", err
+	}
+	rel, err := filepath.Rel(templateDir(v.root), abs)
+	if err != nil || rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || strings.Contains(rel, string(filepath.Separator)) {
+		return "", fmt.Errorf("%w: refusing template path outside templates dir: %s", ErrInvalidTemplate, sourcePath)
+	}
+	if !strings.EqualFold(filepath.Ext(rel), ".md") {
+		return "", fmt.Errorf("%w: template path must be a .md file: %s", ErrInvalidTemplate, sourcePath)
+	}
+	return abs, nil
+}
+
+// uniqueTemplateSlug picks a free slug. Editing the same file keeps its slug
+// (the write lands in place); otherwise the slug is de-duplicated against the
+// files already there (adr, adr-2, adr-3, ...).
+func uniqueTemplateSlug(dir, base, previousSourcePath string) string {
+	prevStem := ""
+	if previousSourcePath != "" {
+		prevStem = templateFilenameStem(previousSourcePath)
+	}
+	candidate := base
+	for n := 2; ; n++ {
+		if candidate == prevStem {
+			return candidate
+		}
+		if _, err := os.Lstat(filepath.Join(dir, candidate+".md")); errors.Is(err, os.ErrNotExist) {
+			return candidate
+		}
+		candidate = fmt.Sprintf("%s-%d", base, n)
+	}
+}
+
+// ListTemplates returns every custom template with its raw bytes. A vault
+// without a templates directory has no templates rather than an error, and
+// an unreadable file is skipped, as the desktop does.
+func (v *Vault) ListTemplates() ([]CustomTemplateFile, error) {
+	v.mu.RLock()
+	defer v.mu.RUnlock()
+	entries, err := os.ReadDir(templateDir(v.root))
+	if errors.Is(err, os.ErrNotExist) {
+		return []CustomTemplateFile{}, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	out := make([]CustomTemplateFile, 0, len(entries))
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || strings.HasPrefix(name, ".") || !strings.EqualFold(filepath.Ext(name), ".md") {
+			continue
+		}
+		sourcePath := templateSourcePath(name)
+		abs, err := v.resolveTemplatePath(sourcePath)
+		if err != nil {
+			continue
+		}
+		raw, err := os.ReadFile(abs)
+		if err != nil {
+			continue
+		}
+		out = append(out, CustomTemplateFile{SourcePath: sourcePath, Raw: string(raw)})
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i].SourcePath < out[j].SourcePath })
+	return out, nil
+}
+
+func (v *Vault) ReadTemplate(sourcePath string) (string, error) {
+	v.mu.RLock()
+	defer v.mu.RUnlock()
+	abs, err := v.resolveTemplatePath(sourcePath)
+	if err != nil {
+		return "", err
+	}
+	raw, err := os.ReadFile(abs)
+	if err != nil {
+		return "", err
+	}
+	return string(raw), nil
+}
+
+// WriteTemplate saves a template under a slug derived from the request, and
+// removes the file it replaces when an edit changed the slug. The previous
+// path is validated before anything is written, so a bad one cannot leave a
+// stray new file behind.
+func (v *Vault) WriteTemplate(input WriteTemplateInput) (CustomTemplateFile, error) {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+	var previous string
+	if input.PreviousSourcePath != "" {
+		abs, err := v.resolveTemplatePath(input.PreviousSourcePath)
+		if err != nil {
+			return CustomTemplateFile{}, err
+		}
+		previous = abs
+	}
+	dir := templateDir(v.root)
+	slug := uniqueTemplateSlug(dir, safeTemplateSlug(input.Slug), input.PreviousSourcePath)
+	sourcePath := templateSourcePath(slug + ".md")
+	abs, err := v.resolveTemplatePath(sourcePath)
+	if err != nil {
+		return CustomTemplateFile{}, err
+	}
+	if err := writeFileAtomic(abs, []byte(input.Raw), v.fileMode, v.dirMode); err != nil {
+		return CustomTemplateFile{}, err
+	}
+	if previous != "" && previous != abs {
+		// On a case-insensitive filesystem two differently-cased paths can name
+		// the SAME file, and writeFileAtomic just landed the new content on it;
+		// a spelling compare would then delete the template that was just
+		// saved. Compare file identity, not path strings.
+		sameFile := false
+		if prevInfo, statErr := os.Stat(previous); statErr == nil {
+			if newInfo, statErr := os.Stat(abs); statErr == nil && os.SameFile(prevInfo, newInfo) {
+				sameFile = true
+			}
+		}
+		if !sameFile {
+			if err := os.Remove(previous); err != nil && !errors.Is(err, os.ErrNotExist) {
+				return CustomTemplateFile{}, err
+			}
+		}
+	}
+	return CustomTemplateFile{SourcePath: sourcePath, Raw: input.Raw}, nil
+}
+
+// DeleteTemplate removes a template; a file that is already gone is a
+// success, as it is on the desktop.
+func (v *Vault) DeleteTemplate(sourcePath string) error {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+	abs, err := v.resolveTemplatePath(sourcePath)
+	if err != nil {
+		return err
+	}
+	if err := os.Remove(abs); err != nil && !errors.Is(err, os.ErrNotExist) {
+		return err
+	}
+	return nil
+}
diff --git a/apps/server/internal/vault/templates_test.go b/apps/server/internal/vault/templates_test.go
new file mode 100644
index 00000000..d6bff8af
--- /dev/null
+++ b/apps/server/internal/vault/templates_test.go
@@ -0,0 +1,227 @@
+package vault
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func templateTestVault(t *testing.T) (*Vault, string) {
+	t.Helper()
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "inbox"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "inbox", "A.md"), []byte("# A\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	v, err := New(root, Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return v, root
+}
+
+// The slug rules are a synced copy of the desktop module; these cases are the
+// desktop's behaviour, spelled out so a drift on either side fails here.
+func TestSafeTemplateSlugMirrorsDesktop(t *testing.T) {
+	cases := map[string]string{
+		"Réunion Hebdo!":     "r-union-hebdo",
+		"  ADR  ":            "adr",
+		"a--b":               "a--b",
+		"a - b":              "a---b",
+		"Weekly Review 2026": "weekly-review-2026",
+		"UPPER_case.name":    "upper-case-name",
+		"":                   "template",
+		"---":                "template",
+		"!!!":                "template",
+	}
+	for input, want := range cases {
+		if got := safeTemplateSlug(input); got != want {
+			t.Errorf("safeTemplateSlug(%q) = %q, want %q", input, got, want)
+		}
+	}
+	stems := map[string]string{
+		".zennotes/templates/adr.md": "adr",
+		".zennotes/templates/adr.MD": "adr",
+		".zennotes/templates/x.y.md": "x.y",
+		"adr":                        "adr",
+	}
+	for input, want := range stems {
+		if got := templateFilenameStem(input); got != want {
+			t.Errorf("templateFilenameStem(%q) = %q, want %q", input, got, want)
+		}
+	}
+}
+
+func TestWriteTemplateDedupesAndKeepsSlugOnEdit(t *testing.T) {
+	v, root := templateTestVault(t)
+
+	first, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v1"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.SourcePath != ".zennotes/templates/adr.md" {
+		t.Fatalf("first sourcePath = %q", first.SourcePath)
+	}
+	second, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v2"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if second.SourcePath != ".zennotes/templates/adr-2.md" {
+		t.Fatalf("duplicate slug landed on %q, want adr-2.md", second.SourcePath)
+	}
+
+	edited, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v1 edited", PreviousSourcePath: first.SourcePath})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if edited.SourcePath != first.SourcePath {
+		t.Fatalf("editing in place moved the file to %q", edited.SourcePath)
+	}
+	body, err := os.ReadFile(filepath.Join(root, ".zennotes", "templates", "adr.md"))
+	if err != nil || string(body) != "v1 edited" {
+		t.Fatalf("edit did not land: %q (%v)", body, err)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".zennotes", "templates", "adr-3.md")); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("editing in place must not create adr-3.md: %v", err)
+	}
+
+	files, err := v.ListTemplates()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(files) != 2 || files[0].SourcePath != ".zennotes/templates/adr-2.md" || files[1].SourcePath != ".zennotes/templates/adr.md" {
+		t.Fatalf("list = %+v", files)
+	}
+	entries, _ := os.ReadDir(filepath.Join(root, ".zennotes", "templates"))
+	for _, entry := range entries {
+		if strings.HasSuffix(entry.Name(), ".tmp") {
+			t.Fatalf("atomic write left its scratch file behind: %s", entry.Name())
+		}
+	}
+}
+
+func TestWriteTemplateRenameRemovesPrevious(t *testing.T) {
+	v, root := templateTestVault(t)
+	if _, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v1"}); err != nil {
+		t.Fatal(err)
+	}
+	renamed, err := v.WriteTemplate(WriteTemplateInput{Slug: "Decision Record", Raw: "v2", PreviousSourcePath: ".zennotes/templates/adr.md"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if renamed.SourcePath != ".zennotes/templates/decision-record.md" {
+		t.Fatalf("renamed sourcePath = %q", renamed.SourcePath)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".zennotes", "templates", "adr.md")); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("previous file should be gone after the rename: %v", err)
+	}
+	raw, err := v.ReadTemplate(renamed.SourcePath)
+	if err != nil || raw != "v2" {
+		t.Fatalf("read after rename = %q (%v)", raw, err)
+	}
+	// Deleting twice is fine: the desktop's rm --force semantics.
+	if err := v.DeleteTemplate(renamed.SourcePath); err != nil {
+		t.Fatal(err)
+	}
+	if err := v.DeleteTemplate(renamed.SourcePath); err != nil {
+		t.Fatalf("second delete should be a no-op, got %v", err)
+	}
+	if _, err := v.ReadTemplate(renamed.SourcePath); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("read after delete = %v, want ErrNotExist", err)
+	}
+}
+
+func TestTemplatePathsMustStayInsideTemplatesDir(t *testing.T) {
+	v, root := templateTestVault(t)
+	for _, bad := range []string{
+		"../../etc/passwd",
+		"/etc/passwd",
+		".zennotes/templates/../../inbox/A.md",
+		".zennotes/templates/sub/dir.md",
+		".zennotes/templates/not-markdown.txt",
+		".zennotes/templates",
+		"inbox/A.md",
+		"",
+	} {
+		if _, err := v.ReadTemplate(bad); !errors.Is(err, ErrInvalidTemplate) && !errors.Is(err, ErrPathEscape) {
+			t.Errorf("ReadTemplate(%q) = %v, want an invalid-path error", bad, err)
+		}
+		if err := v.DeleteTemplate(bad); !errors.Is(err, ErrInvalidTemplate) && !errors.Is(err, ErrPathEscape) {
+			t.Errorf("DeleteTemplate(%q) = %v, want an invalid-path error", bad, err)
+		}
+	}
+	// A template delete can never reach a note.
+	if _, err := os.Stat(filepath.Join(root, "inbox", "A.md")); err != nil {
+		t.Fatalf("note went missing: %v", err)
+	}
+	// A bad previous path fails before anything is written.
+	if _, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v1", PreviousSourcePath: "inbox/A.md"}); !errors.Is(err, ErrInvalidTemplate) {
+		t.Fatalf("write with a note as previous = %v, want ErrInvalidTemplate", err)
+	}
+	if _, err := os.Stat(filepath.Join(root, ".zennotes", "templates", "adr.md")); !errors.Is(err, os.ErrNotExist) {
+		t.Fatalf("rejected write left a file behind: %v", err)
+	}
+}
+
+func TestTemplatesRejectSymlinkedTemplatesDir(t *testing.T) {
+	v, root := templateTestVault(t)
+	external := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, ".zennotes"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(external, filepath.Join(root, ".zennotes", "templates")); err != nil {
+		t.Skipf("symlinks unavailable: %v", err)
+	}
+	if _, err := v.WriteTemplate(WriteTemplateInput{Slug: "adr", Raw: "v1"}); !errors.Is(err, ErrPathEscape) {
+		t.Fatalf("write through a symlinked templates dir = %v, want ErrPathEscape", err)
+	}
+	if entries, _ := os.ReadDir(external); len(entries) != 0 {
+		t.Fatalf("write escaped into %s: %v", external, entries)
+	}
+	if err := os.WriteFile(filepath.Join(external, "leak.md"), []byte("outside"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	files, err := v.ListTemplates()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(files) != 0 {
+		t.Fatalf("list followed the symlink: %+v", files)
+	}
+}
+
+func TestListTemplatesSkipsDotfilesDirsAndNonMarkdown(t *testing.T) {
+	v, root := templateTestVault(t)
+	dir := filepath.Join(root, ".zennotes", "templates")
+	if err := os.MkdirAll(filepath.Join(dir, "nested"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	for name, body := range map[string]string{
+		"adr.md":      "adr",
+		"Weekly.MD":   "weekly",
+		".draft.md":   "hidden",
+		"notes.txt":   "text",
+		"nested/x.md": "nested",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	files, err := v.ListTemplates()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(files) != 2 || files[0].SourcePath != ".zennotes/templates/Weekly.MD" || files[0].Raw != "weekly" || files[1].SourcePath != ".zennotes/templates/adr.md" {
+		t.Fatalf("list = %+v", files)
+	}
+	empty, root2 := templateTestVault(t)
+	_ = root2
+	files, err = empty.ListTemplates()
+	if err != nil || len(files) != 0 {
+		t.Fatalf("vault without a templates dir: %+v, %v", files, err)
+	}
+}
diff --git a/apps/server/internal/vault/types.go b/apps/server/internal/vault/types.go
index 0c1492f7..79bfde3c 100644
--- a/apps/server/internal/vault/types.go
+++ b/apps/server/internal/vault/types.go
@@ -352,6 +352,11 @@ type NoteComment struct {
 	CreatedAt   int64  `json:"createdAt"`
 	UpdatedAt   int64  `json:"updatedAt"`
 	ResolvedAt  *int64 `json:"resolvedAt"`
+	// Author is who wrote it: empty for the vault's owner, an assistant's
+	// name otherwise. ParentID threads a reply under a top-level comment.
+	// Both mirror shared-domain/note-comments.ts (#738).
+	Author   string `json:"author,omitempty"`
+	ParentID string `json:"parentId,omitempty"`
 }
 
 // FolderEntry — mirrors shared/ipc.ts FolderEntry.
diff --git a/apps/server/internal/vault/vault.go b/apps/server/internal/vault/vault.go
index f13bf06e..35c98fa0 100644
--- a/apps/server/internal/vault/vault.go
+++ b/apps/server/internal/vault/vault.go
@@ -1628,9 +1628,21 @@ func normalizeComment(input NoteComment, notePath string) (NoteComment, bool) {
 		CreatedAt:   createdAt,
 		UpdatedAt:   updatedAt,
 		ResolvedAt:  input.ResolvedAt,
+		Author:      normalizeCommentAuthor(input.Author),
+		ParentID:    strings.TrimSpace(input.ParentID),
 	}, true
 }
 
+// normalizeCommentAuthor collapses whitespace and caps the name, mirroring
+// normalizeCommentAuthor in shared-domain/note-comments.ts.
+func normalizeCommentAuthor(raw string) string {
+	author := strings.Join(strings.Fields(raw), " ")
+	if len(author) > 80 {
+		author = author[:80]
+	}
+	return author
+}
+
 func normalizeComments(inputs []NoteComment, notePath string) []NoteComment {
 	out := make([]NoteComment, 0, len(inputs))
 	seen := map[string]struct{}{}
@@ -1651,6 +1663,20 @@ func normalizeComments(inputs []NoteComment, notePath string) []NoteComment {
 		}
 		return out[i].CreatedAt < out[j].CreatedAt
 	})
+	// A reply whose parent is gone (or is itself) stays as a comment of its
+	// own rather than vanishing from the thread view.
+	ids := make(map[string]struct{}, len(out))
+	for _, comment := range out {
+		ids[comment.ID] = struct{}{}
+	}
+	for i := range out {
+		if out[i].ParentID == "" {
+			continue
+		}
+		if _, ok := ids[out[i].ParentID]; !ok || out[i].ParentID == out[i].ID {
+			out[i].ParentID = ""
+		}
+	}
 	return out
 }
 
diff --git a/apps/server/internal/vault/vault_test.go b/apps/server/internal/vault/vault_test.go
index 12193675..0dc1e7cf 100644
--- a/apps/server/internal/vault/vault_test.go
+++ b/apps/server/internal/vault/vault_test.go
@@ -1289,3 +1289,39 @@ func TestHarperSettingsRoundTripAndNormalize(t *testing.T) {
 		t.Errorf("empty harper block should be dropped, got %+v", cleared.Harper)
 	}
 }
+
+func TestNoteCommentsKeepAuthorAndThreadReplies(t *testing.T) {
+	root := t.TempDir()
+	v, err := New(root, Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	meta, err := v.WriteNote("inbox/Reviewed.md", "line one\nline two\nline three")
+	if err != nil {
+		t.Fatalf("write note: %v", err)
+	}
+	written, err := v.WriteNoteComments(meta.Path, []NoteComment{
+		{ID: "c1", Body: "Is this right?", CreatedAt: 1, UpdatedAt: 1},
+		{ID: "c2", Body: "Yes, see line 3.", CreatedAt: 2, UpdatedAt: 2, Author: "  Claude   Code ", ParentID: " c1 "},
+		{ID: "c3", Body: "orphan", CreatedAt: 3, UpdatedAt: 3, ParentID: "missing"},
+	})
+	if err != nil {
+		t.Fatalf("write comments: %v", err)
+	}
+	if len(written) != 3 {
+		t.Fatalf("expected 3 comments, got %d", len(written))
+	}
+	read, err := v.ReadNoteComments(meta.Path)
+	if err != nil {
+		t.Fatalf("read comments: %v", err)
+	}
+	if read[1].Author != "Claude Code" || read[1].ParentID != "c1" {
+		t.Fatalf("reply lost its author or parent: %#v", read[1])
+	}
+	if read[0].Author != "" || read[0].ParentID != "" {
+		t.Fatalf("top-level comment gained fields: %#v", read[0])
+	}
+	if read[2].ParentID != "" {
+		t.Fatalf("orphan reply kept a missing parent: %#v", read[2])
+	}
+}
diff --git a/apps/server/internal/watcher/watcher.go b/apps/server/internal/watcher/watcher.go
index 4b4ed1e2..64c56371 100644
--- a/apps/server/internal/watcher/watcher.go
+++ b/apps/server/internal/watcher/watcher.go
@@ -17,6 +17,7 @@ const (
 	vaultSettingsFilePath = ".zennotes/vault.json"
 	noteCommentsPrefix    = ".zennotes/comments/"
 	noteCommentsSuffix    = ".comments.json"
+	templatesPrefix       = ".zennotes/templates/"
 )
 
 // Watcher recursively watches the vault root and fans out change
@@ -242,6 +243,47 @@ func (w *Watcher) commentsNotePath(absPath string) (string, bool) {
 	return strings.TrimSuffix(strings.TrimPrefix(rel, noteCommentsPrefix), noteCommentsSuffix), true
 }
 
+// templatePath reports whether the path is a custom template: a `.md` file
+// directly inside .zennotes/templates/, the flat directory the template
+// routes serve. Dotfiles and nested paths are not templates there either.
+func (w *Watcher) templatePath(absPath string) (string, bool) {
+	rel := w.relativePath(absPath)
+	if !strings.HasPrefix(rel, templatesPrefix) {
+		return "", false
+	}
+	name := strings.TrimPrefix(rel, templatesPrefix)
+	if name == "" || strings.Contains(name, "/") || strings.HasPrefix(name, ".") || !strings.EqualFold(filepath.Ext(name), ".md") {
+		return "", false
+	}
+	return rel, true
+}
+
+// watchSubdirs adds the directories already inside a directory that just
+// appeared. A tree that arrives in one go (mkdir -p, or a template write
+// creating .zennotes/templates/ in a vault that had no .zennotes/ yet) raises
+// one Create for the top; its children were created before that watch
+// existed, so without this walk they would stay unwatched until a restart.
+func (w *Watcher) watchSubdirs(dir string) {
+	_ = filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+		if err != nil || path == dir || !d.IsDir() {
+			return nil
+		}
+		name := d.Name()
+		if strings.HasPrefix(name, ".") && name != internalVaultDir {
+			return filepath.SkipDir
+		}
+		if _, ok := w.dirs[path]; ok {
+			return nil
+		}
+		if addErr := w.fs.Add(path); addErr != nil {
+			log.Printf("watcher: cannot watch new directory %s: %v", path, addErr)
+		}
+		w.dirs[path] = struct{}{}
+		w.broadcastFolder(path, "add")
+		return nil
+	})
+}
+
 func (w *Watcher) handle(ev fsnotify.Event) {
 	base := filepath.Base(ev.Name)
 	// The scratch file every atomic write renames from. Its create/write/rename
@@ -263,6 +305,7 @@ func (w *Watcher) handle(ev fsnotify.Event) {
 			// An empty folder produces no note event, so clients would never
 			// learn about it until a manual refresh. Surface it explicitly.
 			w.broadcastFolder(ev.Name, "add")
+			w.watchSubdirs(ev.Name)
 		}
 		return
 	}
@@ -310,6 +353,21 @@ func (w *Watcher) handle(ev fsnotify.Event) {
 		})
 		return
 	}
+	if templatePath, ok := w.templatePath(ev.Name); ok {
+		kind := eventKind(ev, statErr == nil)
+		if kind == "" {
+			return
+		}
+		// A template is not a note: its own scope keeps clients from
+		// re-listing the note tree and rescanning tasks for every save.
+		w.broadcast(vault.ChangeEvent{
+			Kind:   kind,
+			Path:   templatePath,
+			Folder: vault.FolderInbox,
+			Scope:  "templates",
+		})
+		return
+	}
 	if strings.HasPrefix(relPosix, ".") || strings.Contains(relPosix, "/.") {
 		return
 	}
diff --git a/apps/server/internal/watcher/watcher_test.go b/apps/server/internal/watcher/watcher_test.go
index 7f9f415f..03ecd1ef 100644
--- a/apps/server/internal/watcher/watcher_test.go
+++ b/apps/server/internal/watcher/watcher_test.go
@@ -315,3 +315,80 @@ func TestWatcherDoesNotReportAReplacedNoteAsDeleted(t *testing.T) {
 		t.Fatalf("deleted note event = %+v, want unlink", ev)
 	}
 }
+
+func TestWatcherSurfacesTemplateChangesWithOwnScope(t *testing.T) {
+	root := t.TempDir()
+	w := newTestWatcher(t, root)
+	ch, unsub := w.Subscribe()
+	defer unsub()
+
+	dir := filepath.Join(root, internalVaultDir, "templates")
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	file := filepath.Join(dir, "adr.md")
+	if err := os.WriteFile(file, []byte("---\nname: ADR\n---\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	w.handle(fsnotify.Event{Name: file, Op: fsnotify.Write})
+	ev := recvChange(t, ch)
+	if ev.Scope != "templates" || ev.Kind != "change" || ev.Path != ".zennotes/templates/adr.md" {
+		t.Fatalf("template write event = %+v", ev)
+	}
+
+	if err := os.Remove(file); err != nil {
+		t.Fatal(err)
+	}
+	w.handle(fsnotify.Event{Name: file, Op: fsnotify.Remove})
+	ev = recvChange(t, ch)
+	if ev.Scope != "templates" || ev.Kind != "unlink" {
+		t.Fatalf("template remove event = %+v", ev)
+	}
+}
+
+func TestWatcherIgnoresNonTemplatesUnderTemplatesDir(t *testing.T) {
+	root := t.TempDir()
+	w := newTestWatcher(t, root)
+	ch, unsub := w.Subscribe()
+	defer unsub()
+
+	dir := filepath.Join(root, internalVaultDir, "templates")
+	if err := os.MkdirAll(filepath.Join(dir, "nested"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{".draft.md", "notes.txt", filepath.Join("nested", "x.md")} {
+		file := filepath.Join(dir, name)
+		if err := os.WriteFile(file, []byte("x"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		w.handle(fsnotify.Event{Name: file, Op: fsnotify.Write})
+	}
+	select {
+	case ev := <-ch:
+		t.Fatalf("unexpected event for a non-template: %+v", ev)
+	case <-time.After(100 * time.Millisecond):
+		// Expected: dotfiles, other extensions and nested paths are not templates.
+	}
+}
+
+func TestWatcherWatchesDirectoriesCreatedWithTheirParent(t *testing.T) {
+	root := t.TempDir()
+	w := newTestWatcher(t, root)
+	_, unsub := w.Subscribe()
+	defer unsub()
+
+	// .zennotes/ and .zennotes/templates/ arrive together (one MkdirAll); the
+	// watcher hears one Create for the parent.
+	internal := filepath.Join(root, internalVaultDir)
+	templates := filepath.Join(internal, "templates")
+	if err := os.MkdirAll(templates, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	w.handle(fsnotify.Event{Name: internal, Op: fsnotify.Create})
+	if _, ok := w.dirs[internal]; !ok {
+		t.Fatalf("parent directory not tracked")
+	}
+	if _, ok := w.dirs[templates]; !ok {
+		t.Fatalf("child directory created with its parent is not watched")
+	}
+}
diff --git a/apps/server/package.json b/apps/server/package.json
index 0ee99611..e7b2caea 100644
--- a/apps/server/package.json
+++ b/apps/server/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/server",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "scripts": {
     "dev": "node ../../tooling/scripts/run-go-server-dev.mjs",
     "prepare-web": "node ../../tooling/scripts/prepare-server-web-dist.mjs",
diff --git a/apps/web/package.json b/apps/web/package.json
index 8a975cac..50ae4206 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/web",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "type": "module",
   "description": "ZenNotes web client for self-hosted and hosted deployments",
   "homepage": "https://zennotes.org",
diff --git a/apps/web/src/bridge/http-bridge.ts b/apps/web/src/bridge/http-bridge.ts
index d6ff36f7..0d6e3410 100644
--- a/apps/web/src/bridge/http-bridge.ts
+++ b/apps/web/src/bridge/http-bridge.ts
@@ -814,23 +814,48 @@ async function deleteWorkflowRuns(workflowId: string): Promise<number> {
   })
 }
 
-// Custom templates require local-filesystem CRUD, which the web app does not
-// have (supportsCustomTemplates is false). Built-in templates still work since
-// they are renderer constants. List is empty; mutations are rejected.
-function listTemplates(): Promise<CustomTemplateFile[]> {
-  return Promise.resolve([])
+// Custom templates live in the vault's .zennotes/templates/, the same files
+// the desktop keeps for a local vault, served by the /templates routes since
+// server 2.46 (#723). An older server has none: the list is empty, Settings,
+// Templates stays read-only, and the built-in templates (renderer constants)
+// keep working. The request gate and the UI gate (getCapabilities below)
+// read the same cached fact.
+async function serverSupportsCustomTemplates(): Promise<boolean> {
+  const capabilities = lastServerCapabilities ?? (await getServerCapabilities())
+  return capabilities?.supportsCustomTemplates === true
+}
+
+async function requireServerTemplateSupport(): Promise<void> {
+  if (await serverSupportsCustomTemplates()) return
+  throw new Error(
+    'Custom templates need ZenNotes server 2.46 or later. Update the server and reload.'
+  )
 }
 
-function readTemplate(_sourcePath: string): Promise<string> {
-  return Promise.reject(new Error('Custom templates are unavailable on the web'))
+async function listTemplates(): Promise<CustomTemplateFile[]> {
+  if (!(await serverSupportsCustomTemplates())) return []
+  return jsonRequest<CustomTemplateFile[]>('/templates')
 }
 
-function writeTemplate(_input: WriteTemplateInput): Promise<CustomTemplateFile> {
-  return Promise.reject(new Error('Custom templates are unavailable on the web'))
+async function readTemplate(sourcePath: string): Promise<string> {
+  await requireServerTemplateSupport()
+  const result = await jsonRequest<{ raw: string }>(
+    `/templates/read?path=${encodeURIComponent(sourcePath)}`
+  )
+  return result.raw
+}
+
+async function writeTemplate(input: WriteTemplateInput): Promise<CustomTemplateFile> {
+  await requireServerTemplateSupport()
+  return jsonRequest<CustomTemplateFile>('/templates/write', {
+    method: 'POST',
+    body: input as unknown as Record<string, unknown>
+  })
 }
 
-function deleteTemplate(_sourcePath: string): Promise<void> {
-  return Promise.reject(new Error('Custom templates are unavailable on the web'))
+async function deleteTemplate(sourcePath: string): Promise<void> {
+  await requireServerTemplateSupport()
+  await jsonRequest('/templates/delete', { method: 'POST', body: { sourcePath } })
 }
 
 // --------------------------------------------------------------------
@@ -1426,13 +1451,15 @@ function clipboardReadText(): string {
 // --------------------------------------------------------------------
 
 export const httpBridge: ZenBridge = {
-  // Workflows are the one capability the SERVER decides; derive it from the
-  // cached /capabilities response instead of mutating the const in place, so
-  // the UI gate (this) and the request gate (serverSupportsWorkflows) can
-  // never disagree about the same fact.
+  // Workflows and custom templates are the capabilities the SERVER decides;
+  // derive them from the cached /capabilities response instead of mutating
+  // the const in place, so the UI gate (this) and the request gates
+  // (serverSupportsWorkflows, serverSupportsCustomTemplates) can never
+  // disagree about the same fact.
   getCapabilities: (): ZenCapabilities => ({
     ...WEB_CAPABILITIES,
-    supportsWorkflows: lastServerCapabilities?.supportsWorkflows === true
+    supportsWorkflows: lastServerCapabilities?.supportsWorkflows === true,
+    supportsCustomTemplates: lastServerCapabilities?.supportsCustomTemplates === true
   }),
   getAppInfo: (): ZenAppInfo => WEB_APP_INFO,
   platform,
diff --git a/docs/how-to/self-host-with-docker.md b/docs/how-to/self-host-with-docker.md
index 560d4e94..070e6ede 100644
--- a/docs/how-to/self-host-with-docker.md
+++ b/docs/how-to/self-host-with-docker.md
@@ -248,7 +248,8 @@ or via the orchestrator of your choice.
 - `ZENNOTES_BROWSE_ROOTS` — directories the server may consider as
   vault candidates. Anything outside is rejected.
 - `ZENNOTES_MAX_NOTE_BYTES` / `ZENNOTES_MAX_ASSET_BYTES` — per-request
-  byte caps for `/api/notes/write` and `/api/assets/upload`. Defaults
+  byte caps for `/api/notes/write` (and the workflow and template writes,
+  which are notes in waiting) and `/api/assets/upload`. Defaults
   10 MiB and 50 MiB.
 - `ZENNOTES_VAULT_FILE_MODE` / `ZENNOTES_VAULT_DIR_MODE` — octal mode
   for new files / directories. Defaults `0600` and `0700`.
diff --git a/docs/releases/v2.46.0/RELEASE_NOTES.md b/docs/releases/v2.46.0/RELEASE_NOTES.md
new file mode 100644
index 00000000..90e92477
--- /dev/null
+++ b/docs/releases/v2.46.0/RELEASE_NOTES.md
@@ -0,0 +1,72 @@
+ZenNotes 2.46.0: comment threads your assistant can join, a Kanban board per folder, unbind a shortcut outright, ignored keys for tap-hold remappers, saved Tasks filters, custom templates on remote vaults, and a calendar in the @ menu
+
+> Seven features and three fixes. Home-row-mods users can list the no-op key their remapper sends, and the app stops seeing it. The Kanban Folder board now groups by each note's folder, or by the children of one folder you name. Note comments thread and carry a name, and the MCP server can read, answer, open and resolve them, so a draft can be reviewed with Claude or Codex inside the Comments panel instead of a chat window. A shortcut can be removed instead of remapped onto some chord you would never press: every keymap row has an Unbind button, `:unbind action.id` does the same from the ex line, and `"action.id" = ""` under `[keymaps]` in config.toml carries it between machines. And custom templates now work in the self-hosted web client and on a desktop connected to a ZenNotes server, stored in the vault's `.zennotes/templates/` like everywhere else, with a change in one client showing up in the others. The `@` menu ends with Date…, a keyboard-first calendar for any day, next to Today, Yesterday, Tomorrow and Now. A Tasks filter can be saved under a name and recalled from a chip, `:filter <name>`, the F picker, or the command palette, with the list kept in config.toml as `[saved_filters]`. `zn create` and the MCP tools now file notes where the app does on a vault in root mode, display math renders inside callouts in both views, and Typst formulas are the size KaTeX's are.
+
+## ✨ New
+
+- **Ignore the no-op key a tap-hold remapper sends.** (#732, requested by @potter1402) Kanata, QMK and ZMK tap-hold layers emit a harmless extra key with every keystroke, on Linux usually the Katakana/Hiragana key, which reads as KanaMode. Neovim ignores keys it does not map; here every stray keydown reset a pending sequence, so `jk` never left insert mode and typed itself, `dd` deleted nothing, and a leader chord or hint mode died halfway. Settings → Keymap gains an **Ignored keys** row: press Record a key, then the no-op, and it is listed by name (its physical code when the layout reports Unidentified). From then on the app never sees it, in the editor, the panels, the hints and the shortcuts alike. `:ignorekey <key>` adds one from the ex line (bare, it opens the page), and `ignored_keys = ["KanaMode"]` under `[editor]` in config.toml is the portable form.
+
+  How to test locally: set `insert_escape = "jk"` under `[vim]` in a scratch config.toml, open a note, enter insert mode and type `j`, press the Katakana/Hiragana key (or any key you can spare, such as F24), then `k`. Before: the editor stays in insert mode with `jk` typed. Record that key under Settings → Keymap → Ignored keys and repeat: `jk` leaves insert mode, `d` <no-op> `d` deletes the line, and config.toml has `ignored_keys = ["KanaMode"]`.
+
+- **The Kanban Folder board groups by each note's folder, or by one folder's children.** (#730, requested by @andradejoelwp) "Group by: Folder" grouped by the four built-in folders, so a vault organised as `Projects/<name>/…` got one column holding everything plus an empty Quick, and people kept a hand-maintained `@status` token per task to get project columns. The board now gives every folder that holds tasks its own column (the Inbox root, `Projects/alpha`, `Areas`, Quick Notes), system folders first and subfolders alphabetical, with no empty columns. Point it at one folder and its children become the columns: `:folderroot Projects` on the board, the chip next to the group-by menu, Settings → Tasks → Folder board, or `kanban_folder_root = "Projects"` under `[view]` in config.toml. Deeper notes roll up to their child, notes in the root itself get the root's column, and notes outside it share an Other folders column. The root is saved per vault like the group-by and travels with your dotfiles. A remapped inbox and a root-mode vault classify the way the sidebar does, column titles and order still stick (ids are the note directories now), and folder columns stay read-only: moving the note is how a card changes column.
+
+  How to test locally: make a vault with `inbox/Projects/alpha/A.md`, `inbox/Projects/beta/meetings/K.md`, `inbox/Areas/Home.md` and `inbox/Plan.md`, each with a `- [ ]` task, then open Tasks, press `3`, and pick Folder. Before: Inbox and an empty Quick. After: Inbox, Areas, Projects/alpha, Projects/beta/meetings. Type `:folderroot Projects`: alpha and beta (the kickoff note rolled up) plus Other folders; config.toml has `kanban_folder_root = "Projects"`. Bare `:folderroot` returns to one column per folder.
+
+- **Discuss a note with an assistant through its comments.** (#738, requested by @gverger) Comments were flat and unsigned, and only the app could reach them, so reviewing a draft with an assistant meant pasting the note into a chat and carrying the answers back by hand. Now comments thread and carry a name: a reply files under the comment it answers, every entry shows who wrote it (You, or the assistant's name), and `a` on a thread (or the Reply arrow) opens a reply box with ⌘↵ to send. The MCP server gains four tools on the same sidecar: `list_comments` returns each thread with the anchored passage, the line it sits on in the note today, the author and the replies; `reply_to_comment` answers in a thread; `add_comment` opens a new one anchored to a passage copied from the note (the editor marks the text) or a note-level remark; `resolve_comment` closes a settled thread or reopens it. Replies are signed with the connected client's name (Claude Code, Claude, Codex), so its words and yours stay apart in the panel, and they arrive live through the vault watcher. The server instructions steer a model toward answering in the threads rather than editing the note body, and toward resolving only when you say so. `zn comment list|add|reply|resolve` does the same from a terminal, against a folder or a ZenNotes server. Everything stays in the `.comments.json` beside the note, so the web client and every MCP client see the same threads.
+
+  How to test locally: launch the built app as above, open a note, select a passage and press ⌘⌥M, type a comment, ⌘↵. In a terminal, `node apps/desktop/out/main/cli.js comment list inbox/<Note>.md` shows the thread with its line; `node apps/desktop/out/main/cli.js comment reply inbox/<Note>.md <id> "Answer" --author Claude` lands under it in the panel within a second, signed Claude. For the MCP path, connect Claude Code to `zn mcp` and ask it to review the note's comments. Before 2.46: comments have no author, no replies, and no tool reaches them.
+
+- **Unbind a shortcut instead of hiding it on an obscure key.** Settings, Keymap gains an **Unbind** button on every row, next to Change and Reset, and inside the recorder in place of the old Clear (Backspace still clears a recording). An unbound row reads **Unbound** with the Custom badge, Unbind greys out, and Reset brings the shipped default back. Nothing fires the action until it gets a key again: the shortcut, sequence, leader chord or editor chord simply stops existing, and that includes the leader and pane prefixes themselves. Everything that advertises keys follows suit: the which-key hints drop an unbound leader action, the command palette shows no chord for it, tooltips lose their parenthetical, and the in-app manual prints "Unbound" where the key used to be. An unbound action never counts as a conflict either, so another global shortcut may take the key it used to hold.
+- **`:unbind action.id` from the ex line.** In Vim mode, `:unbind global.toggleSidebar` removes the key and a toast names what it was (`Unbound Toggle sidebar (was ⌘1)`). Bare `:unbind`, or an id the catalog does not know, opens Settings on the Keymap page, which lists every action id, instead of guessing. Tab completes it in the `:` wildmenu like every other ex command.
+- **Portable through config.toml.** An unbind is written as `"global.commandPalette" = ""  # unbound` under `[keymaps]`, so it travels with your dotfiles, and a hand edit that sets any action to `""` applies live like every other config change. The generated reference block explains the convention above the table. TOML has no null, which is why the empty string is the spelling.
+
+  How to test locally: `cd apps/desktop && npx electron-vite build`, then from the repo root launch `apps/desktop/out/main/index.js` with `ZEN_PERF=1`, `ZENNOTES_USER_DATA_PATH` and `ZENNOTES_CONFIG_DIR` pointing at scratch folders. Press ⌘, (Ctrl+, on Windows and Linux), open Keymap, filter "command palette", press Unbind. Before: ⇧⌘P opens the palette. After: it does nothing, the row reads Unbound, and `config.toml` in the scratch config dir has `"global.commandPalette" = ""  # unbound`. Open a note, type `:unbind vim.leaderOpenBuffers`, press Space: the `o` entry is gone from the leader hints. Reset on the row brings ⇧⌘P back.
+
+- **Custom templates on remote vaults.** (#723, requested by @ajselzilic; the server and web groundwork was first explored by @flokchvtr on their web-feature-parity branch) Settings, Templates used to say that custom templates require a local vault in the web client and in desktop remote mode, because nothing served the vault's `.zennotes/templates/` over HTTP. The server now does, through four authenticated routes (list, read, write, delete) that mirror the desktop module byte for byte: the same slug rules, the same flat-directory and `.md`-only validation, the same `adr`, `adr-2` de-duplication and rename-removes-previous behaviour, atomic writes under the vault lock, and the configured note-size limit (a 413 past it). It advertises them as `supportsCustomTemplates`, and both the web client and the desktop remote client gate on that flag: an older server keeps the section read-only with a note naming the fix (update the server and reload, or reconnect the workspace), and the built-in templates keep working. Both watchers, the server's and the desktop's, now report `.zennotes/templates/` under a `templates` scope of their own, so a template saved in one client appears in the others without a reconnect, and a change-feed gap re-lists them as well. A local vault behaves exactly as before. Found on the way: the desktop read the remote workspace info before the connection existed and kept that copy, so it never learned what the server advertises; it re-reads once the vault is connected.
+
+  How to test locally: `cd apps/server && go build -o /tmp/zennotes-server ./cmd/zennotes-server`, then `ZENNOTES_CONFIG_PATH=/tmp/zs.json ZENNOTES_VAULT_PATH=/path/to/vault ZENNOTES_AUTH_TOKEN=tok ZENNOTES_BIND=127.0.0.1:7878 /tmp/zennotes-server`. Web: `npm run dev:web`, open http://localhost:5180, sign in with `tok`, Settings, Templates. Before: "Custom templates require a local vault". After: New template, and Save lands `/path/to/vault/.zennotes/templates/<slug>.md`; Edit renames the file, Delete removes it. Drop a `.md` with `name:` frontmatter into that folder from a terminal and it appears in the list on its own. Desktop: Settings, Vault, Connect to Remote Vault… with the same URL and token, then the same steps; against a server older than 2.46 the section says the server needs an update instead.
+
+- **Save a Tasks filter under a name, and get it back in one keystroke.** (#731, requested by @andradejoelwp) The filter box narrows the Tasks views to one project, one area, one context, but it was transient: the same query had to be retyped every time, which is why people stopped reaching for it and went looking for a grouping mode instead. Grouping has one axis; filters compose. A query worth typing twice is now saved under a name, as the `[saved_filters]` table in config.toml (`"Project alpha" = "@project:alpha"`, one line each), so it is diffable, syncs with the rest of your preferences, and a hand edit applies live. Recall is the point, so it is cheap from everywhere: a chip row under the Tasks header shows the saved filters in file order, a click applies one and a second click clears it; `:filter <name>` applies the saved query whenever the text is a saved name (any other text filters literally, as before); `F` in Vim mode opens a picker that narrows as you type; and the command palette lists every saved filter as "Tasks: name", which opens the view already filtered from any note. Saving is a chip too: an unsaved query shows **Save filter…**, which asks for a name and offers the existing ones for an overwrite; `:savefilter <name>` does the same from the ex line, `:delfilter <name>` forgets one, and a chip's right-click menu renames or deletes it. Names match regardless of case, edits keep the chip order, and the web client keeps its saved filters in the browser. With Vim mode off, the chips and the palette are the way in, as with every other single-key shortcut in the list.
+
+  How to test locally: launch the built app as above with a scratch config dir, then add to its `config.toml`: `[saved_filters]` and `"Project alpha" = "@project:alpha"`. Open Tasks: the chip is there, and clicking it puts `@project:alpha` in the filter box with the count chip reading `M of N`. Type `:f !high`, then `:savefilter Urgent`: a new chip appears and `config.toml` gains `Urgent = "!high"`. Append `"Blocked" = "@status:blocked"` to the file by hand: the chip appears without a restart. Open a note and press ⇧⌘P, type `Tasks: Blocked`, Enter: the Tasks view opens filtered. Before 2.46: none of this exists; the query is gone the moment you clear it.
+
+- **Pick any date from the `@` menu.** (#743, requested by @uNyanda) `@` offered Today, Yesterday, Tomorrow and Now; any other day meant typing it out by hand. The list now ends with **Date…** (`@date`, `@cal` and `@pick` narrow to it), and Enter on it opens a calendar on today with today's cell already focused, so nothing needs a Tab or a mouse: arrows move a day or a week, PageUp/PageDown change the month, with Shift the year, Home/End go to the ends of the week, and Enter inserts the ISO date (`2026-10-17`, the same shape the quick options write) exactly where the `@` stood, with focus back in the note. A digit pressed on the grid jumps to the text field, so a date can be typed outright, and the grid follows it as it takes shape; a day the month does not have (`2026-02-30`) is refused rather than rolled into March. With Vim mode on, h j k l move and t jumps back to today; with Vim mode off, letters stay inert, as they do in every list. Escape leaves the note as it was before the `@`. The quick options are unchanged, the calendar honours the week start from Settings, Calendar, and it works wherever the `@` menu does, the pinned reference pane and the web client included.
+
+  How to test locally: launch the built app as above, open a note, type `@`: the list ends with Date…. Type `date` and press Enter. Before: `@date` matched nothing and the menu just closed. After: a calendar opens on today; press → → ↓ then PageDown, then Enter, and the note reads the day nine days from today in next month, where the `@` was. Type `@date`, Enter, then `2027-03-14` and Enter: that date is inserted. Type `@date`, Enter, Escape: nothing is left behind.
+
+## 🐛 Fixes
+
+- **`zn create` and the MCP tools follow `primaryNotesLocation: root`.** (#745 by @diazkev314) With Settings, Vault set to "Vault root", `zn create` and the MCP `create_note` tool still wrote new notes into `inbox/`, and `vault_info` reported `inbox`, while `zn list` and `zn search` found root-level notes fine. The CLI and MCP decided the mode from the vault's layout first and only consulted `vault.json` when the layout was ambiguous, a rule written when root mode was new so that a vault switched in Settings but not yet migrated kept filing next to its old notes. The app does the opposite: an explicit setting is the answer and the layout is consulted only when `vault.json` leaves it unstated. With old notes still in `inbox/`, the two halves disagreed on the same vault. The file wins now on every side: an explicit `primaryNotesLocation` decides, and only a vault without one (or one a sandboxed process cannot read) is inferred from its layout, as the app infers it. Reads were already right and are unchanged.
+
+  How to test locally: make a scratch vault with `.zennotes/vault.json` containing `{"primaryNotesLocation": "root"}` and a leftover `inbox/Old.md`, then `node apps/desktop/out/main/cli.js create --vault /path/to/vault --title Test --body test --json`. Before: `"path": "inbox/Test.md"`. After: `"path": "Test.md"`, and the MCP `vault_info` tool reports `primaryNotesLocation: root` with `create_note` landing at the root too.
+
+- **Display math renders inside callouts, in the editor and the reading view.** (#748 by @OstrichDowneyJr) A `$$…$$` block inside an Obsidian-style callout stayed raw in the editor, because the `> ` in front of its fence counted as prose and the live preview only renders fences that own their line. In the reading view it was worse: the fence normalizer, after copying a canonical block that came earlier in the note, re-scanned that block's closing fence as an opener and paired it with the callout's `> $$`, which it took for content hugging a fence; the rewrite left a bare `$$` outside the quote, and with Typst selected that block swallowed everything after it into one failing formula (with KaTeX, into one long one). Both views now treat a fence inside a quote as a fence: the editor strips the quote markers from the formula and gives the rendered block the callout card's own classes so the card stays whole around it, and the normalizer looks past the markers, closes a block only at its own quote depth, and moves past a canonical block instead of re-reading its closing fence. A bare `$` on its own line is still not a display block in ZenNotes (with either engine, that is `$$`), but a span demoted to text inside a callout no longer carries the `> ` of every line it spans.
+
+  How to test locally: with Settings, Editor, Math renderer set to Typst, put `> [!note]`, `> $$`, `> x_1 = frac(det W_1, det A)`, `> $$` in a note under a normal `$$…$$` block. Before: the callout's formula stays raw in the editor, and in the reading view the callout loses its body while a red Typst error starting with `> x_1` swallows the rest of the note. After: both blocks render the same, inside the card in the editor and inside the callout in the reading view.
+
+- **Typst formulas are the size KaTeX formulas are, and their rules follow the text color.** (#746 by @cyperion) With Typst selected, inline math sat visibly smaller than the surrounding text, where KaTeX's fit. KaTeX draws Computer Modern at 1.21 times the text size, its own stylesheet's choice, because the family sits small on its em square and a plain 1em reads undersized next to prose. The Typst SVG was sized at that plain 1em, and New Computer Modern shares the metrics, so the same formula came out a fifth smaller: 52 px wide against KaTeX's 63 for `E = h nu` at the default text size. It is now sized with the same 1.21 factor in both the editor and the reading view, display blocks included, so switching engines no longer changes how big the math is. The Math size setting still scales on top. Found on the way: the recolor that makes Typst glyphs follow the theme only knew fills, so the rules a formula draws as shapes, a square root's bar and a fraction line, kept Typst's black stroke and vanished on a dark theme. Strokes are recolored now too.
+
+  How to test locally: write `The energy of a photon is $E = h nu$ here.` with Settings, Editor, Math renderer set to Typst, then compare against the KaTeX rendering of `$E = h\nu$`. Before: the Typst formula is noticeably smaller than the text, and on a dark theme the bar of `$$ sqrt(p^2 c^2 + m^2 c^4) $$` is black. After: the two engines render the formula at the same width, the text and the math read as one size, and the bar is the text color.
+
+## 🧰 For contributors
+
+- The convention lives in `packages/app-core/src/lib/keymaps.ts`: `UNBOUND_BINDING` (`""`), `isUnboundBinding`, `isKeymapUnbound`, and `UNBOUND_LABEL`. `getKeymapBinding` returns the empty string for an unbound action instead of falling back to the default, `normalizeKeymapOverrides` keeps blank strings, `matchesShortcutBinding` and `eventMatchesUserOverride` return false for them, and `getKeymapDisplay` returns `""` so a caller can leave the chip out; `labelWithShortcut` builds tooltips that never read "Go back ()". The store's `setKeymapBinding(id, null)` clears an override and `setKeymapBinding(id, "")` stores an unbind.
+- Any new consumer of a binding must treat `""` as "no key". CodeMirror files an empty key name without complaint and would run the command on a keydown whose `key` is empty, so editor keymap entries go through `keyBindingsFor` in `vim-half-page-keymap.ts`, which returns nothing for an unbound action; VimNav's leader and pane prefix tokens fall back to `UNBOUND_BINDING`, which never equals a token read off an event, rather than to `Space` and `Ctrl+W`; codemirror-vim mappings already dropped a null sequence.
+- `:unbind` is registered in `Editor.tsx` next to `:harper` and listed in `MANUAL_EX_NAMES`; `SettingsNavigationTarget` gained `"keymaps"` so the command can open that page. The config writer in `apps/desktop/src/main/app-config.ts` appends `# unbound` to empty entries and documents `""` in the `[keymaps]` header.
+- Tests: `keymaps.test.ts` (normalization, resolution, matching, conflicts, tooltips), `vim-half-page-keymap.test.ts` (no keymap entry for an unbound action), `SettingsModal.test.ts` (the Unbind row and the Unbound state), and `app-config.test.ts` (the config.toml round trip). Both docs surfaces are updated: the in-app manual (Keymaps section, config-file entry, `:unbind` ex row) and the website's `docs.blade.php` and `docs-sections.json`, whose DocsPage tests pass.
+- Verification, this pass: monorepo typecheck clean; app-core 1899 tests and the desktop config suite green; the built desktop app driven over CDP with isolated userData and config through 24 checks: the palette before and after the row Unbind, config.toml contents, `:unbind` with a known and an unknown id, the leader hints before and after, a hand-edited `""` picked up live, and Reset restoring the default. Tab completion of `:unb` checked the same way. Captioned demo: `media/keymap-unbind.mp4` (30 seconds, H.264, 1920×1080, CRF 17) with the captions burned into a strip under the app frame, since the clip has no voice, plus `media/keymap-unbind.vtt` for the website's caption track. Recorded from the built app at 1600×820 with sticky which-key hints so the overlay stays readable.
+
+- Remote templates (#723): `apps/server/internal/vault/templates.go` is a SYNCED COPY of `apps/desktop/src/main/templates.ts` (slug, path and de-duplication rules; a template's id is `custom:<filename stem>`, so both sides must land the same filename); `apps/server/internal/httpserver/templates.go` holds the four routes and `writeError` maps `vault.ErrInvalidTemplate` to 400. The Go watcher gained a `templates` scope branch before its dot-path drop, plus `watchSubdirs`, which adds directories created together with a parent that only raised one Create (`.zennotes/templates/` in a vault that had no `.zennotes/` yet stayed unwatched until a restart). The bridge contract gained `ServerCapabilities.supportsCustomTemplates?` and the `templates` member of `VaultChangeScope`; the desktop watcher mirrors the scope; `RemoteServerClient` gained the four template methods; the desktop IPC handlers dispatch through `requireRemoteTemplates`, reading the connect-time `remoteServerCapabilities` rather than re-fetching; the web bridge derives both the request gate and `getCapabilities()` from the same cached `/capabilities` response; `store.applyChange` re-lists templates on the new scope and after a resync; `store.init` re-reads the workspace info after `getCurrentVault` connects. Settings gates on `remoteWorkspaceInfo.capabilities` in remote mode and on the host capability otherwise.
+- #745 lives in `readPrimaryNotesLocation` in `apps/desktop/src/mcp/vault-ops.ts`, shared by the CLI's local backend and the MCP server; the inbox-notes count that used to outrank the file is gone, and the layout fallback mirrors `inferPrimaryNotesLocation` in `main/vault.ts`. Three tests in `vault-ops.test.ts` pin the order: file says root with old inbox notes, file says inbox with loose root notes, and no file at all. Verified through the running app over CDP: the vault switched to Vault root in Settings, then `zn create` with no `--vault` (it follows the vault the app has open) and the MCP `vault_info` and `create_note` tools over stdio, with both new notes appearing in the app at the root while the old ones stayed in `inbox/`. Captioned demo: `media/cli-root-mode-745.mp4` plus `media/cli-root-mode-745.vtt` (1920×1080).
+- #748 lives in two places. `normalizeBlockMathFences` in `packages/app-core/src/lib/markdown.ts` now splits every line into its blockquote prefix and content, matches fences on the content, re-emits the prefix on whatever it writes (an empty quote line where a blank would end the quote), pairs closers only at the same quote depth, and copies a canonical block through with `i = close + 1` instead of `i++` (the re-scan that paired fences across the callout edge). The currency guard's raw source slice drops the markers of continuation lines. In `cm-math-render.ts`, `quoteDepthOf` accepts markers before an opening `$$`, `stripQuoteMarkers` takes them off the formula, and `BlockMathWidget` gained a `frame` of `cm-callout cm-callout-<group>` (or `cm-wq-quote`) resolved from the outermost Blockquote node, so the widget is styled as part of the card. Tests in `markdown.test.ts` and `cm-math-render.test.ts`; verified in the built app in edit and preview with Typst selected, on the pre-fix and fixed builds of the same note. Captioned before/after: `media/typst-callout-748.mp4` plus `media/typst-callout-748.vtt` (1920×1080).
+- #746 lives in `styleSvg` in `packages/app-core/src/lib/typst-math-render.ts`: `KATEX_EM_SCALE = 1.21` applied when the SVG's pt dimensions become em sizes, and `BLACK_PAINT_RE`, which turns every black `fill` or `stroke` (`#000000`, `#000`, `black`, `rgb(0,0,0)`) into `currentColor`; Typst exports glyphs as black fills and shape rules as black strokes, and only the fills were handled. `styleSvg` is exported now, with `typst-math-render.test.ts` pinning the factor and both recolors. Measured in the built app before and after (inline `E = h nu` at 16 px text: 52.4 px wide before, 63.4 after, KaTeX 63.2). Captioned before/after: `media/typst-size-746.mp4` plus `media/typst-size-746.vtt` (1920×1080).
+- #732: `packages/app-core/src/lib/ignored-keys.ts` holds `normalizeIgnoredKeys`, `isIgnoredKeyEvent` (key or code, case-insensitive), `ignoredKeyTokenFromEvent` (key, else code for Unidentified/Dead/Process), `setIgnoredKeysRecorderActive` and `installIgnoredKeysGuard`, a single capture-phase guard on `window` for keydown, keyup and keypress that is installed at App.tsx module load (an effect would run after VimNav's) and reads the live list from the store. The pref `ignoredKeys` is portable (`ignored_keys` list under `[editor]`), with `setIgnoredKeys`, `addIgnoredKey` and `removeIgnoredKey`; Settings renders `IgnoredKeysRow` above the shortcut editor and `:ignorekey` sits next to `:unbind` in `Editor.tsx`. Tests: `ignored-keys.test.ts` (jsdom), `store.test.ts`, the config round trip. Verified in the built app over CDP with realistic timing (the no-op 15 ms after the key): the report reproduced with an empty list, then fixed with the key recorded; eleven checks. Captioned demo: `media/ignored-keys-732.mp4` plus `media/ignored-keys-732.vtt` (1920×1080).
+- #730: `folderColumns`, `noteLocationOf` and `FolderBoardLayout` in `TasksKanban.tsx` (exported for tests) place a task by splitting its path through `systemFolderForDirName`, so a remapped system folder strips its real prefix and a root-mode note has none; column ids are vault-relative directories, `NO_VALUE_COLUMN_ID` is the Other folders bucket (pinned last by `arrangeColumns`), and `kanbanColumnTitles`/`kanbanColumnOrder` grammars now accept path ids (`FOLDER_COLUMN_TITLE_KEY_RE`, `MAX_KANBAN_COLUMN_ID_LENGTH`). The pref `kanbanFolderRoot` (`normalizeKanbanFolderRoot`, `setKanbanFolderRoot`) is portable and a `VaultViewSettings` override; the board's `pickFolderRoot` prompt lists the folders that hold tasks; `:folderroot` lives in the Tasks view ex line; Settings gained `KanbanFolderRootRow`. Tests in `TasksKanban.test.ts`, `store.test.ts` and the config round trip. Verified in the built app over CDP (ten checks). Captioned demo: `media/folder-board-730.mp4` plus `media/folder-board-730.vtt` (1920×1080).
+- #738: the record shape lives in `packages/shared-domain/src/note-comments.ts` (`normalizeNoteComment(s)` with the optional `author` and `parentId`, orphaned replies kept as top-level comments, `threadNoteComments`, `threadRootOf`, the anchor helpers that used to sit in app-core, `lineOfOffset`), imported by the desktop main process (`vault.ts` lost its copy), the MCP `vault-ops` (sidecar read/write) and the panel; the Go `NoteComment` struct and `normalizeComment` mirror it. `apps/desktop/src/mcp/comment-ops.ts` composes list/add/reply/resolve from a backend's `readNote`, `listComments` and `writeComments` (new `VaultBackend` members, local through vault-ops, remote through the existing `/api/comments/*` routes), and returns thread views a model can act on. `server.ts` registers the four tools and captures `clientInfo.name` in `oninitialized` for `commentAuthorForClient`. `CommentsPanel` renders threads (rows stay the top-level cards, so j/k walk conversations), `ReplyRow`, the reply composer and the `a` action; `VimNav` maps `a` to it; `EditorPane` draws markers for top-level comments only. Tests: `note-comments.test.ts`, `comment-ops.test.ts`, `server.test.ts` (tool list, author mapping, reply threading), `cli/commands/comments.test.ts`, and a Go round trip. Verified in the built app with a real `zn mcp` session driven as claude-code, sixteen checks. Captioned demo: `media/comment-threads-738.mp4` plus `media/comment-threads-738.vtt` (1920×1080).
+- #731: the map helpers live in `packages/app-core/src/lib/saved-task-filters.ts` (`normalizeSavedTaskFilters` validates the file and localStorage, `findSavedTaskFilterName` and `savedTaskFilterQuery` match case-insensitively, `withSavedTaskFilter`, `withoutSavedTaskFilter` and `renameSavedTaskFilter` keep the insertion order, which is the chip order and the file order). The store carries `savedTaskFilters` as a portable pref (`PORTABLE_PREF_KEYS` in shared-domain, `[saved_filters]` in the desktop writer's map tables, seeded from `loadPrefs()` like every other pref) with `saveTaskFilter`, `renameSavedTaskFilter`, `deleteSavedTaskFilter` and `applySavedTaskFilter`. `TasksView` owns the chip row, the Save filter… chip, the `F` picker (`tasks.savedFilters`, a new view-actions keymap entry in both the catalog and `keymaps.ts`), and the `:filter`, `:savefilter` and `:delfilter` ex forms in its local ex line; `buildCommands` adds one "Tasks: name" entry per saved filter, opening the view first because `openTasksView` resets the filter. Tests: `saved-task-filters.test.ts`, the `[saved_filters]` round trip in `app-config.test.ts`, the palette entries in `commands.test.ts`, plus the keymap drift test. Verified in the built app over CDP with Vim on (23 checks) and off (9). Captioned demo: `media/saved-filters-731.mp4` plus `media/saved-filters-731.vtt` (34 seconds, 1920×1080). Note for the next person driving this file over CDP: the shell's `grep` wrapper skips `TasksView.tsx` as binary; use `/usr/bin/grep -a`.
+- #743: the calendar is `packages/app-core/src/components/DatePickerModal.tsx` on `ui/Modal` (focus trap, Escape, focus restore), hosted by `DatePickerHost` next to the prompt and confirm hosts in `App.tsx`, and requested through `promptDate()` in `lib/date-prompt-requests.ts`, the calendar twin of `promptApp`: any code without React context (a CodeMirror completion's `apply`, an ex command) can await an ISO string or null. The date math is pure in `lib/date-picker.ts` (`parseISODate` rejects days the month does not have, `addMonths` clamps the day, `buildMonthGrid`, `moveDate`, and `datePickerMoveForKey`, which gates h/j/k/l and t on Vim mode). The Date… item in `cm-date-shortcuts.ts` removes the trigger before the calendar opens and inserts at the recorded position, re-clamped to the document length. The modal carries `data-prompt-modal`, so VimNav and the list views hand over the keyboard as they do for the text prompt. A month change replaces every grid cell, which drops focus to the body before React's effect runs, so the refocus decision is recorded by the move itself rather than read from `document.activeElement`; the built app caught this where jsdom did not. Tests: `date-picker.test.ts`, `DatePickerModal.test.ts` (keyboard, paging with focus, typed dates, Vim gating, cancel), and `cm-date-shortcuts.test.ts` (menu order, queries, the hand-off with a mocked prompt). Verified in the built app over CDP with Vim on and off, thirteen checks. Captioned demo: `media/date-picker-743.mp4` plus `media/date-picker-743.vtt` (31 seconds, 1920×1080).
+- Tests for #723: Go (vault slug, path, de-duplication, symlink and listing rules; HTTP auth, CRUD, traversal, 413 and the capability; watcher scope and late walk), desktop (`server-client.test.ts` drives the four routes against a loopback server, `watcher.test.ts` sees the scope), app-core (`store.test.ts` for the scope, the resync fan-out and the post-connect re-read; `SettingsModal.test.ts` for the remote gate with and without the flag). Verified live: the web client against a real server (create, rename, delete, and a file dropped into the vault arriving through the WebSocket feed) and the desktop in remote mode over CDP through twelve checks. Captioned demo: `media/remote-templates.mp4` plus `media/remote-templates.vtt` (28 seconds, H.264, 1920×1080), recorded from the built app connected to a local ZenNotes server.
+
+---
+
+Local-first and keyboard-first, as always.
diff --git a/docs/releases/v2.46.0/media/cli-root-mode-745.mp4 b/docs/releases/v2.46.0/media/cli-root-mode-745.mp4
new file mode 100644
index 00000000..4ac6c7d4
Binary files /dev/null and b/docs/releases/v2.46.0/media/cli-root-mode-745.mp4 differ
diff --git a/docs/releases/v2.46.0/media/cli-root-mode-745.vtt b/docs/releases/v2.46.0/media/cli-root-mode-745.vtt
new file mode 100644
index 00000000..0fcb0f50
--- /dev/null
+++ b/docs/releases/v2.46.0/media/cli-root-mode-745.vtt
@@ -0,0 +1,13 @@
+WEBVTT
+
+00:00.000 --> 00:07.127
+A vault with notes in inbox/. In Settings, Vault, switch the primary notes location to Vault root.
+
+00:07.127 --> 00:12.335
+In a terminal: zn create --title "From the CLI". It follows the vault the app has open, and the old notes are still in inbox/.
+
+00:12.335 --> 00:16.177
+Before: it landed in inbox/. Now: at the vault root, where the app files its own notes, and the app lists it right away.
+
+00:16.177 --> 00:20.181
+The MCP create_note tool does the same, and vault_info now reports primaryNotesLocation: root.
diff --git a/docs/releases/v2.46.0/media/comment-threads-738.mp4 b/docs/releases/v2.46.0/media/comment-threads-738.mp4
new file mode 100644
index 00000000..c9b8408d
Binary files /dev/null and b/docs/releases/v2.46.0/media/comment-threads-738.mp4 differ
diff --git a/docs/releases/v2.46.0/media/comment-threads-738.vtt b/docs/releases/v2.46.0/media/comment-threads-738.vtt
new file mode 100644
index 00000000..2885ed69
--- /dev/null
+++ b/docs/releases/v2.46.0/media/comment-threads-738.vtt
@@ -0,0 +1,22 @@
+WEBVTT
+
+00:00.001 --> 00:06.479
+Discuss a note with your assistant through comments. Select a passage, press ⌘⌥M, and leave a comment anchored to it.
+
+00:06.479 --> 00:09.084
+Ask Claude Code (or any MCP client) to review the note. It reads the threads with list_comments and answers with reply_to_comment.
+
+00:09.084 --> 00:12.486
+The reply lands under your comment, live, signed with the assistant’s name. Its words and yours stay apart.
+
+00:12.486 --> 00:16.841
+It can raise points of its own: add_comment with a passage from the note anchors a new thread, and the editor marks the text.
+
+00:16.841 --> 00:23.481
+Answer from the panel: a opens a reply box under the selected thread, ⌘↵ sends it.
+
+00:23.481 --> 00:27.438
+resolve_comment (or r in the panel) closes a settled thread. It moves to Resolved and stays in the note’s history.
+
+00:27.438 --> 00:31.112
+Everything lives in the .comments.json beside the note, so zn comment, the web client and every MCP client see the same threads.
diff --git a/docs/releases/v2.46.0/media/date-picker-743.mp4 b/docs/releases/v2.46.0/media/date-picker-743.mp4
new file mode 100644
index 00000000..8c82cfb3
Binary files /dev/null and b/docs/releases/v2.46.0/media/date-picker-743.mp4 differ
diff --git a/docs/releases/v2.46.0/media/date-picker-743.vtt b/docs/releases/v2.46.0/media/date-picker-743.vtt
new file mode 100644
index 00000000..612d7961
--- /dev/null
+++ b/docs/releases/v2.46.0/media/date-picker-743.vtt
@@ -0,0 +1,19 @@
+WEBVTT
+
+00:00.000 --> 00:04.051
+Type @ in a note. Today, Yesterday, Tomorrow and Now are still there. New at the end of the list: Date…
+
+00:04.051 --> 00:07.420
+Type "date" (or arrow down to the row) and press Enter.
+
+00:07.420 --> 00:12.297
+A calendar opens on today, already focused. Arrows move a day or a week, PageDown the month, Shift+PageUp a year back.
+
+00:12.297 --> 00:15.533
+Enter inserts the ISO date where the @ stood, and focus returns to the note.
+
+00:15.533 --> 00:22.956
+Or type the date outright: a digit jumps to the field, and the grid follows as you type.
+
+00:22.956 --> 00:30.751
+Escape leaves the text exactly as it was. With Vim mode on, h j k l move and t jumps back to today.
diff --git a/docs/releases/v2.46.0/media/folder-board-730.mp4 b/docs/releases/v2.46.0/media/folder-board-730.mp4
new file mode 100644
index 00000000..0b79867c
Binary files /dev/null and b/docs/releases/v2.46.0/media/folder-board-730.mp4 differ
diff --git a/docs/releases/v2.46.0/media/folder-board-730.vtt b/docs/releases/v2.46.0/media/folder-board-730.vtt
new file mode 100644
index 00000000..53467ede
--- /dev/null
+++ b/docs/releases/v2.46.0/media/folder-board-730.vtt
@@ -0,0 +1,16 @@
+WEBVTT
+
+00:00.000 --> 00:04.210
+The Kanban Folder board now gives every note folder its own column: Projects/alpha, Projects/beta, Areas, the Inbox root, Quick Notes.
+
+00:04.210 --> 00:08.954
+Notes organised as Projects/<name>? Point the board at that folder: :folderroot Projects (or Settings, Tasks, Folder board).
+
+00:08.954 --> 00:13.156
+Its children are the columns. Deeper notes roll up to their project, and notes outside it share one Other folders column.
+
+00:13.156 --> 00:17.171
+The chip in the header shows the root; click it to pick another folder from the ones that hold tasks.
+
+00:17.171 --> 00:23.502
+It travels in config.toml as kanban_folder_root, per vault. Bare :folderroot goes back to one column per folder.
diff --git a/docs/releases/v2.46.0/media/ignored-keys-732.mp4 b/docs/releases/v2.46.0/media/ignored-keys-732.mp4
new file mode 100644
index 00000000..5eac812c
Binary files /dev/null and b/docs/releases/v2.46.0/media/ignored-keys-732.mp4 differ
diff --git a/docs/releases/v2.46.0/media/ignored-keys-732.vtt b/docs/releases/v2.46.0/media/ignored-keys-732.vtt
new file mode 100644
index 00000000..eb327423
--- /dev/null
+++ b/docs/releases/v2.46.0/media/ignored-keys-732.vtt
@@ -0,0 +1,13 @@
+WEBVTT
+
+00:00.000 --> 00:03.866
+Kanata, QMK and ZMK tap-hold layers send a no-op key (KanaMode on Linux) with every keystroke. Watch it break jk: j, no-op, k.
+
+00:03.866 --> 00:07.800
+Still in insert mode, with a stray jk typed. The no-op reset the sequence; dd, leader chords and hints suffer the same way.
+
+00:07.800 --> 00:14.284
+Settings, Keymap, Ignored keys: press Record a key, then the no-op. It is listed by name and saved to config.toml as ignored_keys.
+
+00:14.284 --> 00:21.362
+Now the app never sees it: j, no-op, k leaves insert mode, and d, no-op, d deletes the line. :ignorekey <key> does the same from the ex line.
diff --git a/docs/releases/v2.46.0/media/keymap-unbind.mp4 b/docs/releases/v2.46.0/media/keymap-unbind.mp4
new file mode 100644
index 00000000..637c76fb
Binary files /dev/null and b/docs/releases/v2.46.0/media/keymap-unbind.mp4 differ
diff --git a/docs/releases/v2.46.0/media/keymap-unbind.vtt b/docs/releases/v2.46.0/media/keymap-unbind.vtt
new file mode 100644
index 00000000..62b94493
--- /dev/null
+++ b/docs/releases/v2.46.0/media/keymap-unbind.vtt
@@ -0,0 +1,22 @@
+WEBVTT
+
+00:00.000 --> 00:04.401
+Every row in Settings, Keymap now has an Unbind button.
+
+00:04.401 --> 00:07.728
+The row reads Unbound. Nothing fires the action until it gets a key again.
+
+00:07.728 --> 00:10.552
+⇧⌘P used to open the command palette. Now it does nothing.
+
+00:10.552 --> 00:16.209
+Vim users: :unbind takes a key away from the ex line.
+
+00:16.209 --> 00:20.588
+The leader hints drop the unbound action: no more o for open buffers.
+
+00:20.588 --> 00:23.989
+It travels with your dotfiles: "vim.leaderOpenBuffers" = "" under [keymaps] in config.toml.
+
+00:23.989 --> 00:30.161
+Reset brings the shipped default back.
diff --git a/docs/releases/v2.46.0/media/remote-templates.mp4 b/docs/releases/v2.46.0/media/remote-templates.mp4
new file mode 100644
index 00000000..8708bc38
Binary files /dev/null and b/docs/releases/v2.46.0/media/remote-templates.mp4 differ
diff --git a/docs/releases/v2.46.0/media/remote-templates.vtt b/docs/releases/v2.46.0/media/remote-templates.vtt
new file mode 100644
index 00000000..5c33bc46
--- /dev/null
+++ b/docs/releases/v2.46.0/media/remote-templates.vtt
@@ -0,0 +1,22 @@
+WEBVTT
+
+00:00.000 --> 00:03.530
+The desktop app on a remote vault: a self-hosted ZenNotes server, not a local folder.
+
+00:03.530 --> 00:06.355
+Settings, Templates now offers New template here (server 2.46 or later).
+
+00:06.355 --> 00:12.259
+Write the template in the editor and save it.
+
+00:12.259 --> 00:15.060
+Saved on the server as .zennotes/templates/team-retro.md, the same file a local vault keeps.
+
+00:15.060 --> 00:18.941
+A template saved by another client shows up on its own: the server’s change feed carries it.
+
+00:18.941 --> 00:23.120
+Both are in the picker like any template: Space t, or :template.
+
+00:23.120 --> 00:28.334
+Delete removes it from the server, and the editor edits it in place.
diff --git a/docs/releases/v2.46.0/media/saved-filters-731.mp4 b/docs/releases/v2.46.0/media/saved-filters-731.mp4
new file mode 100644
index 00000000..601d747e
Binary files /dev/null and b/docs/releases/v2.46.0/media/saved-filters-731.mp4 differ
diff --git a/docs/releases/v2.46.0/media/saved-filters-731.vtt b/docs/releases/v2.46.0/media/saved-filters-731.vtt
new file mode 100644
index 00000000..011af61b
--- /dev/null
+++ b/docs/releases/v2.46.0/media/saved-filters-731.vtt
@@ -0,0 +1,19 @@
+WEBVTT
+
+00:00.000 --> 00:03.401
+Saved filters in the Tasks view. Two are already in config.toml under [saved_filters], so they show as chips under the header.
+
+00:03.401 --> 00:07.776
+Click a chip and its query lands in the filter box. Every sub-view narrows: the list, the calendar, the board.
+
+00:07.776 --> 00:13.535
+Keyboard: F opens the picker. Type to narrow, Enter applies. With :filter you can also type a saved name.
+
+00:13.535 --> 00:22.145
+A new query worth keeping: type it, then Save filter… (or :savefilter <name>). The chip appears, and config.toml gets the line.
+
+00:22.145 --> 00:30.282
+From any note, the command palette lists every saved filter as "Tasks: name". Pick one and the Tasks view opens already filtered.
+
+00:30.282 --> 00:33.925
+Right-click a chip to rename or delete it, or edit [saved_filters] in config.toml by hand: changes apply live and travel with your dotfiles.
diff --git a/docs/releases/v2.46.0/media/typst-callout-748.mp4 b/docs/releases/v2.46.0/media/typst-callout-748.mp4
new file mode 100644
index 00000000..a398db20
Binary files /dev/null and b/docs/releases/v2.46.0/media/typst-callout-748.mp4 differ
diff --git a/docs/releases/v2.46.0/media/typst-callout-748.vtt b/docs/releases/v2.46.0/media/typst-callout-748.vtt
new file mode 100644
index 00000000..315edbeb
--- /dev/null
+++ b/docs/releases/v2.46.0/media/typst-callout-748.vtt
@@ -0,0 +1,13 @@
+WEBVTT
+
+00:00.000 --> 00:04.000
+Before: with Typst selected, a $$ block inside a callout stayed raw in the editor while the one outside rendered.
+
+00:04.000 --> 00:08.500
+Before, reading view: the callout lost its body and a failing formula swallowed the rest of the note.
+
+00:08.500 --> 00:12.500
+After: the block inside the callout renders like the one outside, as part of the card.
+
+00:12.500 --> 00:16.500
+After, reading view: both render, inline math inside callouts included.
diff --git a/docs/releases/v2.46.0/media/typst-size-746.mp4 b/docs/releases/v2.46.0/media/typst-size-746.mp4
new file mode 100644
index 00000000..0e48725f
Binary files /dev/null and b/docs/releases/v2.46.0/media/typst-size-746.mp4 differ
diff --git a/docs/releases/v2.46.0/media/typst-size-746.vtt b/docs/releases/v2.46.0/media/typst-size-746.vtt
new file mode 100644
index 00000000..6b330490
--- /dev/null
+++ b/docs/releases/v2.46.0/media/typst-size-746.vtt
@@ -0,0 +1,13 @@
+WEBVTT
+
+00:00.000 --> 00:04.000
+KaTeX draws Computer Modern at 1.21 times the text size, the way its own stylesheet asks.
+
+00:04.000 --> 00:09.000
+Before: the same formulas under Typst were a fifth smaller, and a square root bar stayed black on a dark theme.
+
+00:09.000 --> 00:13.500
+After: Typst formulas are sized the way KaTeX sizes them, and every rule follows the text color.
+
+00:13.500 --> 00:17.500
+The reading view too, display blocks included. The Math size setting still scales on top.
diff --git a/docs/releases/v2.46.0/twitter-post.md b/docs/releases/v2.46.0/twitter-post.md
new file mode 100644
index 00000000..f5c7ac24
--- /dev/null
+++ b/docs/releases/v2.46.0/twitter-post.md
@@ -0,0 +1,58 @@
+# Twitter/X thread for ZenNotes 2.46.0
+
+## Tweet 1
+
+ZenNotes 2.46.0 is out.
+
+💬 Review a note with your assistant, inside the note. Comments now thread and carry a name, and over MCP Claude Code (or Codex, or Claude Desktop) reads a note's comment threads, answers under yours, opens threads of its own anchored to a passage, and resolves settled ones. Its replies land in the Comments panel live, signed with its name. Thanks @gverger (#738).
+
+https://github.com/ZenNotes/zennotes/releases/tag/v2.46.0
+
+## Tweet 2
+
+🗂 The Kanban Folder board now gives every note folder its own column, and :folderroot Projects turns one folder's children into the columns (deeper notes roll up, the rest share Other folders). No more @status tokens derived from paths. Thanks @andradejoelwp (#730).
+
+## Tweet 3
+
+⌨️ Home-row mods on Kanata, QMK or ZMK? The no-op key your tap-hold layer sends used to reset jk, dd and leader chords. Record it under Settings → Keymap → Ignored keys (or :ignorekey KanaMode, or ignored_keys in config.toml) and the app never sees it again. Thanks @potter1402 (#732).
+
+## Tweet 4
+
+⌨️ You can now remove a shortcut instead of remapping it onto some chord you will never press. Every row in Settings → Keymap has an Unbind button: the row reads Unbound, nothing fires the action any more, and Reset brings the default back whenever you want it.
+
+## Tweet 5
+
+Vim users: `:unbind vim.leaderOpenBuffers` does the same from the ex line, with a toast naming the key it took away. The leader hints, the command palette and the manual stop advertising it. Bare :unbind opens the Keymap page, which lists every action id.
+
+## Tweet 6
+
+🧳 It travels with your dotfiles. An unbind is `"global.commandPalette" = ""` under [keymaps] in config.toml, the file explains the convention next to the table, and a hand edit applies live.
+
+## Tweet 7
+
+🌐 Self-hosting? Custom templates now work in the web client and on a desktop connected to your ZenNotes server. Same .zennotes/templates/ folder as a local vault, same editor, and a template saved on one device shows up on the others through the change feed. Thanks @ajselzilic for the spec (#723).
+
+## Tweet 8
+
+📅 The @ menu now ends with Date…: a keyboard-first calendar for any day, next to Today, Yesterday, Tomorrow and Now. Arrows move, PageUp/PageDown change the month, Enter inserts the ISO date where the @ was. Know the date? Type it outright. h j k l and t work with Vim mode on. Thanks @uNyanda (#743).
+
+## Tweet 9
+
+🔖 Tasks filters you can keep. Save a query under a name and it becomes a chip under the Tasks header, a "Tasks: name" entry in the command palette, and :filter <name> in the view; F opens a picker with Vim on. The list lives in config.toml as [saved_filters], so it diffs and syncs with your dotfiles. Thanks @andradejoelwp (#731).
+
+## Tweet 10
+
+🛠 Fixed: on a vault in root mode, zn create and the MCP create_note tool filed new notes into inbox/ and vault_info said inbox. They now follow vault.json like the app does. Thanks @diazkev314 (#745).
+
+## Tweet 11
+
+🧮 Fixed: a $$ display block inside a callout now renders in both the editor and the reading view, with Typst and KaTeX alike. It used to stay raw in the editor and, with Typst, swallow the rest of the note in the reading view. Thanks @OstrichDowneyJr (#748).
+
+## Tweet 12
+
+📐 Fixed: Typst formulas were a fifth smaller than KaTeX's next to the same text, and a square root bar stayed black on dark themes. They now use the same 1.21 size factor KaTeX uses for Computer Modern, and every rule follows the text color. Thanks @cyperion (#746).
+
+Free, open source, local-first Markdown notes.
+https://zennotes.org
+
+Issues closed: #723, #730, #731, #732, #738, #743, #745, #746, #748.
diff --git a/package-lock.json b/package-lock.json
index cd85b377..8c6eb4f6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "zennotes-monorepo",
-  "version": "2.45.0",
+  "version": "2.46.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "zennotes-monorepo",
-      "version": "2.45.0",
+      "version": "2.46.0",
       "hasInstallScript": true,
       "workspaces": [
         "apps/*",
@@ -23,7 +23,7 @@
     },
     "apps/desktop": {
       "name": "@zennotes/desktop",
-      "version": "2.45.0",
+      "version": "2.46.0",
       "license": "MIT",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
@@ -874,11 +874,11 @@
     },
     "apps/server": {
       "name": "@zennotes/server",
-      "version": "2.45.0"
+      "version": "2.46.0"
     },
     "apps/web": {
       "name": "@zennotes/web",
-      "version": "2.45.0",
+      "version": "2.46.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -16286,7 +16286,7 @@
     },
     "packages/app-core": {
       "name": "@zennotes/app-core",
-      "version": "2.45.0",
+      "version": "2.46.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -16363,11 +16363,11 @@
     },
     "packages/bridge-contract": {
       "name": "@zennotes/bridge-contract",
-      "version": "2.45.0"
+      "version": "2.46.0"
     },
     "packages/shared-domain": {
       "name": "@zennotes/shared-domain",
-      "version": "2.45.0",
+      "version": "2.46.0",
       "dependencies": {
         "@zennotes/bridge-contract": "*",
         "lz-string": "^1.5.0"
@@ -16378,7 +16378,7 @@
     },
     "packages/shared-ui": {
       "name": "@zennotes/shared-ui",
-      "version": "2.45.0"
+      "version": "2.46.0"
     }
   }
 }
diff --git a/package.json b/package.json
index 95f6d3c8..3a38ed97 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "zennotes-monorepo",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "description": "ZenNotes monorepo for desktop, web, and self-hosted server builds",
   "packageManager": "npm@10.9.2",
   "engines": {
diff --git a/packages/app-core/package.json b/packages/app-core/package.json
index 9ffe9115..eec3d378 100644
--- a/packages/app-core/package.json
+++ b/packages/app-core/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/app-core",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "type": "module",
   "exports": {
     "./main": "./src/main.tsx"
diff --git a/packages/app-core/src/App.tsx b/packages/app-core/src/App.tsx
index 336e6f8d..3864e36d 100644
--- a/packages/app-core/src/App.tsx
+++ b/packages/app-core/src/App.tsx
@@ -20,6 +20,7 @@ import { NoteList } from './components/NoteList'
 import { TitleBar } from './components/TitleBar'
 import { PromptHost } from './components/PromptHost'
 import { ConfirmHost } from './components/ConfirmHost'
+import { DatePickerHost } from './components/DatePickerHost'
 import { PublishNoteHost } from './components/PublishNoteHost'
 import { CloudConflictReviewHost } from './components/CloudConflictReviewHost'
 import { ServerDirectoryPickerHost } from './components/ServerDirectoryPickerHost'
@@ -59,6 +60,13 @@ import {
 } from './lib/app-update-state'
 import { ensureCloudAutoSyncStarted, stopCloudAutoSync } from './lib/cloud-auto-sync'
 import { installHarperRuntime } from './lib/harper-runtime'
+import { installIgnoredKeysGuard } from './lib/ignored-keys'
+
+// The ignored-keys guard (#732) has to be on `window` before any component
+// registers a capture listener there, so it is installed at import time,
+// not from an effect: children's effects run before App's, and VimNav's
+// would otherwise see the stray key first. Reads the live list on each key.
+installIgnoredKeysGuard(() => useStore.getState().ignoredKeys)
 
 let editorModulePromise: Promise<typeof import('./components/Editor')> | null = null
 const EDITOR_MODULE_WARMUP_GRACE_MS = 40
@@ -1123,6 +1131,7 @@ function App(): JSX.Element {
         </Suspense>
         <PromptHost />
         <ConfirmHost />
+        <DatePickerHost />
         <PublishNoteHost />
         <ToastHost />
         <ExcalidrawEmbedMenuHost />
@@ -1141,6 +1150,7 @@ function App(): JSX.Element {
         </Suspense>
         <PromptHost />
         <ConfirmHost />
+        <DatePickerHost />
         <PublishNoteHost />
         <ToastHost />
         <ExcalidrawEmbedMenuHost />
@@ -1214,6 +1224,7 @@ function App(): JSX.Element {
       )}
       <PromptHost />
       <ConfirmHost />
+      <DatePickerHost />
       <PublishNoteHost />
       <CloudConflictReviewHost />
       <ToastHost />
diff --git a/packages/app-core/src/components/CommentsPanel.tsx b/packages/app-core/src/components/CommentsPanel.tsx
index 73fe6b4b..0c51d180 100644
--- a/packages/app-core/src/components/CommentsPanel.tsx
+++ b/packages/app-core/src/components/CommentsPanel.tsx
@@ -10,6 +10,7 @@ import {
 import type { NoteComment, NoteContent } from '@shared/ipc'
 import { useStore } from '../store'
 import { commentQuote } from '../lib/comments'
+import { threadNoteComments, type NoteCommentThread } from '@shared/note-comments'
 import { renderMarkdown } from '../lib/markdown'
 import { usePanelResize } from '../lib/use-panel-resize'
 import { PanelResizeHandle } from './PanelResizeHandle'
@@ -98,6 +99,8 @@ export function CommentsPanel({
     setBody('')
     setEditingId(null)
     setEditBody('')
+    setReplyingId(null)
+    setReplyBody('')
     onClearDraft()
   }, [note.path])
 
@@ -111,15 +114,23 @@ export function CommentsPanel({
     return () => cancelAnimationFrame(raf)
   }, [activeCommentId, comments])
 
+  // Threads (#738): a top-level comment with its replies. The panel's rows are
+  // the threads; a reply lives inside its card, so j/k walk conversations.
+  const threads = useMemo(() => threadNoteComments(comments), [comments])
   const unresolved = useMemo(
-    () => comments.filter((comment) => comment.resolvedAt == null),
-    [comments]
+    () => threads.filter((thread) => thread.comment.resolvedAt == null),
+    [threads]
   )
   const resolved = useMemo(
-    () => comments.filter((comment) => comment.resolvedAt != null),
-    [comments]
+    () => threads.filter((thread) => thread.comment.resolvedAt != null),
+    [threads]
   )
-  const orderedComments = useMemo(() => [...unresolved, ...resolved], [resolved, unresolved])
+  const orderedComments = useMemo(
+    () => [...unresolved, ...resolved].map((thread) => thread.comment),
+    [resolved, unresolved]
+  )
+  const [replyingId, setReplyingId] = useState<string | null>(null)
+  const [replyBody, setReplyBody] = useState('')
 
   useEffect(() => {
     if (!commentsFocused) return
@@ -174,6 +185,31 @@ export function CommentsPanel({
     setEditBody('')
   }
 
+  const startReply = (thread: NoteCommentThread): void => {
+    setReplyingId(thread.comment.id)
+    setReplyBody('')
+    setActiveCommentId(thread.comment.id)
+  }
+
+  // A reply keeps the thread's anchor, so the editor keeps one marker per
+  // conversation and re-anchoring moves the whole thread together.
+  const submitReply = async (thread: NoteCommentThread): Promise<void> => {
+    const trimmed = replyBody.trim()
+    if (!trimmed) return
+    const root = thread.comment
+    await addNoteComment({
+      notePath: note.path,
+      anchorStart: root.anchorStart,
+      anchorEnd: root.anchorEnd,
+      anchorText: root.anchorText,
+      body: trimmed,
+      parentId: root.id
+    })
+    setReplyingId(null)
+    setReplyBody('')
+    setActiveCommentId(root.id)
+  }
+
   let rowIndex = 0
 
   return (
@@ -223,6 +259,7 @@ export function CommentsPanel({
           <CommentKeyHint keyLabel="j/k" label="Move" />
           <CommentKeyHint keyLabel="↵" label="Jump" />
           <CommentKeyHint keyLabel="n" label="New" />
+          <CommentKeyHint keyLabel="a" label="Reply" />
           <CommentKeyHint keyLabel="e" label="Edit" />
           <CommentKeyHint keyLabel="r" label="Resolve" />
           <CommentKeyHint keyLabel="d" label="Delete" />
@@ -291,30 +328,40 @@ export function CommentsPanel({
           </div>
         ) : (
           <div className="flex flex-col gap-3">
-            {unresolved.map((comment) => (
+            {unresolved.map((thread) => (
               <CommentCard
-                key={comment.id}
-                comment={comment}
+                key={thread.comment.id}
+                comment={thread.comment}
+                replies={thread.replies}
                 rowIndex={rowIndex++}
-                active={activeCommentId === comment.id}
+                active={activeCommentId === thread.comment.id}
                 commentsFocused={commentsFocused}
-                editing={editingId === comment.id}
+                editing={editingId === thread.comment.id}
                 editBody={editBody}
                 onEditBody={setEditBody}
+                replying={replyingId === thread.comment.id}
+                replyBody={replyBody}
+                onReplyBody={setReplyBody}
+                onReply={() => startReply(thread)}
+                onCancelReply={() => {
+                  setReplyingId(null)
+                  setReplyBody('')
+                }}
+                onSubmitReply={() => void submitReply(thread)}
                 onJump={() => {
-                  setActiveCommentId(comment.id)
-                  onJump(comment)
+                  setActiveCommentId(thread.comment.id)
+                  onJump(thread.comment)
                 }}
-                onEdit={() => startEdit(comment)}
+                onEdit={() => startEdit(thread.comment)}
                 onCancelEdit={() => {
                   setEditingId(null)
                   setEditBody('')
                 }}
-                onSave={() => void saveEdit(comment)}
+                onSave={() => void saveEdit(thread.comment)}
                 onResolve={() =>
-                  void updateNoteComment(note.path, comment.id, { resolvedAt: Date.now() })
+                  void updateNoteComment(note.path, thread.comment.id, { resolvedAt: Date.now() })
                 }
-                onDelete={() => void deleteNoteComment(note.path, comment.id)}
+                onDelete={() => void deleteNoteComment(note.path, thread.comment.id)}
               />
             ))}
             {resolved.length > 0 && unresolved.length > 0 && (
@@ -322,30 +369,40 @@ export function CommentsPanel({
                 Resolved
               </div>
             )}
-            {resolved.map((comment) => (
+            {resolved.map((thread) => (
               <CommentCard
-                key={comment.id}
-                comment={comment}
+                key={thread.comment.id}
+                comment={thread.comment}
+                replies={thread.replies}
                 rowIndex={rowIndex++}
-                active={activeCommentId === comment.id}
+                active={activeCommentId === thread.comment.id}
                 commentsFocused={commentsFocused}
-                editing={editingId === comment.id}
+                editing={editingId === thread.comment.id}
                 editBody={editBody}
                 onEditBody={setEditBody}
+                replying={replyingId === thread.comment.id}
+                replyBody={replyBody}
+                onReplyBody={setReplyBody}
+                onReply={() => startReply(thread)}
+                onCancelReply={() => {
+                  setReplyingId(null)
+                  setReplyBody('')
+                }}
+                onSubmitReply={() => void submitReply(thread)}
                 onJump={() => {
-                  setActiveCommentId(comment.id)
-                  onJump(comment)
+                  setActiveCommentId(thread.comment.id)
+                  onJump(thread.comment)
                 }}
-                onEdit={() => startEdit(comment)}
+                onEdit={() => startEdit(thread.comment)}
                 onCancelEdit={() => {
                   setEditingId(null)
                   setEditBody('')
                 }}
-                onSave={() => void saveEdit(comment)}
+                onSave={() => void saveEdit(thread.comment)}
                 onResolve={() =>
-                  void updateNoteComment(note.path, comment.id, { resolvedAt: null })
+                  void updateNoteComment(note.path, thread.comment.id, { resolvedAt: null })
                 }
-                onDelete={() => void deleteNoteComment(note.path, comment.id)}
+                onDelete={() => void deleteNoteComment(note.path, thread.comment.id)}
               />
             ))}
           </div>
@@ -355,14 +412,30 @@ export function CommentsPanel({
   )
 }
 
+/** Display name and avatar letter: the vault's owner has no stored author. */
+function authorLabel(comment: Pick<NoteComment, 'author'>): string {
+  return comment.author?.trim() || 'You'
+}
+
+function authorInitial(comment: Pick<NoteComment, 'author'>): string {
+  return authorLabel(comment).slice(0, 1).toUpperCase()
+}
+
 function CommentCard({
   comment,
+  replies,
   rowIndex,
   active,
   commentsFocused,
   editing,
   editBody,
   onEditBody,
+  replying,
+  replyBody,
+  onReplyBody,
+  onReply,
+  onCancelReply,
+  onSubmitReply,
   onJump,
   onEdit,
   onCancelEdit,
@@ -371,12 +444,19 @@ function CommentCard({
   onDelete
 }: {
   comment: NoteComment
+  replies: NoteComment[]
   rowIndex: number
   active: boolean
   commentsFocused: boolean
   editing: boolean
   editBody: string
   onEditBody: (body: string) => void
+  replying: boolean
+  replyBody: string
+  onReplyBody: (body: string) => void
+  onReply: () => void
+  onCancelReply: () => void
+  onSubmitReply: () => void
   onJump: () => void
   onEdit: () => void
   onCancelEdit: () => void
@@ -385,6 +465,7 @@ function CommentCard({
   onDelete: () => void
 }): JSX.Element {
   const resolved = comment.resolvedAt != null
+  const assistant = !!comment.author
   // Render the comment body as Markdown (sanitized). Cached by renderMarkdown,
   // memoized per-body so card re-renders (hover/selection) don't re-parse.
   const bodyHtml = useMemo(() => renderMarkdown(comment.body), [comment.body])
@@ -412,12 +493,21 @@ function CommentCard({
       ].join(' ')}
     >
       <div className="flex items-start gap-3">
-        <div className="mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full border border-paper-300/70 bg-paper-200/80 text-xs font-semibold text-ink-700">
-          Y
+        <div
+          className={[
+            'mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-full border text-xs font-semibold',
+            assistant
+              ? 'border-accent/40 bg-accent/15 text-accent'
+              : 'border-paper-300/70 bg-paper-200/80 text-ink-700'
+          ].join(' ')}
+        >
+          {authorInitial(comment)}
         </div>
         <div className="min-w-0 flex-1">
           <div className="flex min-w-0 items-center gap-2">
-            <span className="truncate text-sm font-semibold text-ink-900">You</span>
+            <span data-comment-author className="truncate text-sm font-semibold text-ink-900">
+              {authorLabel(comment)}
+            </span>
             <span className="shrink-0 text-xs text-ink-400">
               {dateFormatter.format(new Date(comment.updatedAt))}
             </span>
@@ -504,6 +594,78 @@ function CommentCard({
               dangerouslySetInnerHTML={{ __html: bodyHtml }}
             />
           )}
+
+          {replies.length > 0 && (
+            <div data-comment-replies className="mt-3 flex flex-col gap-2 border-l-2 border-paper-300/70 pl-3">
+              {replies.map((reply) => (
+                <ReplyRow key={reply.id} reply={reply} />
+              ))}
+            </div>
+          )}
+
+          {replying && (
+            <div className="mt-3" data-comment-card-control>
+              <textarea
+                data-comment-reply-input
+                value={replyBody}
+                onChange={(event) => onReplyBody(event.target.value)}
+                autoFocus
+                placeholder="Reply…"
+                onKeyDown={(event) => {
+                  if (isCommitShortcut(event)) {
+                    event.preventDefault()
+                    if (replyBody.trim()) onSubmitReply()
+                    return
+                  }
+                  if (event.key === 'Escape') {
+                    event.preventDefault()
+                    onCancelReply()
+                  }
+                }}
+                aria-keyshortcuts="Meta+Enter Control+Enter Escape"
+                rows={3}
+                className="w-full resize-none rounded-md border border-paper-300/70 bg-paper-50 px-3 py-2 text-sm leading-5 text-ink-900 outline-none focus:border-accent/60 focus:ring-1 focus:ring-accent/20"
+              />
+              <div className="relative z-10 mt-2 flex justify-end gap-2">
+                <button
+                  type="button"
+                  data-comment-card-control
+                  onMouseDown={(event) => {
+                    event.stopPropagation()
+                  }}
+                  onClick={(event) => {
+                    event.preventDefault()
+                    event.stopPropagation()
+                    onCancelReply()
+                  }}
+                  title="Cancel (Esc)"
+                  className="flex items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs text-ink-500 transition-colors hover:bg-paper-200 hover:text-ink-800 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent/45"
+                >
+                  <span>Cancel</span>
+                  <InlineShortcut>Esc</InlineShortcut>
+                </button>
+                <button
+                  type="button"
+                  data-comment-card-control
+                  data-comment-action="send-reply"
+                  disabled={!replyBody.trim()}
+                  onMouseDown={(event) => {
+                    event.stopPropagation()
+                  }}
+                  onClick={(event) => {
+                    event.preventDefault()
+                    event.stopPropagation()
+                    onSubmitReply()
+                  }}
+                  title="Reply (⌘↵)"
+                  className="flex items-center gap-1.5 rounded-md bg-accent px-3 py-1.5 text-xs font-medium text-white transition-colors hover:bg-accent/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent/45 disabled:cursor-default disabled:bg-paper-300 disabled:text-ink-500"
+                >
+                  <span>Reply</span>
+                  <InlineShortcut tone="light">⌘↵</InlineShortcut>
+                </button>
+              </div>
+            </div>
+          )}
         </div>
       </div>
 
@@ -518,6 +680,17 @@ function CommentCard({
           >
             <ArrowUpRightIcon width={13} height={13} />
           </IconTextButton>
+          {!editing && !replying && (
+            <IconTextButton
+              title="Reply"
+              action="reply"
+              shortcut="a"
+              showShortcut={showActionShortcuts}
+              onClick={onReply}
+            >
+              <ReplyIcon width={13} height={13} />
+            </IconTextButton>
+          )}
           {!editing && (
             <IconTextButton
               title="Edit"
@@ -554,6 +727,59 @@ function CommentCard({
   )
 }
 
+function ReplyRow({ reply }: { reply: NoteComment }): JSX.Element {
+  const html = useMemo(() => renderMarkdown(reply.body), [reply.body])
+  const assistant = !!reply.author
+  return (
+    <div data-comment-reply-id={reply.id} className="flex items-start gap-2">
+      <div
+        className={[
+          'mt-0.5 flex h-5 w-5 shrink-0 items-center justify-center rounded-full border text-2xs font-semibold',
+          assistant
+            ? 'border-accent/40 bg-accent/15 text-accent'
+            : 'border-paper-300/70 bg-paper-200/80 text-ink-700'
+        ].join(' ')}
+      >
+        {authorInitial(reply)}
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="flex min-w-0 items-center gap-2">
+          <span data-comment-author className="truncate text-xs font-semibold text-ink-900">
+            {authorLabel(reply)}
+          </span>
+          <span className="shrink-0 text-2xs text-ink-400">
+            {dateFormatter.format(new Date(reply.createdAt))}
+          </span>
+        </div>
+        <div
+          className="comment-prose prose-zen mt-1 text-sm leading-5 text-ink-900"
+          dangerouslySetInnerHTML={{ __html: html }}
+        />
+      </div>
+    </div>
+  )
+}
+
+/** A small "reply" arrow, drawn inline so the panel stays icon-set agnostic. */
+function ReplyIcon({ width = 13, height = 13 }: { width?: number; height?: number }): JSX.Element {
+  return (
+    <svg
+      width={width}
+      height={height}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth={2}
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden="true"
+    >
+      <polyline points="9 17 4 12 9 7" />
+      <path d="M20 18v-2a4 4 0 0 0-4-4H4" />
+    </svg>
+  )
+}
+
 function IconTextButton({
   title,
   action,
diff --git a/packages/app-core/src/components/DatePickerHost.tsx b/packages/app-core/src/components/DatePickerHost.tsx
new file mode 100644
index 00000000..18367c5a
--- /dev/null
+++ b/packages/app-core/src/components/DatePickerHost.tsx
@@ -0,0 +1,32 @@
+import { lazy, Suspense, useEffect, useState } from 'react'
+import {
+  getDatePromptRequest,
+  settleDatePromptRequest,
+  subscribeDatePromptRequests,
+  type DatePromptRequest
+} from '../lib/date-prompt-requests'
+
+const DatePickerModal = lazy(async () => {
+  const module = await import('./DatePickerModal')
+  return { default: module.DatePickerModal }
+})
+
+export function DatePickerHost(): JSX.Element | null {
+  const [request, setRequest] = useState<DatePromptRequest | null>(getDatePromptRequest)
+
+  useEffect(() => {
+    return subscribeDatePromptRequests(setRequest)
+  }, [])
+
+  if (!request) return null
+
+  return (
+    <Suspense fallback={null}>
+      <DatePickerModal
+        options={request.options}
+        onSubmit={(iso) => settleDatePromptRequest(request, iso)}
+        onCancel={() => settleDatePromptRequest(request, null)}
+      />
+    </Suspense>
+  )
+}
diff --git a/packages/app-core/src/components/DatePickerModal.test.ts b/packages/app-core/src/components/DatePickerModal.test.ts
new file mode 100644
index 00000000..3ca45774
--- /dev/null
+++ b/packages/app-core/src/components/DatePickerModal.test.ts
@@ -0,0 +1,155 @@
+// @vitest-environment jsdom
+
+import { act, createElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useStore } from '../store'
+import { DatePickerModal, type DatePickerOptions } from './DatePickerModal'
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+function key(target: Element, key: string, init: KeyboardEventInit = {}): void {
+  act(() => {
+    target.dispatchEvent(new KeyboardEvent('keydown', { key, bubbles: true, cancelable: true, ...init }))
+  })
+}
+
+function cell(iso: string): HTMLButtonElement {
+  const el = document.querySelector<HTMLButtonElement>(`[data-date-cell="${iso}"]`)
+  if (!el) throw new Error(`no cell for ${iso}`)
+  return el
+}
+
+function selectedIso(): string | null {
+  return document.querySelector('[role="gridcell"][aria-selected="true"]')?.getAttribute('data-date-cell') ?? null
+}
+
+function monthShown(): string {
+  return document.querySelector('[data-date-picker-month]')?.textContent ?? ''
+}
+
+describe('DatePickerModal', () => {
+  let root: Root | null = null
+  let container: HTMLDivElement | null = null
+  const onSubmit = vi.fn<(iso: string) => void>()
+  const onCancel = vi.fn<() => void>()
+
+  function mount(options: DatePickerOptions): void {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+    act(() => {
+      root!.render(createElement(DatePickerModal, { options, onSubmit, onCancel }))
+    })
+  }
+
+  beforeEach(() => {
+    onSubmit.mockReset()
+    onCancel.mockReset()
+    useStore.setState({ vimMode: false, calendarWeekStart: 'monday' })
+  })
+
+  afterEach(() => {
+    act(() => root?.unmount())
+    container?.remove()
+    root = null
+    container = null
+  })
+
+  it('opens on the given day with that cell focused, and Enter inserts it', () => {
+    mount({ initialDate: '2026-09-08' })
+    expect(selectedIso()).toBe('2026-09-08')
+    expect(monthShown()).toBe('September 2026')
+    expect(document.activeElement).toBe(cell('2026-09-08'))
+    key(cell('2026-09-08'), 'Enter')
+    expect(onSubmit).toHaveBeenCalledWith('2026-09-08')
+  })
+
+  it('moves with arrows and paging, following the selection across months', () => {
+    mount({ initialDate: '2026-09-08' })
+    key(cell('2026-09-08'), 'ArrowRight')
+    expect(selectedIso()).toBe('2026-09-09')
+    key(cell('2026-09-09'), 'ArrowDown')
+    expect(selectedIso()).toBe('2026-09-16')
+    expect(document.activeElement).toBe(cell('2026-09-16'))
+    key(cell('2026-09-16'), 'PageDown')
+    expect(selectedIso()).toBe('2026-10-16')
+    expect(monthShown()).toBe('October 2026')
+    // A month change replaces every cell; focus must land on the new one,
+    // not fall to the body with the unmounted button.
+    expect(document.activeElement).toBe(cell('2026-10-16'))
+    key(cell('2026-10-16'), 'PageUp', { shiftKey: true })
+    expect(selectedIso()).toBe('2025-10-16')
+    expect(monthShown()).toBe('October 2025')
+    expect(document.activeElement).toBe(cell('2025-10-16'))
+    key(cell('2025-10-16'), 'Enter')
+    expect(onSubmit).toHaveBeenCalledWith('2025-10-16')
+  })
+
+  it('keeps letters inert with Vim mode off and makes them moves with it on', () => {
+    mount({ initialDate: '2026-09-08' })
+    key(cell('2026-09-08'), 'l')
+    expect(selectedIso()).toBe('2026-09-08')
+
+    act(() => useStore.setState({ vimMode: true }))
+    key(cell('2026-09-08'), 'l')
+    expect(selectedIso()).toBe('2026-09-09')
+    key(cell('2026-09-09'), 'j')
+    expect(selectedIso()).toBe('2026-09-16')
+  })
+
+  it('takes a typed date: the grid follows it and Enter inserts it', () => {
+    mount({ initialDate: '2026-09-08' })
+    const input = document.querySelector<HTMLInputElement>('input[aria-label="Date"]')!
+    // A digit pressed on the grid moves typing to the field, starting fresh.
+    key(cell('2026-09-08'), '2')
+    expect(document.activeElement).toBe(input)
+    expect(input.value).toBe('2')
+
+    const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!
+    act(() => {
+      setValue.call(input, '2027-03-14')
+      input.dispatchEvent(new Event('input', { bubbles: true }))
+    })
+    expect(selectedIso()).toBe('2027-03-14')
+    expect(monthShown()).toBe('March 2027')
+
+    key(input, 'Enter')
+    expect(onSubmit).toHaveBeenCalledWith('2027-03-14')
+  })
+
+  it('refuses a typed day that does not exist instead of inserting a rolled-over one', () => {
+    mount({ initialDate: '2026-09-08' })
+    const input = document.querySelector<HTMLInputElement>('input[aria-label="Date"]')!
+    const setValue = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!
+    act(() => {
+      setValue.call(input, '2026-02-30')
+      input.dispatchEvent(new Event('input', { bubbles: true }))
+    })
+    key(input, 'Enter')
+    expect(onSubmit).not.toHaveBeenCalled()
+    expect(document.body.textContent).toContain('Type a real date as YYYY-MM-DD.')
+    // The grid still stands on the last real day.
+    expect(selectedIso()).toBe('2026-09-08')
+  })
+
+  it('cancels from the footer and marks itself as a prompt for the key routers', () => {
+    mount({ initialDate: '2026-09-08' })
+    expect(document.querySelector('[data-prompt-modal]')).not.toBeNull()
+    const cancel = Array.from(document.querySelectorAll('button')).find(
+      (b) => b.textContent === 'Cancel'
+    )!
+    act(() => cancel.click())
+    expect(onCancel).toHaveBeenCalledTimes(1)
+    expect(onSubmit).not.toHaveBeenCalled()
+  })
+
+  it('falls back to today when the initial date is malformed', () => {
+    mount({ initialDate: 'yesterday' })
+    const now = new Date()
+    const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(
+      now.getDate()
+    ).padStart(2, '0')}`
+    expect(selectedIso()).toBe(today)
+  })
+})
diff --git a/packages/app-core/src/components/DatePickerModal.tsx b/packages/app-core/src/components/DatePickerModal.tsx
new file mode 100644
index 00000000..cc80c164
--- /dev/null
+++ b/packages/app-core/src/components/DatePickerModal.tsx
@@ -0,0 +1,266 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useStore } from '../store'
+import {
+  addMonths,
+  buildMonthGrid,
+  datePickerMoveForKey,
+  firstOfMonth,
+  formatISODate,
+  monthTitle,
+  moveDate,
+  parseISODate,
+  startOfDay
+} from '../lib/date-picker'
+import { isImeComposing } from '../lib/ime'
+import { resolveWeekStartDay } from '../lib/week-start'
+import { Modal } from './ui/Modal'
+import { Button } from './ui/Button'
+import { ChevronLeftIcon, ChevronRightIcon } from './icons'
+
+export interface DatePickerOptions {
+  title?: string
+  description?: string
+  /** `YYYY-MM-DD` the picker opens on; today when absent or malformed. */
+  initialDate?: string
+  okLabel?: string
+}
+
+const DAY_LABELS = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa']
+
+/**
+ * The calendar behind `@date` (#743). Keyboard first: it opens with the
+ * selected day focused, so arrows move and Enter inserts without a Tab
+ * anywhere; typing a digit from the grid jumps to the text field for a date
+ * typed outright. The grid always shows the month of the selected day, so a
+ * move can never land on a day the user cannot see. Carries
+ * `data-prompt-modal` like the text prompt so VimNav and the list views hand
+ * the keyboard over while it is open.
+ */
+export function DatePickerModal({
+  options,
+  onSubmit,
+  onCancel
+}: {
+  options: DatePickerOptions
+  onSubmit: (iso: string) => void
+  onCancel: () => void
+}): JSX.Element {
+  const vimMode = useStore((s) => s.vimMode)
+  const weekStart = useStore((s) => s.calendarWeekStart)
+  const firstDay = resolveWeekStartDay(weekStart)
+  const today = useMemo(() => startOfDay(new Date()), [])
+  const [selected, setSelected] = useState<Date>(
+    () => (options.initialDate ? parseISODate(options.initialDate) : null) ?? today
+  )
+  const [anchor, setAnchor] = useState<Date>(() => firstOfMonth(selected))
+  const [typed, setTyped] = useState(() => formatISODate(selected))
+  const [error, setError] = useState<string | null>(null)
+  const inputRef = useRef<HTMLInputElement>(null)
+  const gridRef = useRef<HTMLDivElement>(null)
+  const selectedCellRef = useRef<HTMLButtonElement>(null)
+  // Set by a keyboard move in the grid; the effect below consumes it.
+  const refocusGridRef = useRef(false)
+
+  const selectedIso = formatISODate(selected)
+  const todayIso = formatISODate(today)
+  const grid = useMemo(() => buildMonthGrid(anchor, firstDay), [anchor, firstDay])
+  const dayLabels = useMemo(
+    () => Array.from({ length: 7 }, (_, i) => DAY_LABELS[(firstDay + i) % 7]),
+    [firstDay]
+  )
+  // Roving tabindex: one cell is reachable by Tab, the selected day when the
+  // grid shows it, else the first of the month being browsed.
+  const tabbableIso = grid.some((day) => formatISODate(day) === selectedIso)
+    ? selectedIso
+    : formatISODate(anchor)
+
+  function select(next: Date): void {
+    setSelected(next)
+    setAnchor(firstOfMonth(next))
+    setTyped(formatISODate(next))
+    setError(null)
+  }
+
+  // A keyboard move re-renders the grid with a new selected cell; put focus
+  // on it so the next arrow continues from there. A move into another month
+  // replaces every cell, which drops focus to the body before this effect
+  // runs, so the decision to refocus is recorded by the move itself rather
+  // than read from where focus happens to be.
+  useEffect(() => {
+    if (!refocusGridRef.current) return
+    refocusGridRef.current = false
+    selectedCellRef.current?.focus()
+  }, [selectedIso])
+
+  function submitTyped(): void {
+    const parsed = parseISODate(typed.trim())
+    if (!parsed) {
+      setError('Type a real date as YYYY-MM-DD.')
+      return
+    }
+    onSubmit(formatISODate(parsed))
+  }
+
+  const hint = vimMode
+    ? 'h j k l or arrows move, t is today. PageUp/PageDown change the month, with Shift the year. Enter inserts.'
+    : 'Arrows move. PageUp/PageDown change the month, with Shift the year. Enter inserts.'
+
+  return (
+    <Modal
+      size="xs"
+      layer="modal"
+      onClose={onCancel}
+      initialFocus={selectedCellRef}
+      data={{ 'data-prompt-modal': '', 'data-date-picker': '' }}
+    >
+      <Modal.Header title={options.title ?? 'Insert date'} description={options.description} />
+      <div className="px-5 pt-3">
+        <input
+          ref={inputRef}
+          value={typed}
+          placeholder="YYYY-MM-DD"
+          aria-label="Date"
+          spellCheck={false}
+          autoComplete="off"
+          onChange={(e) => {
+            const value = e.target.value
+            setTyped(value)
+            setError(null)
+            // The grid follows a complete date as it is typed; partial input
+            // leaves the last valid day selected.
+            const parsed = parseISODate(value.trim())
+            if (parsed) {
+              setSelected(parsed)
+              setAnchor(firstOfMonth(parsed))
+            }
+          }}
+          onKeyDown={(e) => {
+            if (isImeComposing(e)) return
+            if (e.key === 'Enter') {
+              e.preventDefault()
+              submitTyped()
+            } else if (e.key === 'ArrowDown') {
+              e.preventDefault()
+              gridRef.current
+                ?.querySelector<HTMLButtonElement>(`[data-date-cell="${tabbableIso}"]`)
+                ?.focus()
+            }
+          }}
+          className="w-full rounded-md border border-paper-300 bg-paper-50 px-2.5 py-1.5 text-sm text-ink-900 outline-none focus:border-accent"
+        />
+        {error && <div className="mt-2 text-xs text-danger">{error}</div>}
+        <div className="mt-3 flex items-center justify-between">
+          <button
+            type="button"
+            onClick={() => setAnchor((a) => addMonths(a, -1))}
+            className="rounded p-1 text-ink-500 transition-colors hover:bg-paper-200 hover:text-ink-800"
+            aria-label="Previous month"
+          >
+            <ChevronLeftIcon className="h-4 w-4" />
+          </button>
+          <span data-date-picker-month className="text-sm font-medium text-ink-800">
+            {monthTitle(anchor)}
+          </span>
+          <button
+            type="button"
+            onClick={() => setAnchor((a) => addMonths(a, 1))}
+            className="rounded p-1 text-ink-500 transition-colors hover:bg-paper-200 hover:text-ink-800"
+            aria-label="Next month"
+          >
+            <ChevronRightIcon className="h-4 w-4" />
+          </button>
+        </div>
+        <div
+          ref={gridRef}
+          role="grid"
+          aria-label="Calendar"
+          className="mt-2 grid grid-cols-7 gap-y-1"
+          onKeyDown={(e) => {
+            if (isImeComposing(e)) return
+            if (e.metaKey || e.ctrlKey || e.altKey) return
+            if (e.key === 'Enter' || e.key === ' ') {
+              e.preventDefault()
+              onSubmit(selectedIso)
+              return
+            }
+            if (/^\d$/.test(e.key)) {
+              // A digit means "let me type it": hand the keystroke to the
+              // text field as the first character of a fresh date.
+              e.preventDefault()
+              setTyped(e.key)
+              setError(null)
+              inputRef.current?.focus()
+              return
+            }
+            const move = datePickerMoveForKey(e.key, { shift: e.shiftKey, vimMode })
+            if (!move) return
+            e.preventDefault()
+            refocusGridRef.current = true
+            select(moveDate(selected, move, firstDay, today))
+          }}
+        >
+          {dayLabels.map((label, i) => (
+            <div
+              key={`${label}-${i}`}
+              role="columnheader"
+              className="text-center text-2xs font-medium uppercase text-ink-400"
+            >
+              {label}
+            </div>
+          ))}
+          {grid.map((day) => {
+            const iso = formatISODate(day)
+            const inMonth = day.getMonth() === anchor.getMonth()
+            const isSelected = iso === selectedIso
+            const isToday = iso === todayIso
+            return (
+              <button
+                key={iso}
+                ref={isSelected ? selectedCellRef : undefined}
+                type="button"
+                role="gridcell"
+                aria-selected={isSelected}
+                data-date-cell={iso}
+                tabIndex={iso === tabbableIso ? 0 : -1}
+                onClick={() => {
+                  select(day)
+                  onSubmit(iso)
+                }}
+                className={[
+                  'flex h-8 items-center justify-center rounded text-sm transition-colors',
+                  isSelected
+                    ? 'bg-accent font-semibold text-white'
+                    : isToday
+                      ? 'font-semibold text-accent ring-1 ring-inset ring-accent/50 hover:bg-paper-200'
+                      : inMonth
+                        ? 'text-ink-700 hover:bg-paper-200'
+                        : 'text-ink-400 hover:bg-paper-200'
+                ].join(' ')}
+              >
+                {day.getDate()}
+              </button>
+            )
+          })}
+        </div>
+        <div className="mt-3 flex items-start justify-between gap-3 text-xs text-ink-400">
+          <span>{hint}</span>
+          <button
+            type="button"
+            onClick={() => select(today)}
+            className="shrink-0 rounded px-1.5 py-0.5 text-ink-500 transition-colors hover:bg-paper-200 hover:text-accent"
+          >
+            Today
+          </button>
+        </div>
+      </div>
+      <Modal.Footer>
+        <Button variant="secondary" onClick={onCancel}>
+          Cancel
+        </Button>
+        <Button variant="primary" onClick={() => onSubmit(selectedIso)}>
+          {options.okLabel ?? 'Insert'}
+        </Button>
+      </Modal.Footer>
+    </Modal>
+  )
+}
diff --git a/packages/app-core/src/components/Editor.tsx b/packages/app-core/src/components/Editor.tsx
index 3ebf60e4..6616b3dd 100644
--- a/packages/app-core/src/components/Editor.tsx
+++ b/packages/app-core/src/components/Editor.tsx
@@ -63,10 +63,15 @@ import { focusPaneInDirection, focusPaneOrEdgePanel } from "../lib/pane-nav";
 import { requestPaneMode } from "../lib/pane-mode";
 import {
   getKeymapBinding,
+  getKeymapDefinitions,
+  getKeymapDisplay,
   getSequenceTokens,
+  UNBOUND_BINDING,
   type KeymapId,
   type KeymapOverrides,
 } from "../lib/keymaps";
+import { requestSettingsTarget } from "../lib/settings-navigation";
+import { useToastStore } from "../lib/toast";
 import {
   navigateActiveBuffer,
   selectActiveBuffer,
@@ -559,6 +564,59 @@ function registerVimCommands(): void {
       else state.setHarperEnabled(!state.harperEnabled);
     },
   );
+  // `:ignorekey <name>` (#732) adds a key the app should never see, the ex
+  // twin of Settings, Keymap, Ignored keys: a remapper's tap-hold no-op such
+  // as KanaMode. Bare, it opens that page, whose recorder names the key.
+  Vim.defineEx(
+    "ignorekey",
+    "ignorekey",
+    (_cm: unknown, params: { argString?: string } | undefined) => {
+      const arg = (params?.argString ?? "").trim();
+      const state = useStore.getState();
+      if (!arg) {
+        requestSettingsTarget("keymaps");
+        state.setSettingsOpen(true);
+        return;
+      }
+      state.addIgnoredKey(arg);
+      useToastStore
+        .getState()
+        .addToast(`Ignoring ${arg}: the app no longer reacts to it`, "success");
+    },
+  );
+  // `:unbind <action.id>` removes an action's key entirely, the ex twin of
+  // the Unbind button under Settings, Keymaps. Without an argument, or with
+  // an id the catalog does not know, it opens that page, where every id is
+  // listed, instead of guessing.
+  Vim.defineEx(
+    "unbind",
+    "unbind",
+    (_cm: unknown, params: { argString?: string } | undefined) => {
+      const arg = (params?.argString ?? "").trim();
+      const state = useStore.getState();
+      const definition = getKeymapDefinitions().find((d) => d.id === arg);
+      if (!definition) {
+        if (arg) {
+          useToastStore
+            .getState()
+            .addToast(`No keymap action is called "${arg}"`, "info");
+        }
+        requestSettingsTarget("keymaps");
+        state.setSettingsOpen(true);
+        return;
+      }
+      const before = getKeymapDisplay(state.keymapOverrides, definition.id);
+      state.setKeymapBinding(definition.id, UNBOUND_BINDING);
+      useToastStore
+        .getState()
+        .addToast(
+          before
+            ? `Unbound ${definition.title} (was ${before})`
+            : `${definition.title} is already unbound`,
+          "success",
+        );
+    },
+  );
   Vim.defineEx("quit", "q", () => {
     const state = useStore.getState();
     if (isTasksViewActive(state)) {
@@ -1174,6 +1232,7 @@ const MANUAL_EX_NAMES = new Set([
   "q",
   "wq",
   "format",
+  "unbind",
   "tasks",
   "tag",
   "template",
diff --git a/packages/app-core/src/components/EditorPane.tsx b/packages/app-core/src/components/EditorPane.tsx
index 5b3d6425..74ba1992 100644
--- a/packages/app-core/src/components/EditorPane.tsx
+++ b/packages/app-core/src/components/EditorPane.tsx
@@ -65,7 +65,7 @@ import { toggleCheckbox } from '../lib/cm-toggle-checkbox'
 import { completionKeymapExtension, completionNavKeymap } from '../lib/cm-completion-nav'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { isVimAwaitingArgument } from '../lib/vim-nav'
-import { toCodeMirrorKey, vimHalfPageKeymap } from '../lib/vim-half-page-keymap'
+import { keyBindingsFor, vimHalfPageKeymap } from '../lib/vim-half-page-keymap'
 import { scrollOff } from '../lib/cm-scrolloff'
 import { followLinkTarget } from '../lib/follow-link'
 import { pointerOverRange } from '../lib/cm-pointer-range'
@@ -289,6 +289,7 @@ import {
   formatKeyToken,
   getKeymapBinding,
   getKeymapDisplay,
+  labelWithShortcut,
   type KeymapId,
   type KeymapOverrides
 } from '../lib/keymaps'
@@ -345,44 +346,20 @@ function buildEditorKeymap(vimMode: boolean, overrides: KeymapOverrides): Extens
     // Move the current line (or selection) up/down — reorders the markdown so
     // it persists in the file. Listed before defaultKeymap so the configured
     // binding wins; works in Vim normal/insert and non-Vim alike.
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.moveLineUp')),
-      run: moveLineUp
-    },
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.moveLineDown')),
-      run: moveLineDown
-    },
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.moveLineUp'), moveLineUp),
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.moveLineDown'), moveLineDown),
     // Obsidian-style checkbox toggle: line -> `- [ ]` -> `[x]` and back.
     // Mode-agnostic like the line moves.
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.toggleCheckbox')),
-      run: toggleCheckbox
-    },
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.toggleCheckbox'), toggleCheckbox),
     // Join a hard-wrapped paragraph back into one line so the pane wraps it
     // (#676). Mode-agnostic like the line moves; Vim mode also has `gq`.
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.reflowParagraph')),
-      run: reflowParagraph
-    },
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.reflowParagraph'), reflowParagraph),
     // Step across inline markers, so a formatted word can be finished without
     // reaching for the arrow keys. Mode-agnostic like the line moves. (#490)
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.hopMarkerForward')),
-      run: markerHop.forward
-    },
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.hopMarkerBackward')),
-      run: markerHop.backward
-    },
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.foldHeading')),
-      run: foldHeadingAtCursor
-    },
-    {
-      key: toCodeMirrorKey(getKeymapBinding(overrides, 'editor.unfoldHeading')),
-      run: unfoldHeadingAtCursor
-    },
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.hopMarkerForward'), markerHop.forward),
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.hopMarkerBackward'), markerHop.backward),
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.foldHeading'), foldHeadingAtCursor),
+    ...keyBindingsFor(getKeymapBinding(overrides, 'editor.unfoldHeading'), unfoldHeadingAtCursor),
     // Inline-format shortcuts (bold/italic/code/strike/highlight/math/link). In
     // Vim mode VimNav owns these (its window handler also resolves the Ctrl+I
     // jumplist collision on Linux); in non-Vim mode that handler is disabled, so
@@ -586,8 +563,10 @@ function buildCommentDecorations(
 ): DecorationSet {
   const lineMarkerCounts = new Map<number, number>()
   const decoratedLines = new Set<number>()
+  // Top-level comments only: a reply shares its thread's anchor (#738), so
+  // drawing it too would double every marker and highlight.
   const ranges = comments
-    .filter((comment) => comment.resolvedAt == null)
+    .filter((comment) => comment.resolvedAt == null && !comment.parentId)
     .flatMap((comment) => {
       const anchor = resolveCommentAnchor(comment, doc)
       if (anchor.to <= anchor.from) return []
@@ -3725,10 +3704,10 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element {
               </IconBtn>
             )}
             <IconBtn
-              title={`Go back (${getKeymapDisplay(
-                tabNavOverrides,
-                vimMode ? 'vim.historyBack' : 'global.historyBack'
-              )})`}
+              title={labelWithShortcut(
+                'Go back',
+                getKeymapDisplay(tabNavOverrides, vimMode ? 'vim.historyBack' : 'global.historyBack')
+              )}
               onClick={() => void jumpToPreviousNote()}
               disabled={!canGoBack}
               tooltipAlign="left"
@@ -3736,10 +3715,10 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element {
               <ArrowLeftIcon width={16} height={16} />
             </IconBtn>
             <IconBtn
-              title={`Go forward (${getKeymapDisplay(
-                tabNavOverrides,
-                vimMode ? 'vim.historyForward' : 'global.historyForward'
-              )})`}
+              title={labelWithShortcut(
+                'Go forward',
+                getKeymapDisplay(tabNavOverrides, vimMode ? 'vim.historyForward' : 'global.historyForward')
+              )}
               onClick={() => void jumpToNextNote()}
               disabled={!canGoForward}
               tooltipAlign="left"
@@ -4365,13 +4344,16 @@ function ToggleGroup({
   return (
     <div className="flex items-center gap-1 rounded-md bg-paper-200/70 p-0.5 text-xs">
       {MODE_OPTIONS.map((option) => {
-        const shortcut = getKeymapDisplay(keymapOverrides, option.keymapId)
+        const label = labelWithShortcut(
+          option.tooltipLabel,
+          getKeymapDisplay(keymapOverrides, option.keymapId)
+        )
         return (
           <button
             key={option.mode}
             onClick={() => onChange(option.mode)}
-            title={`${option.tooltipLabel} (${shortcut})`}
-            aria-label={`${option.tooltipLabel} (${shortcut})`}
+            title={label}
+            aria-label={label}
             className={[
               'rounded px-2 py-1 transition-colors',
               mode === option.mode
diff --git a/packages/app-core/src/components/HelpView.tsx b/packages/app-core/src/components/HelpView.tsx
index 484c9f7f..0ff3c58c 100644
--- a/packages/app-core/src/components/HelpView.tsx
+++ b/packages/app-core/src/components/HelpView.tsx
@@ -1,7 +1,12 @@
 import { useDeferredValue, useMemo, useState } from 'react'
 import { useStore } from '../store'
 import { buildCommands, type Command } from '../lib/commands'
-import { getKeymapDisplay, type KeymapId, type KeymapOverrides } from '../lib/keymaps'
+import {
+  getKeymapDisplay,
+  UNBOUND_LABEL,
+  type KeymapId,
+  type KeymapOverrides
+} from '../lib/keymaps'
 import {
   HELP_CLI,
   HELP_CORE_CONCEPTS,
@@ -26,16 +31,29 @@ interface CommandGroup {
   commands: Command[]
 }
 
+// The manual names an unbound action as such where the palette leaves the
+// key out: someone looking up "how do I open the outline" should learn that
+// the key was removed, not meet an empty cell.
 function shortcut(overrides: KeymapOverrides, id: KeymapId): string {
-  return getKeymapDisplay(overrides, id)
+  return getKeymapDisplay(overrides, id) || UNBOUND_LABEL
+}
+
+/** The steps of one chord; a single unbound step makes the chord unbound. */
+function chord(...steps: string[]): string {
+  return steps.includes(UNBOUND_LABEL) ? UNBOUND_LABEL : steps.join(' ')
+}
+
+/** Alternatives shown side by side; the unbound ones drop out. */
+function alternatives(keys: string[]): string {
+  return keys.filter((key) => key !== UNBOUND_LABEL).join(' / ') || UNBOUND_LABEL
 }
 
 function leaderShortcut(overrides: KeymapOverrides, id: KeymapId): string {
-  return `${shortcut(overrides, 'vim.leaderPrefix')} ${shortcut(overrides, id)}`
+  return chord(shortcut(overrides, 'vim.leaderPrefix'), shortcut(overrides, id))
 }
 
 function paneShortcut(overrides: KeymapOverrides, id: KeymapId): string {
-  return `${shortcut(overrides, 'vim.panePrefix')} ${shortcut(overrides, id)}`
+  return chord(shortcut(overrides, 'vim.panePrefix'), shortcut(overrides, id))
 }
 
 function resolveShortcutKeys(
@@ -62,19 +80,22 @@ function resolveShortcutKeys(
 
   if (sectionId === 'panel-motion') {
     if (action === 'Move focus') {
-      return [
+      return alternatives([
         paneShortcut(overrides, 'vim.paneFocusLeft'),
         paneShortcut(overrides, 'vim.paneFocusDown'),
         paneShortcut(overrides, 'vim.paneFocusUp'),
         paneShortcut(overrides, 'vim.paneFocusRight')
-      ].join(' / ')
+      ])
     }
     if (action === 'Split right') return paneShortcut(overrides, 'vim.paneSplitRight')
     if (action === 'Split down') return paneShortcut(overrides, 'vim.paneSplitDown')
     if (action === 'Open buffers') return leaderShortcut(overrides, 'vim.leaderOpenBuffers')
     if (action === 'Search notes') return leaderShortcut(overrides, 'vim.leaderSearchNotes')
     if (action === 'Search vault text') {
-      return `${leaderShortcut(overrides, 'vim.leaderSearchGroup')} ${shortcut(overrides, 'vim.leaderSearchVaultText')}`
+      return chord(
+        leaderShortcut(overrides, 'vim.leaderSearchGroup'),
+        shortcut(overrides, 'vim.leaderSearchVaultText')
+      )
     }
     if (action === 'Toggle left sidebar') return leaderShortcut(overrides, 'vim.leaderToggleSidebar')
     if (action === 'Note outline') return leaderShortcut(overrides, 'vim.leaderNoteOutline')
@@ -83,13 +104,16 @@ function resolveShortcutKeys(
     if (action === 'Review Cloud conflicts') {
       return leaderShortcut(overrides, 'vim.leaderCloudConflicts')
     }
-    if (action === 'Show leader hints') return `${shortcut(overrides, 'vim.leaderPrefix')}, then pause`
+    if (action === 'Show leader hints') {
+      const leader = shortcut(overrides, 'vim.leaderPrefix')
+      return leader === UNBOUND_LABEL ? leader : `${leader}, then pause`
+    }
     if (action === 'Toggle outline panel') return shortcut(overrides, 'global.toggleOutlinePanel')
     if (action === 'Fold / unfold heading') {
-      return `${shortcut(overrides, 'vim.foldCurrent')} / ${shortcut(overrides, 'vim.unfoldCurrent')}`
+      return alternatives([shortcut(overrides, 'vim.foldCurrent'), shortcut(overrides, 'vim.unfoldCurrent')])
     }
     if (action === 'Fold / unfold all') {
-      return `${shortcut(overrides, 'vim.foldAll')} / ${shortcut(overrides, 'vim.unfoldAll')}`
+      return alternatives([shortcut(overrides, 'vim.foldAll'), shortcut(overrides, 'vim.unfoldAll')])
     }
     if (action === 'Go back') return shortcut(overrides, 'vim.historyBack')
     if (action === 'Go forward') return shortcut(overrides, 'vim.historyForward')
@@ -98,12 +122,12 @@ function resolveShortcutKeys(
 
   if (sectionId === 'lists-and-sidebar') {
     if (action === 'Move selection') {
-      return `${shortcut(overrides, 'nav.moveDown')} / ${shortcut(overrides, 'nav.moveUp')}`
+      return alternatives([shortcut(overrides, 'nav.moveDown'), shortcut(overrides, 'nav.moveUp')])
     }
     if (action === 'Jump to top or bottom') {
-      return `${shortcut(overrides, 'nav.jumpTop')} / ${shortcut(overrides, 'nav.jumpBottom')}`
+      return alternatives([shortcut(overrides, 'nav.jumpTop'), shortcut(overrides, 'nav.jumpBottom')])
     }
-    if (action === 'Open item') return `Enter / ${shortcut(overrides, 'nav.openSideItem')}`
+    if (action === 'Open item') return alternatives(['Enter', shortcut(overrides, 'nav.openSideItem')])
     if (action === 'Collapse or move left') return shortcut(overrides, 'nav.back')
     if (action === 'Toggle folder') return shortcut(overrides, 'nav.toggleFolder')
     if (action === 'Search notes') return shortcut(overrides, 'nav.filter')
@@ -112,17 +136,17 @@ function resolveShortcutKeys(
 
   if (sectionId === 'preview-and-connections') {
     if (action === 'Scroll preview') {
-      return `${shortcut(overrides, 'nav.moveDown')} / ${shortcut(overrides, 'nav.moveUp')}`
+      return alternatives([shortcut(overrides, 'nav.moveDown'), shortcut(overrides, 'nav.moveUp')])
     }
     if (action === 'Half-page scroll') {
-      return `${shortcut(overrides, 'nav.halfPageDown')} / ${shortcut(overrides, 'nav.halfPageUp')}`
+      return alternatives([shortcut(overrides, 'nav.halfPageDown'), shortcut(overrides, 'nav.halfPageUp')])
     }
     if (action === 'Jump to top or bottom') {
-      return `${shortcut(overrides, 'nav.jumpTop')} / ${shortcut(overrides, 'nav.jumpBottom')}`
+      return alternatives([shortcut(overrides, 'nav.jumpTop'), shortcut(overrides, 'nav.jumpBottom')])
     }
     if (action === 'Search notes') return shortcut(overrides, 'nav.filter')
     if (action === 'Peek backlink') return shortcut(overrides, 'nav.peekPreview')
-    if (action === 'Back out') return `${shortcut(overrides, 'nav.back')} / Esc`
+    if (action === 'Back out') return alternatives([shortcut(overrides, 'nav.back'), 'Esc'])
   }
 
   return null
@@ -131,15 +155,22 @@ function resolveShortcutKeys(
 function resolveVimCommandLabel(command: string, overrides: KeymapOverrides): string {
   if (command === 'gd') return shortcut(overrides, 'vim.goToDefinition')
   if (command === '<Space> l f') {
-    return `${leaderShortcut(overrides, 'vim.leaderNoteActions')} ${shortcut(overrides, 'vim.leaderFormatNote')}`
+    return chord(
+      leaderShortcut(overrides, 'vim.leaderNoteActions'),
+      shortcut(overrides, 'vim.leaderFormatNote')
+    )
   }
   if (command === '<Space> (pause)') {
-    return `${shortcut(overrides, 'vim.leaderPrefix')} (pause)`
+    const leader = shortcut(overrides, 'vim.leaderPrefix')
+    return leader === UNBOUND_LABEL ? leader : `${leader} (pause)`
   }
   if (command === '<Space> o') return leaderShortcut(overrides, 'vim.leaderOpenBuffers')
   if (command === '<Space> f') return leaderShortcut(overrides, 'vim.leaderSearchNotes')
   if (command === '<Space> s t') {
-    return `${leaderShortcut(overrides, 'vim.leaderSearchGroup')} ${shortcut(overrides, 'vim.leaderSearchVaultText')}`
+    return chord(
+      leaderShortcut(overrides, 'vim.leaderSearchGroup'),
+      shortcut(overrides, 'vim.leaderSearchVaultText')
+    )
   }
   if (command === '<Space> e') return leaderShortcut(overrides, 'vim.leaderToggleSidebar')
   if (command === '<Space> p') return leaderShortcut(overrides, 'vim.leaderNoteOutline')
@@ -576,12 +607,20 @@ export function HelpView(): JSX.Element {
                     <CalloutCard
                       icon={<CheckSquareIcon width={16} height={16} className="text-accent" />}
                       title="Tasks and Tags have local ex prompts"
-                      body={`Inside Tasks or Tags, press \`${shortcut(keymapOverrides, 'nav.localEx')}\` to open the local command line for view-specific actions like close, split, refresh, and retagging.`}
+                      body={
+                        shortcut(keymapOverrides, 'nav.localEx') === UNBOUND_LABEL
+                          ? 'Inside Tasks or Tags, the local command line (nav.localEx) has no key right now; give it one under Settings, Keymaps to reach view-specific actions like close, split, refresh, and retagging.'
+                          : `Inside Tasks or Tags, press \`${shortcut(keymapOverrides, 'nav.localEx')}\` to open the local command line for view-specific actions like close, split, refresh, and retagging.`
+                      }
                     />
                     <CalloutCard
                       icon={<TagIcon width={16} height={16} className="text-accent" />}
                       title="Link following is context-aware"
-                      body={`\`${shortcut(keymapOverrides, 'vim.goToDefinition')}\` opens existing notes, external links, or PDFs. Missing wikilinks can create new notes directly from the ex-aware workflow.`}
+                      body={
+                        shortcut(keymapOverrides, 'vim.goToDefinition') === UNBOUND_LABEL
+                          ? 'Following the link at the cursor (vim.goToDefinition) has no key right now; give it one under Settings, Keymaps. It opens existing notes, external links, or PDFs, and missing wikilinks can create new notes directly from the ex-aware workflow.'
+                          : `\`${shortcut(keymapOverrides, 'vim.goToDefinition')}\` opens existing notes, external links, or PDFs. Missing wikilinks can create new notes directly from the ex-aware workflow.`
+                      }
                     />
                   </div>
                 </div>
diff --git a/packages/app-core/src/components/SettingsModal.test.ts b/packages/app-core/src/components/SettingsModal.test.ts
index 116b0844..48303f96 100644
--- a/packages/app-core/src/components/SettingsModal.test.ts
+++ b/packages/app-core/src/components/SettingsModal.test.ts
@@ -28,12 +28,12 @@ const mocks = vi.hoisted(() => {
       hiddenWorkflowPresets: [],
       hideBuiltinTemplates: false,
       interfaceFont: null,
-      keymapOverrides: {},
+      keymapOverrides: {} as Record<string, string>,
       lineNumberMode: "off",
       monoFont: null,
       previewMaxWidth: 760,
       quickNoteTitlePrefix: null,
-      remoteWorkspaceInfo: null,
+      remoteWorkspaceInfo: null as null | { mode: string; baseUrl: string | null; authConfigured: boolean; capabilities: Record<string, unknown> | null; profileId: string | null; bootError: string | null },
       remoteWorkspaceProfiles: [],
       ripgrepBinaryPath: null,
       setSettingsOpen: vi.fn(),
@@ -60,10 +60,11 @@ const mocks = vi.hoisted(() => {
       vimMode: false,
       vimWrappedLineMotions: "logical",
       setVimWrappedLineMotions: vi.fn(),
+      setKeymapBinding: vi.fn(),
       whichKeyHintMode: "timed",
       whichKeyHintTimeoutMs: 1200,
       whichKeyHints: true,
-      workspaceMode: "local",
+      workspaceMode: "local" as "local" | "remote",
     },
     {
       get(target, property: string) {
@@ -132,6 +133,9 @@ describe("SettingsModal date note directories", () => {
     vi.clearAllMocks();
     mocks.state.vimMode = false;
     mocks.state.vimWrappedLineMotions = "logical";
+    mocks.state.keymapOverrides = {};
+    mocks.state.workspaceMode = "local";
+    mocks.state.remoteWorkspaceInfo = null;
     (
       globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
     ).IS_REACT_ACT_ENVIRONMENT = true;
@@ -301,4 +305,104 @@ describe("SettingsModal date note directories", () => {
     expect(host.textContent).toContain("Keep your vault available everywhere");
     expect(host.textContent).toContain("Connect ZenNotes Cloud");
   });
+  async function openKeymapRow(title: string): Promise<HTMLElement> {
+    await act(async () => {
+      root.render(createElement(SettingsModal));
+    });
+    const keymapButton = [
+      ...host.querySelectorAll<HTMLButtonElement>("button"),
+    ].find((button) => button.textContent?.trim() === "Keymap");
+    expect(keymapButton).toBeTruthy();
+    await act(async () => keymapButton!.click());
+    const filter = host.querySelector<HTMLInputElement>(
+      'input[placeholder="Filter keymaps…"]',
+    );
+    expect(filter).toBeTruthy();
+    await act(async () => changeInput(filter!, title));
+    const label = [...host.querySelectorAll<HTMLSpanElement>("span")].find(
+      (span) => span.textContent === title,
+    );
+    expect(label).toBeTruthy();
+    const row = label!.closest<HTMLElement>(".justify-between");
+    expect(row).toBeTruthy();
+    return row!;
+  }
+
+  function rowButton(row: HTMLElement, text: string): HTMLButtonElement {
+    const button = [...row.querySelectorAll<HTMLButtonElement>("button")].find(
+      (candidate) => candidate.textContent?.trim() === text,
+    );
+    expect(button, `${text} button`).toBeTruthy();
+    return button!;
+  }
+
+  it("unbinds a keymap from its row with an empty-string override", async () => {
+    const row = await openKeymapRow("Zoom in");
+    const unbind = rowButton(row, "Unbind");
+    expect(unbind.disabled).toBe(false);
+    await act(async () => unbind.click());
+    expect(mocks.state.setKeymapBinding).toHaveBeenCalledWith(
+      "global.zoomIn",
+      "",
+    );
+  });
+
+  it("shows an unbound keymap as Unbound and only offers Reset or Change", async () => {
+    mocks.state.keymapOverrides = { "global.zoomIn": "" };
+    const row = await openKeymapRow("Zoom in");
+    expect(row.textContent).toContain("Unbound");
+    expect(rowButton(row, "Unbind").disabled).toBe(true);
+    expect(rowButton(row, "Reset").disabled).toBe(false);
+
+    await act(async () => rowButton(row, "Change…").click());
+    const recorder = document.body.textContent ?? "";
+    expect(recorder).toContain("Current: Unbound");
+  });
+  async function openTemplatesSection(): Promise<void> {
+    await act(async () => {
+      root.render(createElement(SettingsModal));
+    });
+    const templatesButton = [
+      ...host.querySelectorAll<HTMLButtonElement>("button"),
+    ].find((button) => button.textContent?.trim() === "Templates");
+    expect(templatesButton).toBeTruthy();
+    await act(async () => templatesButton!.click());
+  }
+
+  function newTemplateButton(): HTMLButtonElement | undefined {
+    return [...host.querySelectorAll<HTMLButtonElement>("button")].find(
+      (button) => button.textContent?.trim() === "New template",
+    );
+  }
+
+  it("offers custom templates on a remote vault whose server advertises them (#723)", async () => {
+    mocks.state.workspaceMode = "remote";
+    mocks.state.remoteWorkspaceInfo = {
+      mode: "remote",
+      baseUrl: "http://localhost:7878",
+      authConfigured: true,
+      capabilities: { supportsCustomTemplates: true },
+      profileId: null,
+      bootError: null,
+    };
+    await openTemplatesSection();
+    expect(newTemplateButton()).toBeTruthy();
+    expect(host.textContent).not.toContain("need ZenNotes server 2.46");
+  });
+
+  it("keeps templates read-only on a remote vault behind an older server", async () => {
+    mocks.state.workspaceMode = "remote";
+    mocks.state.remoteWorkspaceInfo = {
+      mode: "remote",
+      baseUrl: "http://localhost:7878",
+      authConfigured: true,
+      capabilities: { supportsWorkflows: true },
+      profileId: null,
+      bootError: null,
+    };
+    await openTemplatesSection();
+    expect(newTemplateButton()).toBeUndefined();
+    expect(host.textContent).toContain("need ZenNotes server 2.46 or later");
+    expect(host.textContent).toContain("reconnect this workspace");
+  });
 });
diff --git a/packages/app-core/src/components/SettingsModal.tsx b/packages/app-core/src/components/SettingsModal.tsx
index 2ce2ae24..e3d824d6 100644
--- a/packages/app-core/src/components/SettingsModal.tsx
+++ b/packages/app-core/src/components/SettingsModal.tsx
@@ -65,8 +65,11 @@ import {
   getKeymapDefinitionsByGroup,
   getKeymapDisplay,
   isMacPlatform,
+  isUnboundBinding,
   sequenceTokenFromEvent,
   shortcutBindingFromEvent,
+  UNBOUND_BINDING,
+  UNBOUND_LABEL,
 } from "../lib/keymaps";
 import {
   resolveAuto,
@@ -129,6 +132,10 @@ import { promptApp } from "../lib/prompt-requests";
 import { isImeComposing } from "../lib/ime";
 import { RemoteWorkspaceProfileModal } from "./RemoteWorkspaceProfileModal";
 import { Button } from "./ui/Button";
+import {
+  ignoredKeyTokenFromEvent,
+  setIgnoredKeysRecorderActive,
+} from "../lib/ignored-keys";
 import { CustomCodeLanguagesSettings } from "./CustomCodeLanguagesSettings";
 import { TextReplacementsSettings } from "./TextReplacementsSettings";
 import { CloudSettings } from "./CloudSettings";
@@ -594,9 +601,14 @@ export function SettingsModal(): JSX.Element {
       ),
     [customTemplates, hideBuiltinTemplates],
   );
+  // A local vault's templates are a host feature (the desktop has a disk, the
+  // web client asks its server); a remote vault's are the server's, advertised
+  // since 2.46 (#723). The store keeps remoteWorkspaceInfo fresh across
+  // connects and disconnects, so this re-renders with it.
   const supportsCustomTemplates =
-    zenBridge.getCapabilities().supportsCustomTemplates &&
-    workspaceMode !== "remote";
+    workspaceMode === "remote"
+      ? remoteWorkspaceInfo?.capabilities?.supportsCustomTemplates === true
+      : zenBridge.getCapabilities().supportsCustomTemplates === true;
   const supportsCustomCodeLanguages =
     !!zenBridge.getCapabilities().supportsCustomCodeLanguages;
   const [templateEditor, setTemplateEditor] = useState<{
@@ -2843,6 +2855,24 @@ export function SettingsModal(): JSX.Element {
       description: "Remap global shortcuts, Vim bindings, and view navigation.",
       keywords: ["shortcuts", "bindings", "leader", "vim", "remap", "keyboard"],
       searchItems: [
+        {
+          id: "ignored-keys",
+          title: "Ignored keys",
+          description:
+            "Keys the app never sees, such as the no-op a Kanata or QMK tap-hold layer sends with every keystroke.",
+          keywords: [
+            "ignore",
+            "ignored",
+            "no-op",
+            "noop",
+            "kanata",
+            "qmk",
+            "zmk",
+            "tap-hold",
+            "home row",
+            "kanamode",
+          ],
+        },
         {
           id: "shortcut-editor",
           title: "Shortcut editor",
@@ -2904,6 +2934,22 @@ export function SettingsModal(): JSX.Element {
             "workflow",
           ],
         },
+        {
+          id: "kanban-folder-root",
+          title: "Folder board root",
+          description:
+            "Group the Tasks Kanban Folder board by the folders inside one folder, such as Projects, instead of each note's own folder.",
+          keywords: [
+            "kanban",
+            "folder",
+            "board",
+            "group",
+            "projects",
+            "root",
+            "column",
+            "directory",
+          ],
+        },
         {
           id: "show-archived-tasks",
           title: "Show tasks from archived notes",
@@ -2944,6 +2990,12 @@ export function SettingsModal(): JSX.Element {
           >
             <KanbanStatusesRow settingId="kanban-statuses" />
           </Section>
+          <Section
+            title="Folder board"
+            description="The Kanban Folder board gives every note folder its own column. Point it at one folder to make that folder's children the columns instead."
+          >
+            <KanbanFolderRootRow settingId="kanban-folder-root" />
+          </Section>
           <Section
             title="Archived notes"
             description="What happens to a note's tasks when the note moves to the Archive."
@@ -4672,8 +4724,12 @@ export function SettingsModal(): JSX.Element {
               </div>
             ) : (
               <InlineNote>
-                Custom templates require a local vault. Built-in templates still
-                work here.
+                Custom templates need ZenNotes server 2.46 or later. Update the
+                server and{" "}
+                {workspaceMode === "remote"
+                  ? "reconnect this workspace"
+                  : "reload"}
+                ; built-in templates still work here.
               </InlineNote>
             )}
             <div className="flex items-center justify-between gap-4 border-t border-paper-300/40 px-5 py-4">
@@ -5396,10 +5452,12 @@ function KeymapSettings({
             // before turning Vim mode back on, but still let the filter work.
           }
           if (!q) return true;
+          const display =
+            getKeymapDisplay(overrides, definition.id) || UNBOUND_LABEL;
           return (
             definition.title.toLowerCase().includes(q) ||
             definition.description.toLowerCase().includes(q) ||
-            getKeymapDisplay(overrides, definition.id).toLowerCase().includes(q)
+            display.toLowerCase().includes(q)
           );
         });
         return items.length > 0 ? { ...group, items } : null;
@@ -5415,7 +5473,8 @@ function KeymapSettings({
   const hasOverrides = Object.keys(overrides).length > 0;
 
   return (
-    <div className="flex h-full min-h-0 flex-col">
+    <div className="flex h-full min-h-0 flex-col gap-4">
+      <IgnoredKeysRow settingId="ignored-keys" />
       <div className="flex min-h-0 flex-1 flex-col rounded-3xl border border-paper-300/60 bg-paper-50/45 shadow-[0_14px_36px_rgba(15,23,42,0.04)]">
         <div className="sticky top-0 z-10 rounded-t-[22px] border-b border-paper-300/55 bg-paper-50/95 px-5 py-4 backdrop-blur">
           <div className="flex flex-wrap items-center justify-between gap-3">
@@ -5425,8 +5484,9 @@ function KeymapSettings({
               </div>
               <div className="mt-1 text-xs leading-5 text-ink-500">
                 Record a new key or sequence for the app’s keyboard-first
-                actions. Standard accessibility fallbacks like arrows, Enter,
-                and Escape still work.
+                actions, or unbind one so no key triggers it. Standard
+                accessibility fallbacks like arrows, Enter, and Escape still
+                work.
               </div>
             </div>
             <div className="flex items-center gap-2">
@@ -5462,7 +5522,8 @@ function KeymapSettings({
               <div className="pb-4">
                 {group.items.map((definition) => {
                   const current = getKeymapBinding(overrides, definition.id);
-                  const custom = !!overrides[definition.id];
+                  const custom = overrides[definition.id] !== undefined;
+                  const unbound = isUnboundBinding(current);
                   const conflict = findKeymapConflict(
                     overrides,
                     definition.id,
@@ -5505,8 +5566,17 @@ function KeymapSettings({
                         </div>
                       </div>
                       <div className="flex shrink-0 items-center gap-2">
-                        <span className="rounded-xl border border-paper-300/70 bg-paper-100/85 px-3 py-1.5 text-xs font-medium text-ink-900">
-                          {formatKeymapBinding(current, definition.kind)}
+                        <span
+                          className={[
+                            "rounded-xl border px-3 py-1.5 text-xs font-medium",
+                            unbound
+                              ? "border-dashed border-paper-300/70 bg-paper-100/45 text-ink-500"
+                              : "border-paper-300/70 bg-paper-100/85 text-ink-900",
+                          ].join(" ")}
+                        >
+                          {unbound
+                            ? UNBOUND_LABEL
+                            : formatKeymapBinding(current, definition.kind)}
                         </span>
                         <button
                           type="button"
@@ -5515,6 +5585,22 @@ function KeymapSettings({
                         >
                           Change…
                         </button>
+                        <button
+                          type="button"
+                          disabled={unbound}
+                          onClick={() =>
+                            onSetBinding(definition.id, UNBOUND_BINDING)
+                          }
+                          title="Remove the key entirely. Nothing triggers this action until it is rebound or reset."
+                          className={[
+                            "rounded-xl border px-3 py-1.5 text-xs font-medium transition-colors",
+                            unbound
+                              ? "cursor-not-allowed border-paper-300/60 bg-paper-100/45 text-ink-400"
+                              : "border-paper-300/70 bg-paper-100/80 text-ink-700 hover:bg-paper-200",
+                          ].join(" ")}
+                        >
+                          Unbind
+                        </button>
                         <button
                           type="button"
                           disabled={!custom}
@@ -5558,24 +5644,114 @@ function KeymapSettings({
             );
             setRecording(null);
           }}
+          onUnbind={() => {
+            onSetBinding(recording.id, UNBOUND_BINDING);
+            setRecording(null);
+          }}
         />
       )}
     </div>
   );
 }
 
+function IgnoredKeysRow({ settingId }: { settingId?: string }): JSX.Element {
+  const ignoredKeys = useStore((s) => s.ignoredKeys);
+  const addIgnoredKey = useStore((s) => s.addIgnoredKey);
+  const removeIgnoredKey = useStore((s) => s.removeIgnoredKey);
+  const [recording, setRecording] = useState(false);
+
+  // Capture the next key. The window guard stands aside while this runs
+  // (setIgnoredKeysRecorderActive), since a key already on the list would
+  // otherwise never reach us; Escape cancels without recording anything.
+  useEffect(() => {
+    if (!recording) return;
+    setIgnoredKeysRecorderActive(true);
+    const onKey = (event: KeyboardEvent): void => {
+      event.preventDefault();
+      event.stopPropagation();
+      if (event.key === "Escape") {
+        setRecording(false);
+        return;
+      }
+      if (["Shift", "Control", "Alt", "Meta"].includes(event.key)) return;
+      const token = ignoredKeyTokenFromEvent(event);
+      if (!token) return;
+      addIgnoredKey(token);
+      setRecording(false);
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => {
+      window.removeEventListener("keydown", onKey, true);
+      setIgnoredKeysRecorderActive(false);
+    };
+  }, [recording, addIgnoredKey]);
+
+  return (
+    <div
+      className="rounded-3xl border border-paper-300/60 bg-paper-50/45 px-5 py-4 shadow-[0_14px_36px_rgba(15,23,42,0.04)]"
+      {...settingsSearchTargetProps(settingId)}
+    >
+      <div className="flex flex-wrap items-start justify-between gap-3">
+        <div className="min-w-0">
+          <div className="text-sm font-medium text-ink-900">Ignored keys</div>
+          <div className="mt-1 text-xs leading-5 text-ink-500">
+            Keys the app never sees. Remappers with tap-hold layers (Kanata,
+            QMK, ZMK) send a harmless extra key with every keystroke, on Linux
+            usually the Katakana/Hiragana key, which reads as KanaMode; each one
+            would otherwise reset a pending <code>jk</code>, <code>dd</code>,
+            leader chord or hint. Also <code>:ignorekey</code> in the editor, or{" "}
+            <code>ignored_keys</code> under <code>[editor]</code> in config.toml.
+          </div>
+        </div>
+        <Button
+          variant={recording ? "primary" : "secondary"}
+          size="sm"
+          data-ignored-keys-record
+          onClick={() => setRecording((r) => !r)}
+        >
+          {recording ? "Press the key… (Esc cancels)" : "Record a key"}
+        </Button>
+      </div>
+      {ignoredKeys.length > 0 && (
+        <div className="mt-3 flex flex-wrap items-center gap-1.5" data-ignored-keys>
+          {ignoredKeys.map((key) => (
+            <span
+              key={key}
+              data-ignored-key={key}
+              className="inline-flex items-center gap-1 rounded-full border border-paper-300/70 bg-paper-200/50 py-0.5 pl-2.5 pr-1 font-mono text-xs text-ink-800"
+            >
+              {key}
+              <button
+                type="button"
+                onClick={() => removeIgnoredKey(key)}
+                title={`Stop ignoring ${key}`}
+                aria-label={`Stop ignoring ${key}`}
+                className="rounded-full px-1 text-ink-400 transition-colors hover:bg-paper-300/70 hover:text-ink-800"
+              >
+                ×
+              </button>
+            </span>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
 function KeymapRecorderModal({
   definition,
   overrides,
   currentBinding,
   onClose,
   onSave,
+  onUnbind,
 }: {
   definition: KeymapDefinition;
   overrides: KeymapOverrides;
   currentBinding: string;
   onClose: () => void;
   onSave: (binding: string) => void;
+  onUnbind: () => void;
 }): JSX.Element {
   const [binding, setBinding] = useState(currentBinding);
   const mac = isMacPlatform();
@@ -5660,8 +5836,8 @@ function KeymapRecorderModal({
             </div>
             <div className="mt-2 text-xs leading-5 text-ink-500">
               {definition.kind === "shortcut"
-                ? `Press the shortcut you want. ${mac ? "Command" : "Ctrl"}-style chords are saved in the app’s cross-platform format.`
-                : `Press the sequence you want. Backspace removes the last token, and multi-step sequences stop at ${definition.maxTokens ?? 2} key${(definition.maxTokens ?? 2) === 1 ? "" : "s"}.`}
+                ? `Press the shortcut you want; Backspace clears it. ${mac ? "Command" : "Ctrl"}-style chords are saved in the app’s cross-platform format. Unbind leaves the action with no key at all.`
+                : `Press the sequence you want. Backspace removes the last token, and multi-step sequences stop at ${definition.maxTokens ?? 2} key${(definition.maxTokens ?? 2) === 1 ? "" : "s"}. Unbind leaves the action with no key at all.`}
             </div>
           </div>
           {conflict && (
@@ -5676,7 +5852,10 @@ function KeymapRecorderModal({
             </div>
           )}
           <div className="mt-3 text-xs text-ink-500">
-            Current: {formatKeymapBinding(currentBinding, definition.kind)}
+            Current:{" "}
+            {isUnboundBinding(currentBinding)
+              ? UNBOUND_LABEL
+              : formatKeymapBinding(currentBinding, definition.kind)}
           </div>
           <div className="mt-1 text-xs text-ink-500">
             Default:{" "}
@@ -5689,10 +5868,17 @@ function KeymapRecorderModal({
         <div className="flex items-center justify-between gap-3 border-t border-paper-300/60 px-5 py-3">
           <button
             type="button"
-            onClick={() => setBinding("")}
-            className="rounded-md border border-paper-300 bg-paper-100 px-3 py-1.5 text-xs font-medium text-ink-700 transition-colors hover:bg-paper-200"
+            onClick={onUnbind}
+            disabled={isUnboundBinding(currentBinding)}
+            title="Save this action with no key at all."
+            className={[
+              "rounded-md border px-3 py-1.5 text-xs font-medium transition-colors",
+              isUnboundBinding(currentBinding)
+                ? "cursor-not-allowed border-paper-300/60 bg-paper-100/45 text-ink-400"
+                : "border-paper-300 bg-paper-100 text-ink-700 hover:bg-paper-200",
+            ].join(" ")}
           >
-            Clear
+            Unbind
           </button>
           <div className="flex items-center gap-2">
             <button
@@ -6915,6 +7101,54 @@ function slugifyStatus(name: string): string {
 /** Settings editor for the custom-status Kanban columns. Add, rename, reorder,
  *  and remove columns without touching config.toml by hand; changes are written
  *  straight back to the config file (and the per-vault view override). (#354) */
+function KanbanFolderRootRow({ settingId }: { settingId?: string }): JSX.Element {
+  const root = useStore((s) => s.kanbanFolderRoot);
+  const setKanbanFolderRoot = useStore((s) => s.setKanbanFolderRoot);
+  const [draft, setDraft] = useState(root);
+  useEffect(() => {
+    setDraft(root);
+  }, [root]);
+  const commit = (): void => {
+    setKanbanFolderRoot(draft);
+  };
+  return (
+    <div className="px-5 py-4" {...settingsSearchTargetProps(settingId)}>
+      <div className="text-sm font-medium text-ink-900">Group by the folders inside</div>
+      <div className="mt-1 text-xs leading-5 text-ink-500">
+        A folder path relative to your notes, such as <code>Projects</code>: its
+        subfolders become the columns, deeper notes roll up to their subfolder,
+        and notes outside it share an “Other folders” column. Leave it empty for
+        one column per note folder. On the board, <code>:folderroot Projects</code>{" "}
+        does the same; <code>kanban_folder_root</code> in config.toml is the
+        file-level key.
+      </div>
+      <div className="mt-3 flex items-center gap-2">
+        <input
+          type="text"
+          value={draft}
+          placeholder="Projects"
+          spellCheck={false}
+          autoComplete="off"
+          onChange={(e) => setDraft(e.target.value)}
+          onBlur={commit}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              commit();
+            }
+          }}
+          className="w-64 rounded-md border border-paper-300 bg-paper-50 px-2.5 py-1.5 text-sm text-ink-900 outline-none focus:border-accent"
+        />
+        {root && (
+          <Button variant="secondary" size="sm" onClick={() => setKanbanFolderRoot("")}>
+            Clear
+          </Button>
+        )}
+      </div>
+    </div>
+  );
+}
+
 function KanbanStatusesRow({ settingId }: { settingId?: string }): JSX.Element {
   const statuses = useStore((s) => s.kanbanStatuses);
   const setKanbanStatuses = useStore((s) => s.setKanbanStatuses);
diff --git a/packages/app-core/src/components/TasksKanban.test.ts b/packages/app-core/src/components/TasksKanban.test.ts
index 45ceedc1..42cba323 100644
--- a/packages/app-core/src/components/TasksKanban.test.ts
+++ b/packages/app-core/src/components/TasksKanban.test.ts
@@ -12,7 +12,10 @@ import {
   NO_VALUE_COLUMN_ID,
   statusColumns,
   taskIdentityKey,
-  type Column
+  type Column,
+  folderColumns,
+  noteLocationOf,
+  FOLDER_OTHER_LABEL
 } from './TasksKanban'
 
 function col(id: string): Column {
@@ -348,3 +351,109 @@ describe('completeStatusOrder (#677)', () => {
     ])
   })
 })
+
+describe('folder board (#730)', () => {
+  const task = (sourcePath: string, noteFolder: VaultTask['noteFolder'], extra: Partial<VaultTask> = {}): VaultTask =>
+    ({
+      id: `${sourcePath}#0`,
+      sourcePath,
+      noteTitle: sourcePath.split('/').pop()!.replace(/\.md$/, ''),
+      noteFolder,
+      lineNumber: 0,
+      taskIndex: 0,
+      rawText: '- [ ] x',
+      content: 'x',
+      checked: false,
+      forwarded: false,
+      cancelled: false,
+      inProgress: false,
+      waiting: false,
+      tags: [],
+      ...extra
+    }) as VaultTask
+  const layout = (folderRoot = '', systemFolderPaths?: Record<string, string>) => ({
+    folderRoot,
+    systemFolderPaths: systemFolderPaths ?? null,
+    systemFolderLabels: null
+  })
+
+  it('locates a note under its system folder in inbox mode, root mode, and with a remapped folder', () => {
+    expect(noteLocationOf(task('inbox/Projects/alpha/plan.md', 'inbox'))).toEqual({ folder: 'inbox', dir: 'Projects/alpha', prefix: 'inbox' })
+    expect(noteLocationOf(task('inbox/plan.md', 'inbox'))).toEqual({ folder: 'inbox', dir: '', prefix: 'inbox' })
+    // Root mode: no prefix, so the first segment is a user folder.
+    expect(noteLocationOf(task('Projects/alpha/plan.md', 'inbox'))).toEqual({ folder: 'inbox', dir: 'Projects/alpha', prefix: '' })
+    expect(noteLocationOf(task('plan.md', 'inbox'))).toEqual({ folder: 'inbox', dir: '', prefix: '' })
+    // A vault whose inbox lives in `01 - Entry`: that prefix is the inbox, and a
+    // directory literally called inbox is a user folder.
+    const remapped = { inbox: '01 - Entry' }
+    expect(noteLocationOf(task('01 - Entry/Projects/plan.md', 'inbox'), remapped)).toEqual({ folder: 'inbox', dir: 'Projects', prefix: '01 - Entry' })
+    expect(noteLocationOf(task('inbox/plan.md', 'inbox'), remapped)).toEqual({ folder: 'inbox', dir: 'inbox', prefix: '' })
+    expect(noteLocationOf(task('quick/2026/plan.md', 'quick'))).toEqual({ folder: 'quick', dir: '2026', prefix: 'quick' })
+  })
+
+  it('gives every note folder its own column, system roots first, subfolders alphabetically', () => {
+    const columns = folderColumns(
+      [
+        task('inbox/Projects/beta/b.md', 'inbox'),
+        task('inbox/plan.md', 'inbox'),
+        task('inbox/Projects/alpha/a.md', 'inbox'),
+        task('inbox/Projects/alpha/deep/d.md', 'inbox'),
+        task('quick/q.md', 'quick'),
+        task('inbox/Areas/home.md', 'inbox'),
+        task('inbox/Projects/alpha/done.md', 'inbox', { checked: true })
+      ],
+      false,
+      layout()
+    )
+    expect(columns.map((c) => [c.id, c.label, c.tasks.length])).toEqual([
+      ['inbox', 'Inbox', 1],
+      ['inbox/Areas', 'Areas', 1],
+      ['inbox/Projects/alpha', 'Projects/alpha', 1],
+      ['inbox/Projects/alpha/deep', 'Projects/alpha/deep', 1],
+      ['inbox/Projects/beta', 'Projects/beta', 1],
+      ['quick', 'Quick Notes', 1]
+    ])
+  })
+
+  it('labels root-mode notes by their folder and the vault root by the inbox label', () => {
+    const columns = folderColumns([task('Projects/alpha/a.md', 'inbox'), task('plan.md', 'inbox')], false, layout())
+    expect(columns.map((c) => [c.id, c.label])).toEqual([
+      ['inbox', 'Inbox'],
+      ['Projects/alpha', 'Projects/alpha']
+    ])
+  })
+
+  it('with a root, groups by its children, rolls deeper notes up, and parks the rest in Other folders', () => {
+    const columns = folderColumns(
+      [
+        task('inbox/Projects/beta/b.md', 'inbox'),
+        task('inbox/Projects/alpha/a.md', 'inbox'),
+        task('inbox/Projects/alpha/deep/d.md', 'inbox'),
+        task('inbox/Projects/overview.md', 'inbox'),
+        task('inbox/Areas/home.md', 'inbox'),
+        task('inbox/plan.md', 'inbox'),
+        task('quick/q.md', 'quick')
+      ],
+      false,
+      layout('projects/')
+    )
+    expect(columns.map((c) => [c.id, c.label, c.tasks.length])).toEqual([
+      ['inbox/Projects', 'Projects', 1],
+      ['inbox/Projects/alpha', 'alpha', 2],
+      ['inbox/Projects/beta', 'beta', 1],
+      [NO_VALUE_COLUMN_ID, FOLDER_OTHER_LABEL, 3]
+    ])
+    // Root mode: same shape without the prefix.
+    const rootMode = folderColumns([task('Projects/alpha/a.md', 'inbox'), task('Notes/n.md', 'inbox')], false, layout('Projects'))
+    expect(rootMode.map((c) => c.id)).toEqual(['Projects/alpha', NO_VALUE_COLUMN_ID])
+  })
+
+  it('hides archived notes unless asked, and shows their column with the archive label when shown', () => {
+    const tasks = [task('inbox/a.md', 'inbox'), task('archive/old/o.md', 'archive')]
+    expect(folderColumns(tasks, false, layout()).map((c) => c.id)).toEqual(['inbox'])
+    expect(folderColumns(tasks, true, layout()).map((c) => [c.id, c.label])).toEqual([
+      ['inbox', 'Inbox'],
+      ['archive/old', 'Archive / old']
+    ])
+  })
+})
diff --git a/packages/app-core/src/components/TasksKanban.tsx b/packages/app-core/src/components/TasksKanban.tsx
index 417901fc..070bb077 100644
--- a/packages/app-core/src/components/TasksKanban.tsx
+++ b/packages/app-core/src/components/TasksKanban.tsx
@@ -4,7 +4,8 @@
  * Columns are driven by the user's `kanbanGroupBy` choice:
  *   - 'status'  — Today / Upcoming / Waiting / Done   (mirrors list groups)
  *   - 'priority' — High / Med / Low / None
- *   - 'folder'  — Inbox / Quick / Archive            (read-only)
+ *   - 'folder'  one column per note folder (read-only); with a folder
+ *                root set, the children of that folder (#730)
  *
  * Drag-and-drop:
  *   - Status: drop changes `[ ]`/`[x]`, `@waiting`, and due-date tokens
@@ -27,9 +28,16 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { flushSync } from 'react-dom'
 import type { NoteFolder } from '@shared/ipc'
+import {
+  resolveFolderPath,
+  systemFolderForDirName,
+  type SystemFolderPaths
+} from '@shared/system-folder-paths'
+import { resolveSystemFolderLabels, type SystemFolderLabels } from '../lib/system-folder-labels'
+import { promptApp } from '../lib/prompt-requests'
 import type { VaultTask } from '@shared/tasks'
 import { groupTasks, isOverdue as isTaskOverdue, toIsoDateLocal } from '@shared/tasks'
-import { useStore, type KanbanGroupBy, type TaskMutation } from '../store'
+import { normalizeKanbanFolderRoot, useStore, type KanbanGroupBy, type TaskMutation } from '../store'
 import { filterTasks } from '../lib/tasks-filter'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
 import { buildTaskMenuItems } from '../lib/task-context-menu'
@@ -240,30 +248,126 @@ function priorityColumns(tasks: VaultTask[]): Column[] {
   ]
 }
 
-const FOLDER_ORDER: NoteFolder[] = ['inbox', 'quick', 'archive']
-const FOLDER_LABEL: Record<NoteFolder, string> = {
-  inbox: 'Inbox',
-  quick: 'Quick',
-  archive: 'Archive',
-  trash: 'Trash'
+const FOLDER_ORDER: NoteFolder[] = ['inbox', 'quick', 'archive', 'trash']
+
+/** What the folder board needs to know about the vault to place a note. */
+export interface FolderBoardLayout {
+  /** vault.json `systemFolderPaths`: the on-disk names of the system folders. */
+  systemFolderPaths?: SystemFolderPaths | null
+  /** Display names for the system folders (Settings, Sidebar). */
+  systemFolderLabels?: SystemFolderLabels | null
+  /** `kanbanFolderRoot`: group by the children of this folder; '' = each
+   *  note's own folder. Relative to the notes area, posix, no slashes at
+   *  the ends. */
+  folderRoot: string
+}
+
+export const FOLDER_OTHER_LABEL = 'Other folders'
+
+/**
+ * Where a task's note lives, split into the system folder that owns it and
+ * the directory path under that folder ('' at its root). A note in the
+ * primary area of a root-mode vault has no system-folder prefix in its
+ * path, so the first segment is classified by name rather than assumed:
+ * `Projects/alpha/x.md` with noteFolder inbox is at `Projects/alpha` under
+ * the inbox, while `01 - Entry/Projects/x.md` in a vault whose inbox is
+ * remapped to `01 - Entry` strips that prefix first.
+ */
+export function noteLocationOf(
+  task: Pick<VaultTask, 'sourcePath' | 'noteFolder'>,
+  systemFolderPaths?: SystemFolderPaths | null
+): { folder: NoteFolder; dir: string; prefix: string } {
+  const segments = task.sourcePath.split('/')
+  segments.pop()
+  const first = segments[0]
+  const owner = first ? systemFolderForDirName(first, systemFolderPaths) : null
+  if (owner && owner === task.noteFolder) {
+    return { folder: task.noteFolder, dir: segments.slice(1).join('/'), prefix: first }
+  }
+  return { folder: task.noteFolder, dir: segments.join('/'), prefix: '' }
+}
+
+function folderColumnLabel(
+  folder: NoteFolder,
+  dir: string,
+  labels: Record<string, string>
+): string {
+  if (!dir) return labels[folder]
+  return folder === 'inbox' ? dir : `${labels[folder]} / ${dir}`
 }
 
-function folderColumns(tasks: VaultTask[], showArchived: boolean): Column[] {
-  const map = new Map<NoteFolder, VaultTask[]>()
+export function folderColumns(
+  tasks: VaultTask[],
+  showArchived: boolean,
+  layout: FolderBoardLayout
+): Column[] {
+  const labels = resolveSystemFolderLabels(layout.systemFolderLabels)
+  const root = normalizeKanbanFolderRoot(layout.folderRoot)
+  const rootLower = root.toLowerCase()
+  const byId = new Map<string, { label: string; folder: NoteFolder; dir: string; tasks: VaultTask[] }>()
+  const other: VaultTask[] = []
+  const place = (id: string, label: string, folder: NoteFolder, dir: string, task: VaultTask): void => {
+    const entry = byId.get(id)
+    if (entry) entry.tasks.push(task)
+    else byId.set(id, { label, folder, dir, tasks: [task] })
+  }
   for (const task of tasks) {
     if (task.checked) continue
-    const list = map.get(task.noteFolder)
-    if (list) list.push(task)
-    else map.set(task.noteFolder, [task])
+    if (task.noteFolder === 'archive' && !showArchived) continue
+    const location = noteLocationOf(task, layout.systemFolderPaths)
+    const vaultDir = [location.prefix, location.dir].filter(Boolean).join('/')
+    if (!root) {
+      // Each note's own folder: the system folder's root as its label, a
+      // subfolder as its path.
+      const id = vaultDir || resolveFolderPath(location.folder, layout.systemFolderPaths)
+      place(id, folderColumnLabel(location.folder, location.dir, labels), location.folder, location.dir, task)
+      continue
+    }
+    // A root narrows the board to the primary area: the root's direct
+    // children are the columns, deeper notes roll up to their child, notes
+    // in the root itself get the root's column, and everything else (other
+    // system folders, folders beside the root) shares one trailing column.
+    if (location.folder !== 'inbox') {
+      other.push(task)
+      continue
+    }
+    const dirLower = location.dir.toLowerCase()
+    if (dirLower === rootLower) {
+      const id = [location.prefix, location.dir].filter(Boolean).join('/')
+      place(id, location.dir.split('/').pop() ?? location.dir, 'inbox', location.dir, task)
+      continue
+    }
+    if (dirLower.startsWith(rootLower + '/')) {
+      const child = location.dir.slice(root.length + 1).split('/')[0]
+      const childDir = `${location.dir.slice(0, root.length)}/${child}`
+      const id = [location.prefix, childDir].filter(Boolean).join('/')
+      place(id, child, 'inbox', childDir, task)
+      continue
+    }
+    other.push(task)
   }
-  // With archived tasks hidden (#540) the Archive column would only ever be
-  // empty, so it leaves the board instead of standing as a hollow promise.
-  const order = showArchived ? FOLDER_ORDER : FOLDER_ORDER.filter((f) => f !== 'archive')
-  return order.map((folder) => ({
-    id: folder,
-    label: FOLDER_LABEL[folder],
-    tasks: map.get(folder) ?? []
-  }))
+
+  const sortByDue = (a: VaultTask, b: VaultTask): number => {
+    const ad = a.due ?? '9999-12-31'
+    const bd = b.due ?? '9999-12-31'
+    if (ad !== bd) return ad < bd ? -1 : 1
+    if (a.sourcePath !== b.sourcePath) return a.sourcePath < b.sourcePath ? -1 : 1
+    return a.taskIndex - b.taskIndex
+  }
+  const folderRank = (folder: NoteFolder): number => FOLDER_ORDER.indexOf(folder)
+  const columns: Column[] = [...byId.entries()]
+    .sort(([, a], [, b]) => {
+      // System folder order first, a folder's root before its subfolders,
+      // then subfolders alphabetically.
+      if (a.folder !== b.folder) return folderRank(a.folder) - folderRank(b.folder)
+      if (!a.dir !== !b.dir) return a.dir ? 1 : -1
+      return a.dir.localeCompare(b.dir, undefined, { sensitivity: 'base', numeric: true })
+    })
+    .map(([id, entry]) => ({ id, label: entry.label, tasks: entry.tasks.sort(sortByDue) }))
+  if (other.length > 0) {
+    columns.push({ id: NO_VALUE_COLUMN_ID, label: FOLDER_OTHER_LABEL, tasks: other.sort(sortByDue) })
+  }
+  return columns
 }
 
 /** Title-case a field value for its default column label; users can still
@@ -340,10 +444,11 @@ function buildColumns(
   tasks: VaultTask[],
   today: Date,
   statuses: string[],
-  showArchived: boolean
+  showArchived: boolean,
+  folderLayout: FolderBoardLayout
 ): Column[] {
   if (groupBy === 'priority') return priorityColumns(tasks)
-  if (groupBy === 'folder') return folderColumns(tasks, showArchived)
+  if (groupBy === 'folder') return folderColumns(tasks, showArchived, folderLayout)
   const fieldKey = fieldKeyOf(groupBy)
   if (fieldKey) {
     // The status field keeps its friendly `kanban_statuses` order; other fields
@@ -596,6 +701,14 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
   const setKanbanCardOrder = useStore((s) => s.setKanbanCardOrder)
   const kanbanStatuses = useStore((s) => s.kanbanStatuses)
   const showArchivedTasks = useStore((s) => s.showArchivedTasks)
+  const kanbanFolderRoot = useStore((s) => s.kanbanFolderRoot)
+  const setKanbanFolderRoot = useStore((s) => s.setKanbanFolderRoot)
+  const systemFolderPaths = useStore((s) => s.vaultSettings.systemFolderPaths)
+  const systemFolderLabels = useStore((s) => s.systemFolderLabels)
+  const folderLayout = useMemo<FolderBoardLayout>(
+    () => ({ systemFolderPaths, systemFolderLabels, folderRoot: kanbanFolderRoot }),
+    [systemFolderPaths, systemFolderLabels, kanbanFolderRoot]
+  )
   const applyTaskMutation = useStore((s) => s.applyTaskMutation)
   const startTaskFromList = useStore((s) => s.startTaskFromList)
   const cancelTaskFromList = useStore((s) => s.cancelTaskFromList)
@@ -686,7 +799,14 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
 
   const fullColumns = useMemo(
     () => {
-      const built = buildColumns(groupBy, displayTasks, today, kanbanStatuses, showArchivedTasks)
+      const built = buildColumns(
+        groupBy,
+        displayTasks,
+        today,
+        kanbanStatuses,
+        showArchivedTasks,
+        folderLayout
+      )
       const savedOrder = kanbanColumnOrder[groupBy] ?? []
       const orderedColumns = applyColumnOrder(
         groupBy,
@@ -714,6 +834,7 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
       kanbanColumnTitles,
       kanbanStatuses,
       showArchivedTasks,
+      folderLayout,
       today
     ]
   )
@@ -769,6 +890,32 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
 
   const dndEnabled = groupBy !== 'folder'
 
+  // The folder board's root (#730): a prompt listing the folders that hold
+  // tasks, so the choice is one Enter away; an empty answer goes back to
+  // grouping by each note's own folder.
+  const pickFolderRoot = useCallback(async (): Promise<void> => {
+    const dirs = new Set<string>()
+    for (const task of latestTasksRef.current) {
+      const location = noteLocationOf(task, folderLayout.systemFolderPaths)
+      if (location.folder !== 'inbox' || !location.dir) continue
+      const parts = location.dir.split('/')
+      for (let i = 1; i <= parts.length; i += 1) dirs.add(parts.slice(0, i).join('/'))
+    }
+    const answer = await promptApp({
+      title: 'Group the folder board by',
+      description:
+        'The folders inside this one become the columns; deeper notes roll up to their folder, and notes outside it share an Other folders column. Leave empty to group by each note’s own folder.',
+      initialValue: kanbanFolderRoot,
+      placeholder: 'Projects',
+      okLabel: 'Apply',
+      allowEmptySubmit: true,
+      suggestions: [...dirs].sort().map((dir) => ({ value: dir })),
+      suggestionsHint: '↑↓ pick a folder · Enter apply · empty clears'
+    })
+    if (answer === null) return
+    setKanbanFolderRoot(answer)
+  }, [folderLayout.systemFolderPaths, kanbanFolderRoot, setKanbanFolderRoot])
+
   const beginColumnRename = useCallback((column: Column) => {
     setEditingColumnId(column.id)
     setEditingTitle(column.label)
@@ -1569,6 +1716,21 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
               </option>
             ))}
           </select>
+          {groupBy === 'folder' && (
+            <button
+              type="button"
+              data-kanban-folder-root
+              onClick={() => void pickFolderRoot()}
+              title={
+                kanbanFolderRoot
+                  ? `Columns are the folders inside ${kanbanFolderRoot}. Click to change (:folderroot).`
+                  : 'Columns are each note’s own folder. Click to group by the folders inside one folder instead (:folderroot <path>).'
+              }
+              className="ml-1 rounded-md border border-paper-300/60 bg-paper-200/60 px-2 py-0.5 text-xs text-current/70 transition-colors hover:bg-paper-200 hover:text-current/90"
+            >
+              {kanbanFolderRoot ? `inside ${kanbanFolderRoot}` : 'each note’s folder'}
+            </button>
+          )}
         </div>
         <div className="text-xs text-current/40">
           {dndEnabled
@@ -1740,7 +1902,7 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
       </div>
       {!dndEnabled && (
         <div className="shrink-0 border-t border-paper-300/45 px-3 py-1.5 text-xs text-current/40">
-          Folder grouping is read-only — move a task across folders by moving its source note in
+          Folder grouping is read-only: move a task across folders by moving its source note in
           the sidebar.
         </div>
       )}
diff --git a/packages/app-core/src/components/TasksView.tsx b/packages/app-core/src/components/TasksView.tsx
index 8911d4fa..1a4518a8 100644
--- a/packages/app-core/src/components/TasksView.tsx
+++ b/packages/app-core/src/components/TasksView.tsx
@@ -13,6 +13,9 @@ import { ContextMenu, type ContextMenuItem } from './ContextMenu'
 import { buildTaskMenuItems } from '../lib/task-context-menu'
 import { isImeComposing } from '../lib/ime'
 import { isAppOverlayOpen } from '../lib/overlay-open'
+import { promptApp } from '../lib/prompt-requests'
+import { useToastStore } from '../lib/toast'
+import { findSavedTaskFilterName, savedTaskFilterNameForQuery } from '../lib/saved-task-filters'
 
 type GroupKey = 'today' | 'upcoming' | 'waiting' | 'forwarded' | 'done' | 'cancelled'
 
@@ -48,6 +51,11 @@ export function TasksView(): JSX.Element {
   const filter = useStore((s) => s.tasksFilter)
   const cursorIndex = useStore((s) => s.taskCursorIndex)
   const setFilter = useStore((s) => s.setTasksFilter)
+  const savedFilters = useStore((s) => s.savedTaskFilters)
+  const saveTaskFilter = useStore((s) => s.saveTaskFilter)
+  const renameSavedTaskFilter = useStore((s) => s.renameSavedTaskFilter)
+  const deleteSavedTaskFilter = useStore((s) => s.deleteSavedTaskFilter)
+  const applySavedTaskFilter = useStore((s) => s.applySavedTaskFilter)
   const setCursorIndex = useStore((s) => s.setTaskCursorIndex)
   const refreshTasks = useStore((s) => s.refreshTasks)
   const openTaskAt = useStore((s) => s.openTaskAt)
@@ -189,6 +197,107 @@ export function TasksView(): JSX.Element {
     [today, vimMode]
   )
 
+  // Saved filters (#731): named queries kept in the prefs and mirrored to
+  // config.toml as [saved_filters]. The chip row shows them in stored order;
+  // the chip whose query is the current filter reads as active.
+  const savedEntries = useMemo(() => Object.entries(savedFilters), [savedFilters])
+  const activeSavedName = useMemo(
+    () => savedTaskFilterNameForQuery(savedFilters, filter),
+    [savedFilters, filter]
+  )
+  const toast = useCallback((message: string, kind: 'info' | 'success' = 'info'): void => {
+    useToastStore.getState().addToast(message, kind)
+  }, [])
+  // The name prompt lists the existing names, so picking one overwrites it
+  // with the current query instead of creating a near-duplicate.
+  const saveCurrentFilter = useCallback(
+    async (name?: string): Promise<void> => {
+      const query = filter.trim()
+      if (!query) {
+        toast('Type a filter first, then save it')
+        return
+      }
+      let chosen = (name ?? '').trim()
+      if (!chosen) {
+        const names = Object.keys(savedFilters)
+        const answer = await promptApp({
+          title: 'Save filter',
+          description: `A name for "${query}". Saved filters live in config.toml under [saved_filters].`,
+          placeholder: 'Project alpha',
+          okLabel: 'Save',
+          suggestions: names.map((n) => ({ value: n, detail: savedFilters[n] })),
+          suggestionsHint: names.length > 0 ? 'Pick an existing name to overwrite it.' : undefined
+        })
+        if (answer === null) return
+        chosen = answer.trim()
+        if (!chosen) return
+      }
+      saveTaskFilter(chosen, query)
+      toast(`Saved filter "${chosen}"`, 'success')
+    },
+    [filter, savedFilters, saveTaskFilter, toast]
+  )
+  const pickSavedFilter = useCallback(async (): Promise<void> => {
+    const names = Object.keys(savedFilters)
+    if (names.length === 0) {
+      toast('No saved filters yet. Type a filter, then press Save filter (or :savefilter <name>)')
+      return
+    }
+    const answer = await promptApp({
+      title: 'Saved filters',
+      placeholder: 'Name',
+      okLabel: 'Apply',
+      suggestions: names.map((n) => ({ value: n, detail: savedFilters[n] })),
+      autoHighlightFirst: true,
+      suggestionsHint: 'Type to narrow · ↑↓ move · Enter applies'
+    })
+    if (answer === null) return
+    if (!applySavedTaskFilter(answer)) toast(`No saved filter called "${answer.trim()}"`)
+  }, [savedFilters, applySavedTaskFilter, toast])
+  const renameSavedFilter = useCallback(
+    async (name: string): Promise<void> => {
+      const answer = await promptApp({
+        title: 'Rename saved filter',
+        initialValue: name,
+        okLabel: 'Rename'
+      })
+      if (answer === null) return
+      const next = answer.trim()
+      if (!next || next === name) return
+      renameSavedTaskFilter(name, next)
+    },
+    [renameSavedTaskFilter]
+  )
+  const openSavedFilterMenu = useCallback(
+    (e: React.MouseEvent, name: string): void => {
+      e.preventDefault()
+      e.stopPropagation()
+      setMenu({
+        x: e.clientX,
+        y: e.clientY,
+        items: [
+          {
+            label: 'Apply',
+            onSelect: () => {
+              applySavedTaskFilter(name)
+            }
+          },
+          { label: 'Rename…', onSelect: () => void renameSavedFilter(name) },
+          { kind: 'separator' },
+          {
+            label: 'Delete',
+            danger: true,
+            onSelect: () => {
+              deleteSavedTaskFilter(name)
+              toast(`Deleted saved filter "${name}"`)
+            }
+          }
+        ]
+      })
+    },
+    [applySavedTaskFilter, renameSavedFilter, deleteSavedTaskFilter, toast]
+  )
+
   // On first mount, pull fresh if we have nothing yet.
   useEffect(() => {
     if (tasks.length === 0 && !loading) void refreshTasks()
@@ -312,8 +421,48 @@ export function TasksView(): JSX.Element {
       // input so the query lands in the box as typed.
       const spaceIdx = input.indexOf(' ')
       const head = (spaceIdx === -1 ? input : input.slice(0, spaceIdx)).toLowerCase()
+      const arg = spaceIdx === -1 ? '' : input.slice(spaceIdx + 1).trim()
       if (head === 'filter' || head === 'f') {
-        setFilter(spaceIdx === -1 ? '' : input.slice(spaceIdx + 1).trim())
+        // A saved filter's name applies its query (#731); any other text is
+        // the query itself, as before.
+        if (arg && applySavedTaskFilter(arg)) return
+        setFilter(arg)
+        return
+      }
+      // `:savefilter <name>` keeps the current query under that name (bare, it
+      // asks for one); `:delfilter <name>` forgets it. (#731)
+      if (head === 'savefilter' || head === 'sf') {
+        void saveCurrentFilter(arg)
+        return
+      }
+      // `:folderroot <path>` groups the folder board by the folders inside
+      // <path>; bare `:folderroot` returns to each note's own folder. (#730)
+      if (head === 'folderroot' || head === 'fr') {
+        const store = useStore.getState()
+        store.setKanbanFolderRoot(arg)
+        if (store.kanbanGroupBy !== 'folder') store.setKanbanGroupBy('folder')
+        setViewMode('kanban')
+        // Read back after the set: the snapshot above predates it.
+        const applied = useStore.getState().kanbanFolderRoot
+        toast(
+          applied
+            ? `Folder board: columns are the folders inside ${applied}`
+            : 'Folder board: columns are each note’s own folder'
+        )
+        return
+      }
+      if (head === 'delfilter' || head === 'df') {
+        if (!arg) {
+          toast('Usage: :delfilter <name>')
+          return
+        }
+        const stored = findSavedTaskFilterName(savedFilters, arg)
+        if (!stored) {
+          toast(`No saved filter called "${arg}"`)
+          return
+        }
+        deleteSavedTaskFilter(stored)
+        toast(`Deleted saved filter "${stored}"`)
         return
       }
       const cmd = input.toLowerCase()
@@ -384,7 +533,17 @@ export function TasksView(): JSX.Element {
           return
       }
     },
-    [closeTasksView, refreshTasks, setFilter, setViewMode]
+    [
+      closeTasksView,
+      refreshTasks,
+      setFilter,
+      setViewMode,
+      applySavedTaskFilter,
+      saveCurrentFilter,
+      deleteSavedTaskFilter,
+      savedFilters,
+      toast
+    ]
   )
 
   // Window-level handler with two responsibilities:
@@ -477,6 +636,13 @@ export function TasksView(): JSX.Element {
         return
       }
 
+      // View-independent like the filter box it recalls into. (#731)
+      if (seq('tasks.savedFilters')) {
+        consume()
+        void pickSavedFilter()
+        return
+      }
+
       if (seq('nav.localEx')) {
         consume()
         setExValue('')
@@ -582,7 +748,8 @@ export function TasksView(): JSX.Element {
     setFilter,
     viewMode,
     setViewMode,
-    newTaskFile
+    newTaskFile,
+    pickSavedFilter
   ])
 
   return (
@@ -681,6 +848,58 @@ export function TasksView(): JSX.Element {
         </div>
       </div>
 
+      {/* Saved filters (#731): recall with a click, `:filter <name>`, or F.
+          The row appears once there is something to recall, or a query
+          worth keeping. */}
+      {(savedEntries.length > 0 || filter.trim()) && (
+        <div
+          data-saved-filters
+          className="flex flex-wrap items-center gap-1.5 border-b border-paper-300/45 px-4 py-1.5"
+        >
+          {savedEntries.length > 0 && (
+            <span className="text-2xs font-medium uppercase tracking-wide text-current/45">
+              Saved
+            </span>
+          )}
+          {savedEntries.map(([name, query]) => {
+            const active = name === activeSavedName
+            return (
+              <button
+                key={name}
+                type="button"
+                data-saved-filter={name}
+                data-active={active ? '' : undefined}
+                title={active ? `${query} (click to clear)` : query}
+                onClick={() => {
+                  if (active) setFilter('')
+                  else applySavedTaskFilter(name)
+                }}
+                onContextMenu={(e) => openSavedFilterMenu(e, name)}
+                className={[
+                  'rounded-full border px-2 py-0.5 text-xs transition-colors',
+                  active
+                    ? 'border-accent/50 bg-accent/15 text-accent'
+                    : 'border-paper-300/70 bg-paper-200/50 text-current/70 hover:bg-paper-200 hover:text-current/90'
+                ].join(' ')}
+              >
+                {name}
+              </button>
+            )
+          })}
+          {filter.trim() && !activeSavedName && (
+            <button
+              type="button"
+              data-save-filter
+              onClick={() => void saveCurrentFilter()}
+              title={vimMode ? 'Keep this query under a name (:savefilter <name>)' : 'Keep this query under a name'}
+              className="rounded-full border border-dashed border-paper-400/60 px-2 py-0.5 text-xs text-current/60 transition-colors hover:border-accent/50 hover:text-accent"
+            >
+              + Save filter…
+            </button>
+          )}
+        </div>
+      )}
+
       {viewMode === 'list' && (
         <div className="min-h-0 flex-1 overflow-y-auto px-2 py-2">
           {render.rows.length === 0 && !loading && (
@@ -801,14 +1020,14 @@ export function TasksView(): JSX.Element {
         <div className="border-t border-paper-300/45 px-4 py-1.5 text-xs text-current/40">
           {viewMode === 'list'
             ? vimMode
-              ? 'j/k move · J/K reorder · Enter/o open · x toggle · i start · c cancel · right-click actions · :q close'
+              ? 'j/k move · J/K reorder · Enter/o open · x toggle · i start · c cancel · F saved filters · right-click actions · :q close'
               : '↑/↓ move · Shift+J/K reorder · Enter open · right-click actions'
             : viewMode === 'calendar'
               ? vimMode
-                ? 'h/j/k/l day · [ ] month · Tab pick · x toggle · i start · c cancel · drag to move · right-click actions · :q'
+                ? 'h/j/k/l day · [ ] month · Tab pick · x toggle · i start · c cancel · F saved filters · drag to move · right-click actions · :q'
                 : 'h/j/k/l day · [ ] month · Tab pick · x toggle · drag to move · right-click actions'
               : vimMode
-                ? 'h/l column · j/k card · x toggle · i start · c cancel · Enter open · right-click actions · :q close'
+                ? 'h/l column · j/k card · x toggle · i start · c cancel · Enter open · F saved filters · right-click actions · :q close'
                 : 'h/l column · j/k card · x toggle · Enter open · right-click actions'}
         </div>
       )}
diff --git a/packages/app-core/src/components/VimNav.tsx b/packages/app-core/src/components/VimNav.tsx
index 79b5bc7e..80fad42f 100644
--- a/packages/app-core/src/components/VimNav.tsx
+++ b/packages/app-core/src/components/VimNav.tsx
@@ -35,6 +35,7 @@ import {
   getSequenceTokens,
   matchesSequenceToken,
   matchesShortcutBinding,
+  UNBOUND_BINDING,
   sequenceTokenFromEvent
 } from '../lib/keymaps'
 import { toggleWrap, wrapLink } from '../lib/cm-format'
@@ -375,7 +376,8 @@ export function VimNav(): JSX.Element | null {
       })
     }
     return items
-  })()
+    // An unbound leader action has no key to press, so it leaves the hints.
+  })().filter((item) => !!item.keyLabel)
 
   useEffect(() => {
     if (vimMode) return
@@ -397,8 +399,12 @@ export function VimNav(): JSX.Element | null {
     const handler = (e: KeyboardEvent): void => {
       const state = useStore.getState()
       const overrides = state.keymapOverrides
-      const leaderToken = getSequenceTokens(overrides, 'vim.leaderPrefix')[0] ?? 'Space'
-      const panePrefixToken = getSequenceTokens(overrides, 'vim.panePrefix')[0] ?? 'Ctrl+W'
+      // An unbound prefix has no token. The empty string never equals a token
+      // read off an event, so every comparison below stays false instead of
+      // quietly reviving the shipped default.
+      const leaderToken = getSequenceTokens(overrides, 'vim.leaderPrefix')[0] ?? UNBOUND_BINDING
+      const panePrefixToken =
+        getSequenceTokens(overrides, 'vim.panePrefix')[0] ?? UNBOUND_BINDING
 
       // Skip when modals / overlays are open
       if (
@@ -1308,7 +1314,8 @@ export function VimNav(): JSX.Element | null {
     const onKeyUp = (e: KeyboardEvent): void => {
       if (excalidrawSpaceDownAt.current == null) return
       const leaderToken =
-        getSequenceTokens(useStore.getState().keymapOverrides, 'vim.leaderPrefix')[0] ?? 'Space'
+        getSequenceTokens(useStore.getState().keymapOverrides, 'vim.leaderPrefix')[0] ??
+        UNBOUND_BINDING
       if (sequenceTokenFromEvent(e) !== leaderToken) return
       const downAt = excalidrawSpaceDownAt.current
       excalidrawSpaceDownAt.current = null
@@ -1747,6 +1754,7 @@ export function VimNav(): JSX.Element | null {
       key === 'o' ||
       key === 'e' ||
       key === 'r' ||
+      key === 'a' ||
       key === 'd' ||
       key === 'n' ||
       key === '+' ||
@@ -1828,6 +1836,12 @@ export function VimNav(): JSX.Element | null {
       clickCommentAction(current, 'resolve')
       return
     }
+    // `a` answers in the thread (#738); the composer inside the card takes
+    // focus, so the next keys type the reply.
+    if (key === 'a') {
+      clickCommentAction(current, 'reply')
+      return
+    }
     if (key === 'd' || key === 'Backspace' || key === 'Delete') {
       clickCommentAction(current, 'delete')
     }
diff --git a/packages/app-core/src/lib/cm-date-shortcuts.test.ts b/packages/app-core/src/lib/cm-date-shortcuts.test.ts
index 71fc745f..10a3b872 100644
--- a/packages/app-core/src/lib/cm-date-shortcuts.test.ts
+++ b/packages/app-core/src/lib/cm-date-shortcuts.test.ts
@@ -1,5 +1,18 @@
-import { describe, expect, it } from 'vitest'
-import { formatClockTime } from './cm-date-shortcuts'
+// @vitest-environment jsdom
+
+import { CompletionContext, type Completion } from '@codemirror/autocomplete'
+import { EditorState } from '@codemirror/state'
+import { EditorView } from '@codemirror/view'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { dateShortcutSource, formatClockTime } from './cm-date-shortcuts'
+
+const promptMocks = vi.hoisted(() => ({
+  promptDate: vi.fn<(options?: unknown) => Promise<string | null>>()
+}))
+
+vi.mock('./date-prompt-requests', () => ({
+  promptDate: promptMocks.promptDate
+}))
 
 const at = (h: number, m: number) => new Date(2026, 0, 1, h, m)
 
@@ -19,3 +32,77 @@ describe('formatClockTime', () => {
     expect(formatClockTime(at(23, 59), '12h')).toBe('11:59 PM')
   })
 })
+
+function optionsFor(doc: string): readonly Completion[] {
+  const state = EditorState.create({ doc, selection: { anchor: doc.length } })
+  const result = dateShortcutSource(new CompletionContext(state, doc.length, false))
+  return result?.options ?? []
+}
+
+function labels(doc: string): string[] {
+  return optionsFor(doc).map((o) => o.label)
+}
+
+function todayIso(): string {
+  const now = new Date()
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(
+    now.getDate()
+  ).padStart(2, '0')}`
+}
+
+describe('the @ menu', () => {
+  it('keeps the quick options and adds Date… at the end', () => {
+    expect(labels('meet @')).toEqual(['Today', 'Yesterday', 'Tomorrow', 'Now', 'Date…'])
+  })
+
+  it('finds the calendar by date, pick or calendar, and quick options by their names', () => {
+    expect(labels('meet @date')).toEqual(['Date…'])
+    expect(labels('meet @cal')).toEqual(['Date…'])
+    expect(labels('meet @pick')).toEqual(['Date…'])
+    expect(labels('meet @tom')).toEqual(['Tomorrow'])
+    expect(labels('meet @now')).toEqual(['Now'])
+  })
+})
+
+describe('picking a date from the @ menu', () => {
+  let view: EditorView
+
+  beforeEach(() => {
+    promptMocks.promptDate.mockReset()
+  })
+
+  afterEach(() => {
+    view.destroy()
+  })
+
+  function applyDatePick(doc: string): void {
+    view = new EditorView({
+      parent: document.body,
+      state: EditorState.create({ doc, selection: { anchor: doc.length } })
+    })
+    const context = new CompletionContext(view.state, doc.length, false)
+    const result = dateShortcutSource(context)!
+    const pick = result.options.find((o) => o.label === 'Date…')!
+    const apply = pick.apply as (view: EditorView, c: Completion, from: number, to: number) => void
+    apply(view, pick, result.from, doc.length)
+  }
+
+  it('drops the trigger, opens the calendar on today, and inserts the picked day where @ stood', async () => {
+    promptMocks.promptDate.mockResolvedValue('2027-03-14')
+    applyDatePick('meet @date')
+    // The trigger is gone before the calendar shows, so the note never
+    // carries a half-typed `@date` under the modal.
+    expect(view.state.doc.toString()).toBe('meet ')
+    expect(promptMocks.promptDate).toHaveBeenCalledWith({ initialDate: todayIso() })
+    await vi.waitFor(() => expect(view.state.doc.toString()).toBe('meet 2027-03-14'))
+    expect(view.state.selection.main.head).toBe('meet 2027-03-14'.length)
+  })
+
+  it('leaves clean text when the calendar is dismissed', async () => {
+    promptMocks.promptDate.mockResolvedValue(null)
+    applyDatePick('meet @da')
+    expect(view.state.doc.toString()).toBe('meet ')
+    await new Promise((r) => setTimeout(r, 0))
+    expect(view.state.doc.toString()).toBe('meet ')
+  })
+})
diff --git a/packages/app-core/src/lib/cm-date-shortcuts.ts b/packages/app-core/src/lib/cm-date-shortcuts.ts
index 004895be..8939b033 100644
--- a/packages/app-core/src/lib/cm-date-shortcuts.ts
+++ b/packages/app-core/src/lib/cm-date-shortcuts.ts
@@ -2,6 +2,8 @@ import type { Completion, CompletionContext, CompletionResult } from '@codemirro
 import type { EditorView } from '@codemirror/view'
 import type { TimeFormat } from '@shared/app-config'
 import { useStore } from '../store'
+import { formatISODate } from './date-picker'
+import { promptDate } from './date-prompt-requests'
 
 interface DateShortcut {
   label: string
@@ -9,6 +11,8 @@ interface DateShortcut {
   insert: string
   /** When set, computed fresh at apply time (used for the current time). */
   dynamicInsert?: () => string
+  /** Opens the calendar instead of inserting `insert` (#743). */
+  pick?: boolean
   searchText: string
   icon: string
 }
@@ -17,10 +21,6 @@ function pad2(n: number): string {
   return String(n).padStart(2, '0')
 }
 
-function formatISODate(date: Date): string {
-  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`
-}
-
 /** Wall-clock time in the given format: `14:30` (24h) or `2:30 PM` (12h). */
 export function formatClockTime(date: Date, format: TimeFormat): string {
   const minutes = pad2(date.getMinutes())
@@ -80,7 +80,39 @@ function buildShortcuts(now = new Date()): DateShortcut[] {
     icon: '🕘'
   }
 
-  return [...dates, time]
+  // #743: any other day. Its detail names the outcome, since there is no
+  // date to preview until the calendar returns one.
+  const pick: DateShortcut = {
+    label: 'Date…',
+    detail: 'Pick any date',
+    insert: '',
+    pick: true,
+    searchText: 'date… date pick picker calendar choose any other day',
+    icon: '📅'
+  }
+
+  return [...dates, time, pick]
+}
+
+/**
+ * Trades the `@…` trigger for the calendar. The trigger goes first, so a
+ * dismissed picker leaves the text as if nothing was typed, and the picked
+ * date lands exactly where the `@` stood. The position is re-clamped at
+ * insert time: the modal blocks editing, but a note switched underneath it
+ * (a sync, a remote change) can still shorten the document.
+ */
+function pickDate(view: EditorView, from: number, to: number): void {
+  view.dispatch({ changes: { from, to, insert: '' }, selection: { anchor: from } })
+  void promptDate({ initialDate: formatISODate(new Date()) }).then((iso) => {
+    if (iso) {
+      const at = Math.min(from, view.state.doc.length)
+      view.dispatch({
+        changes: { from: at, insert: iso },
+        selection: { anchor: at + iso.length }
+      })
+    }
+    view.focus()
+  })
 }
 
 function dateShortcutMatch(context: CompletionContext): {
@@ -117,6 +149,10 @@ export function dateShortcutSource(context: CompletionContext): CompletionResult
         _kind: 'date',
         _icon: item.icon,
         apply: (view: EditorView, _completion: Completion, _from: number, to: number) => {
+          if (item.pick) {
+            pickDate(view, match.replaceFrom, to)
+            return
+          }
           const insert = item.dynamicInsert ? item.dynamicInsert() : item.insert
           view.dispatch({
             changes: { from: match.replaceFrom, to, insert },
diff --git a/packages/app-core/src/lib/cm-math-render.test.ts b/packages/app-core/src/lib/cm-math-render.test.ts
index bdec3748..04bc6dfe 100644
--- a/packages/app-core/src/lib/cm-math-render.test.ts
+++ b/packages/app-core/src/lib/cm-math-render.test.ts
@@ -38,6 +38,32 @@ describe('mathRenderExtension', () => {
     view.destroy()
   })
 
+  it('renders a $$ block inside a callout, without the quote markers, as part of the card (#748)', () => {
+    const view = mount('start\n\n> [!note]\n> $$\n> a+b\n> $$\n\nend')
+    const blocks = view.dom.querySelectorAll('.cm-math-block')
+    expect(blocks.length).toBe(1)
+    expect(blocks[0].textContent).not.toContain('>')
+    expect(blocks[0].textContent).toContain('a')
+    expect(blocks[0].classList.contains('cm-callout')).toBe(true)
+    expect(blocks[0].classList.contains('cm-callout-note')).toBe(true)
+    view.destroy()
+  })
+
+  it('renders a $$ block inside a plain blockquote with the quote bar (#748)', () => {
+    const view = mount('start\n\n> $$\n> a+b\n> $$\n\nend')
+    const block = view.dom.querySelector('.cm-math-block')
+    expect(block).not.toBeNull()
+    expect(block?.classList.contains('cm-wq-quote')).toBe(true)
+    expect(block?.classList.contains('cm-callout')).toBe(false)
+    view.destroy()
+  })
+
+  it('still leaves a $$ with prose before it literal', () => {
+    const view = mount('start\n\nsee $$\na+b\n$$\n\nend')
+    expect(view.dom.querySelectorAll('.cm-math-block').length).toBe(0)
+    view.destroy()
+  })
+
   it('numbers equation environments in document order', () => {
     const view = mount(
       [
diff --git a/packages/app-core/src/lib/cm-math-render.ts b/packages/app-core/src/lib/cm-math-render.ts
index 27cabc91..0a3d21e6 100644
--- a/packages/app-core/src/lib/cm-math-render.ts
+++ b/packages/app-core/src/lib/cm-math-render.ts
@@ -21,6 +21,7 @@ import { Decoration, type DecorationSet, EditorView, WidgetType } from '@codemir
 import katex from 'katex'
 import type { MathRenderer } from '@shared/app-config'
 import { peekTypstMathSvg, renderTypstMathToSvg } from './typst-math-render'
+import { calloutGroupFor } from './callout-types'
 import { numberLatexEquationEnvironments } from './latex-equation-numbering'
 
 /** Which typesetter the live-preview widgets use. Supplied by
@@ -50,6 +51,57 @@ const typstPreambleFacet = Facet.define<string, string>({
 const INLINE_MATH_RE = /(?<![\\$])\$(?!\s)(?!\$)((?:\\.|[^$\\])+?)(?<!\s)\$(?!\$)/g
 // Block `$$…$$`, shortest match, may span lines.
 const BLOCK_MATH_RE = /\$\$(?!\$)([\s\S]+?)\$\$/g
+/** Blockquote markers at the start of a line: `> `, `> > `, ` >`. */
+const QUOTE_MARKERS_RE = /^(?:[ \t]{0,3}>[ \t]?)+/
+const CALLOUT_HEADER_RE = /^(?:[ \t]{0,3}>[ \t]?)+\[!(\w+)\]/
+
+/** How many blockquote markers `text` is made of: 0 for blank, null when it
+ *  holds anything else. What precedes a fence on its line must be one of
+ *  those two for the fence to own its line. */
+function quoteDepthOf(text: string): number | null {
+  if (text.trim() === '') return 0
+  const markers = text.match(QUOTE_MARKERS_RE)
+  if (!markers || text.slice(markers[0].length).trim() !== '') return null
+  return (markers[0].match(/>/g) ?? []).length
+}
+
+/** Drop up to `depth` blockquote markers from the start of every line. The
+ *  markers belong to the quote, not to the formula. */
+function stripQuoteMarkers(text: string, depth: number): string {
+  if (depth === 0) return text
+  return text
+    .split('\n')
+    .map((line) => {
+      let rest = line
+      for (let d = 0; d < depth; d++) {
+        const marker = rest.match(/^[ \t]{0,3}>[ \t]?/)
+        if (!marker) break
+        rest = rest.slice(marker[0].length)
+      }
+      return rest
+    })
+    .join('\n')
+}
+
+/** The classes that make a block widget part of the quote it sits in: the
+ *  callout card's body classes, or the plain quote's bar. cm-wysiwyg-blocks
+ *  draws the card line by line, and a widget replacing some of those lines
+ *  has to wear the same classes or the card breaks in two around the formula. */
+function quoteFrameClasses(state: EditorState, pos: number): string {
+  // The outermost quote is the one drawing the card, so keep climbing.
+  let node = syntaxTree(state).resolveInner(pos, 1)
+  let quoteFrom = -1
+  for (;;) {
+    if (node.name === 'Blockquote') quoteFrom = node.from
+    const parent = node.parent
+    if (!parent) break
+    node = parent
+  }
+  if (quoteFrom < 0) return ''
+  const header = state.doc.lineAt(quoteFrom).text.match(CALLOUT_HEADER_RE)
+  if (header) return `cm-callout cm-callout-${calloutGroupFor(header[1])}`
+  return 'cm-wq-quote'
+}
 
 function renderKatex(el: HTMLElement, latex: string, display: boolean): void {
   try {
@@ -138,7 +190,9 @@ class BlockMathWidget extends WidgetType {
   constructor(
     readonly latex: string,
     readonly renderer: MathRenderer,
-    readonly preamble = ''
+    readonly preamble = '',
+    /** Quote or callout classes when the block sits inside one (#748). */
+    readonly frame = ''
   ) {
     super()
   }
@@ -146,12 +200,13 @@ class BlockMathWidget extends WidgetType {
     return (
       other.latex === this.latex &&
       other.renderer === this.renderer &&
-      other.preamble === this.preamble
+      other.preamble === this.preamble &&
+      other.frame === this.frame
     )
   }
   toDOM(): HTMLElement {
     const el = document.createElement('div')
-    el.className = 'cm-math-block'
+    el.className = this.frame ? `cm-math-block ${this.frame}` : 'cm-math-block'
     renderMath(el, this.latex, true, this.renderer, this.preamble)
     return el
   }
@@ -214,16 +269,21 @@ function buildMathRender(state: EditorState): MathRenderValue {
     if (isInsideCode(state, rawFrom)) continue
     const openLine = doc.lineAt(rawFrom)
     const closeLine = doc.lineAt(rawTo)
-    // Only render when the fences own their lines (nothing but whitespace before
-    // the opening `$$` and after the closing `$$`), so the whole-line block
-    // replace can never swallow surrounding prose.
+    // Only render when the fences own their lines (nothing but whitespace, or
+    // a blockquote's markers, before the opening `$$` and nothing after the
+    // closing one), so the whole-line block replace can never swallow
+    // surrounding prose. A fence inside a callout is a fence too: its `> `
+    // used to read as prose and the block stayed raw there (#748).
     const before = openLine.text.slice(0, rawFrom - openLine.from)
     const after = closeLine.text.slice(rawTo - closeLine.from)
-    if (before.trim() !== '' || after.trim() !== '') continue
+    const depth = quoteDepthOf(before)
+    if (depth === null || after.trim() !== '') continue
+    const source = stripQuoteMarkers(inner, depth)
+    if (!source.trim()) continue
     const numbered =
       renderer === 'katex'
-        ? numberLatexEquationEnvironments(inner, equationNumber)
-        : { latex: inner, nextNumber: equationNumber }
+        ? numberLatexEquationEnvironments(source, equationNumber)
+        : { latex: source, nextNumber: equationNumber }
     equationNumber = numbered.nextNumber
     // Reserve the whole-line span so inline scanning skips inside it, whether the
     // block ends up rendered or revealed.
@@ -235,7 +295,12 @@ function buildMathRender(state: EditorState): MathRenderValue {
       to: closeLine.to,
       deco: Decoration.replace({
         block: true,
-        widget: new BlockMathWidget(numbered.latex, renderer, preamble)
+        widget: new BlockMathWidget(
+          numbered.latex,
+          renderer,
+          preamble,
+          depth > 0 ? quoteFrameClasses(state, openLine.from) : ''
+        )
       })
     })
   }
diff --git a/packages/app-core/src/lib/commands.test.ts b/packages/app-core/src/lib/commands.test.ts
index ef3d0028..37eba34a 100644
--- a/packages/app-core/src/lib/commands.test.ts
+++ b/packages/app-core/src/lib/commands.test.ts
@@ -350,3 +350,22 @@ describe('note commands for a trashed note (#712)', () => {
   })
 })
 
+
+describe('saved Tasks filters (#731)', () => {
+  it('lists one palette entry per saved filter, which opens Tasks and applies it', async () => {
+    const { buildCommands, useStore } = await loadCommands()
+    expect(buildCommands().some((c) => c.id.startsWith('tasks.savedFilter.'))).toBe(false)
+
+    useStore.getState().saveTaskFilter('Blocked', '@status:blocked')
+    useStore.getState().saveTaskFilter('Project alpha', '@project:alpha')
+    const entries = buildCommands().filter((c) => c.id.startsWith('tasks.savedFilter.'))
+    expect(entries.map((c) => c.title)).toEqual(['Tasks: Blocked', 'Tasks: Project alpha'])
+    expect(entries[1].keywords).toContain('@project:alpha')
+
+    const openTasksView = vi.fn().mockResolvedValue(undefined)
+    useStore.setState({ openTasksView })
+    await entries[1].run()
+    expect(openTasksView).toHaveBeenCalledTimes(1)
+    expect(useStore.getState().tasksFilter).toBe('@project:alpha')
+  })
+})
diff --git a/packages/app-core/src/lib/commands.ts b/packages/app-core/src/lib/commands.ts
index 7b1174e6..a9eeb6cd 100644
--- a/packages/app-core/src/lib/commands.ts
+++ b/packages/app-core/src/lib/commands.ts
@@ -81,15 +81,19 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma
   const pathLabel = (): string =>
     getState().workspaceMode === 'remote' ? 'Server Path' : 'Absolute Path'
   const shortcut = (id: KeymapId): string => getKeymapDisplay(getState().keymapOverrides, id)
-  const leaderShortcut = (id: KeymapId): string =>
-    `${shortcut('vim.leaderPrefix')} ${shortcut(id)}`
-  const paneShortcut = (id: KeymapId): string =>
-    `${shortcut('vim.panePrefix')} ${shortcut(id)}`
+  // A chord with an unbound step cannot be pressed, so the palette shows no
+  // key for it rather than half a sequence.
+  const chord = (...ids: KeymapId[]): string => {
+    const parts = ids.map(shortcut)
+    return parts.every(Boolean) ? parts.join(' ') : ''
+  }
+  const leaderShortcut = (id: KeymapId): string => chord('vim.leaderPrefix', id)
+  const paneShortcut = (id: KeymapId): string => chord('vim.panePrefix', id)
   const searchShortcut = (): string => {
     const state = getState()
     const primary = shortcut('global.searchNotes')
     if (state.vimMode) return primary
-    return `${primary} / ${shortcut('global.searchNotesNonVim')}`
+    return [primary, shortcut('global.searchNotesNonVim')].filter(Boolean).join(' / ')
   }
   const openExternal = (url: string): void => {
     window.open(url, '_blank')
@@ -1336,6 +1340,22 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma
     }
   )
 
+  // Saved Tasks filters (#731): one palette entry per name, so a filter is a
+  // few keystrokes away from any note. Opening the view resets the filter, so
+  // the query is applied once the open has settled.
+  for (const [name, query] of Object.entries(getState().savedTaskFilters)) {
+    cmds.push({
+      id: `tasks.savedFilter.${name}`,
+      title: `${labels().tasks}: ${name}`,
+      category: 'View',
+      keywords: `saved filter tasks ${query}`,
+      run: async () => {
+        if (!isTasksViewActive(getState())) await getState().openTasksView()
+        getState().applySavedTaskFilter(name)
+      }
+    })
+  }
+
   /* ---------------- Editor preferences ---------------- */
   cmds.push(
     {
diff --git a/packages/app-core/src/lib/comments.ts b/packages/app-core/src/lib/comments.ts
index 75ac41be..54615c4f 100644
--- a/packages/app-core/src/lib/comments.ts
+++ b/packages/app-core/src/lib/comments.ts
@@ -1,41 +1,11 @@
-import type { NoteComment } from '@shared/ipc'
-
-export interface ResolvedCommentAnchor {
-  from: number
-  to: number
-}
-
-export function resolveCommentAnchor(
-  comment: Pick<NoteComment, 'anchorStart' | 'anchorEnd' | 'anchorText'>,
-  doc: string
-): ResolvedCommentAnchor {
-  const docLength = doc.length
-  const from = Math.max(0, Math.min(docLength, comment.anchorStart))
-  const to = Math.max(from, Math.min(docLength, comment.anchorEnd))
-  const selected = doc.slice(from, to)
-  if (!comment.anchorText || selected === comment.anchorText) {
-    return { from, to }
-  }
-  const found = doc.indexOf(comment.anchorText)
-  if (found >= 0) return { from: found, to: found + comment.anchorText.length }
-  return { from, to }
-}
-
-export function selectionToCommentAnchor(
-  doc: string,
-  from: number,
-  to: number
-): Pick<NoteComment, 'anchorStart' | 'anchorEnd' | 'anchorText'> {
-  const start = Math.max(0, Math.min(doc.length, Math.min(from, to)))
-  const end = Math.max(start, Math.min(doc.length, Math.max(from, to)))
-  const selected = doc.slice(start, end).replace(/\s+/g, ' ').trim()
-  return {
-    anchorStart: start,
-    anchorEnd: end,
-    anchorText: selected.slice(0, 500)
-  }
-}
-
-export function commentQuote(comment: Pick<NoteComment, 'anchorText'>): string {
-  return comment.anchorText.trim() || 'Current cursor position'
-}
+/**
+ * The comment anchor helpers moved to shared-domain (#738) so the MCP server
+ * and the CLI resolve anchors exactly as the editor does. Re-exported here
+ * for the two components that import them.
+ */
+export {
+  commentQuote,
+  resolveCommentAnchor,
+  selectionToCommentAnchor,
+  type ResolvedCommentAnchor
+} from '@shared/note-comments'
diff --git a/packages/app-core/src/lib/date-picker.test.ts b/packages/app-core/src/lib/date-picker.test.ts
new file mode 100644
index 00000000..8526e68e
--- /dev/null
+++ b/packages/app-core/src/lib/date-picker.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest'
+import {
+  addMonths,
+  buildMonthGrid,
+  datePickerMoveForKey,
+  formatISODate,
+  moveDate,
+  parseISODate,
+  startOfWeek
+} from './date-picker'
+
+describe('parseISODate', () => {
+  it('round-trips a real local calendar day', () => {
+    const date = parseISODate('2026-09-08')
+    expect(date).not.toBeNull()
+    expect(date!.getFullYear()).toBe(2026)
+    expect(date!.getMonth()).toBe(8)
+    expect(date!.getDate()).toBe(8)
+    expect(date!.getHours()).toBe(0)
+    expect(formatISODate(date!)).toBe('2026-09-08')
+  })
+
+  it('accepts a leap day and rejects a day the month does not have', () => {
+    expect(formatISODate(parseISODate('2028-02-29')!)).toBe('2028-02-29')
+    expect(parseISODate('2026-02-29')).toBeNull()
+    expect(parseISODate('2026-02-30')).toBeNull()
+    expect(parseISODate('2026-13-01')).toBeNull()
+    expect(parseISODate('2026-00-10')).toBeNull()
+  })
+
+  it('wants the strict YYYY-MM-DD shape', () => {
+    expect(parseISODate('2026-9-8')).toBeNull()
+    expect(parseISODate('08/09/2026')).toBeNull()
+    expect(parseISODate('2026-09-08T10:00')).toBeNull()
+    expect(parseISODate('')).toBeNull()
+  })
+})
+
+describe('addMonths', () => {
+  it('clamps the day to the target month instead of rolling over', () => {
+    expect(formatISODate(addMonths(parseISODate('2026-01-31')!, 1))).toBe('2026-02-28')
+    expect(formatISODate(addMonths(parseISODate('2028-01-31')!, 1))).toBe('2028-02-29')
+    expect(formatISODate(addMonths(parseISODate('2026-03-31')!, -1))).toBe('2026-02-28')
+    expect(formatISODate(addMonths(parseISODate('2026-12-15')!, 1))).toBe('2027-01-15')
+    expect(formatISODate(addMonths(parseISODate('2028-02-29')!, 12))).toBe('2029-02-28')
+  })
+})
+
+describe('buildMonthGrid', () => {
+  it('lays out six weeks starting on the configured weekday', () => {
+    const monday = buildMonthGrid(parseISODate('2026-09-01')!, 1)
+    expect(monday).toHaveLength(42)
+    expect(monday[0].getDay()).toBe(1)
+    // September 2026 starts on a Tuesday: one leading day from August.
+    expect(formatISODate(monday[0])).toBe('2026-08-31')
+    expect(formatISODate(monday[1])).toBe('2026-09-01')
+    expect(formatISODate(monday[41])).toBe('2026-10-11')
+
+    const sunday = buildMonthGrid(parseISODate('2026-09-20')!, 0)
+    expect(sunday[0].getDay()).toBe(0)
+    expect(formatISODate(sunday[0])).toBe('2026-08-30')
+  })
+})
+
+describe('moveDate', () => {
+  const firstDay = 1
+  const at = (iso: string): Date => parseISODate(iso)!
+
+  it('moves by day, week, month and year', () => {
+    expect(formatISODate(moveDate(at('2026-09-08'), 'prev-day', firstDay))).toBe('2026-09-07')
+    expect(formatISODate(moveDate(at('2026-09-08'), 'next-day', firstDay))).toBe('2026-09-09')
+    expect(formatISODate(moveDate(at('2026-09-08'), 'prev-week', firstDay))).toBe('2026-09-01')
+    expect(formatISODate(moveDate(at('2026-09-08'), 'next-week', firstDay))).toBe('2026-09-15')
+    expect(formatISODate(moveDate(at('2026-09-30'), 'prev-month', firstDay))).toBe('2026-08-30')
+    expect(formatISODate(moveDate(at('2026-01-31'), 'next-month', firstDay))).toBe('2026-02-28')
+    expect(formatISODate(moveDate(at('2026-09-08'), 'prev-year', firstDay))).toBe('2025-09-08')
+    expect(formatISODate(moveDate(at('2026-09-08'), 'next-year', firstDay))).toBe('2027-09-08')
+  })
+
+  it('crosses month and year boundaries a day at a time', () => {
+    expect(formatISODate(moveDate(at('2026-12-31'), 'next-day', firstDay))).toBe('2027-01-01')
+    expect(formatISODate(moveDate(at('2026-03-01'), 'prev-day', firstDay))).toBe('2026-02-28')
+  })
+
+  it('finds the ends of the week for the configured first day', () => {
+    // 2026-09-10 is a Thursday.
+    expect(formatISODate(moveDate(at('2026-09-10'), 'week-start', 1))).toBe('2026-09-07')
+    expect(formatISODate(moveDate(at('2026-09-10'), 'week-end', 1))).toBe('2026-09-13')
+    expect(formatISODate(moveDate(at('2026-09-10'), 'week-start', 0))).toBe('2026-09-06')
+    expect(formatISODate(moveDate(at('2026-09-10'), 'week-end', 0))).toBe('2026-09-12')
+    expect(formatISODate(startOfWeek(at('2026-09-07'), 1))).toBe('2026-09-07')
+  })
+
+  it('jumps to today at local midnight', () => {
+    const today = new Date(2026, 8, 8, 17, 45)
+    const moved = moveDate(at('2020-01-01'), 'today', firstDay, today)
+    expect(formatISODate(moved)).toBe('2026-09-08')
+    expect(moved.getHours()).toBe(0)
+  })
+})
+
+describe('datePickerMoveForKey', () => {
+  it('follows the ARIA date-grid keys with any editing mode', () => {
+    const off = { shift: false, vimMode: false }
+    expect(datePickerMoveForKey('ArrowLeft', off)).toBe('prev-day')
+    expect(datePickerMoveForKey('ArrowRight', off)).toBe('next-day')
+    expect(datePickerMoveForKey('ArrowUp', off)).toBe('prev-week')
+    expect(datePickerMoveForKey('ArrowDown', off)).toBe('next-week')
+    expect(datePickerMoveForKey('PageUp', off)).toBe('prev-month')
+    expect(datePickerMoveForKey('PageDown', off)).toBe('next-month')
+    expect(datePickerMoveForKey('PageUp', { ...off, shift: true })).toBe('prev-year')
+    expect(datePickerMoveForKey('PageDown', { ...off, shift: true })).toBe('next-year')
+    expect(datePickerMoveForKey('Home', off)).toBe('week-start')
+    expect(datePickerMoveForKey('End', off)).toBe('week-end')
+  })
+
+  it('adds h/j/k/l and t only while Vim mode is on', () => {
+    const on = { shift: false, vimMode: true }
+    expect(datePickerMoveForKey('h', on)).toBe('prev-day')
+    expect(datePickerMoveForKey('l', on)).toBe('next-day')
+    expect(datePickerMoveForKey('k', on)).toBe('prev-week')
+    expect(datePickerMoveForKey('j', on)).toBe('next-week')
+    expect(datePickerMoveForKey('t', on)).toBe('today')
+    const off = { shift: false, vimMode: false }
+    for (const key of ['h', 'j', 'k', 'l', 't']) {
+      expect(datePickerMoveForKey(key, off)).toBeNull()
+    }
+    expect(datePickerMoveForKey('x', on)).toBeNull()
+  })
+})
diff --git a/packages/app-core/src/lib/date-picker.ts b/packages/app-core/src/lib/date-picker.ts
new file mode 100644
index 00000000..6110ec5f
--- /dev/null
+++ b/packages/app-core/src/lib/date-picker.ts
@@ -0,0 +1,162 @@
+/**
+ * Date math behind the `@date` calendar (#743): ISO round-trips, the month
+ * grid, and the moves its keyboard answers with. Everything works on local
+ * calendar days (never UTC): a date picked at 23:30 in Sydney must insert
+ * that day, not the one the UTC clock is still on. Kept pure so the picker's
+ * behavior is testable without rendering it, and so the `@` menu and the
+ * modal agree on what a day looks like on disk (`YYYY-MM-DD`).
+ */
+
+function pad2(n: number): string {
+  return String(n).padStart(2, '0')
+}
+
+export function formatISODate(date: Date): string {
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`
+}
+
+/**
+ * Strict `YYYY-MM-DD` to a local-midnight Date, or null. A day that does not
+ * exist (2026-02-30) is rejected rather than rolled into March: the picker
+ * would otherwise insert a date the user never typed.
+ */
+export function parseISODate(text: string): Date | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text)
+  if (!match) return null
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  if (month < 1 || month > 12 || day < 1 || day > 31) return null
+  const date = new Date(year, month - 1, day)
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
+    return null
+  }
+  return date
+}
+
+export function startOfDay(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate())
+}
+
+export function firstOfMonth(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), 1)
+}
+
+export function addDays(date: Date, days: number): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + days)
+}
+
+/**
+ * Same day-of-month `months` away, clamped to the target month's length
+ * (Jan 31 + 1 month is Feb 28, not Mar 3). PageUp/PageDown in the picker
+ * would otherwise skip past short months.
+ */
+export function addMonths(date: Date, months: number): Date {
+  const first = new Date(date.getFullYear(), date.getMonth() + months, 1)
+  const lastDay = new Date(first.getFullYear(), first.getMonth() + 1, 0).getDate()
+  return new Date(first.getFullYear(), first.getMonth(), Math.min(date.getDate(), lastDay))
+}
+
+/** First day of the week containing `date`, with `firstDay` as 0 (Sunday) .. 6. */
+export function startOfWeek(date: Date, firstDay: number): Date {
+  return addDays(date, -((date.getDay() - firstDay + 7) % 7))
+}
+
+/** 6-row (42-cell) grid for the month containing `anchor`, starting on `firstDay`. */
+export function buildMonthGrid(anchor: Date, firstDay: number): Date[] {
+  const start = startOfWeek(firstOfMonth(anchor), firstDay)
+  return Array.from({ length: 42 }, (_, i) => addDays(start, i))
+}
+
+export function monthTitle(date: Date): string {
+  return date.toLocaleDateString(undefined, { month: 'long', year: 'numeric' })
+}
+
+export type DatePickerMove =
+  | 'prev-day'
+  | 'next-day'
+  | 'prev-week'
+  | 'next-week'
+  | 'prev-month'
+  | 'next-month'
+  | 'prev-year'
+  | 'next-year'
+  | 'week-start'
+  | 'week-end'
+  | 'today'
+
+export function moveDate(
+  date: Date,
+  move: DatePickerMove,
+  firstDay: number,
+  today: Date = new Date()
+): Date {
+  switch (move) {
+    case 'prev-day':
+      return addDays(date, -1)
+    case 'next-day':
+      return addDays(date, 1)
+    case 'prev-week':
+      return addDays(date, -7)
+    case 'next-week':
+      return addDays(date, 7)
+    case 'prev-month':
+      return addMonths(date, -1)
+    case 'next-month':
+      return addMonths(date, 1)
+    case 'prev-year':
+      return addMonths(date, -12)
+    case 'next-year':
+      return addMonths(date, 12)
+    case 'week-start':
+      return startOfWeek(date, firstDay)
+    case 'week-end':
+      return addDays(startOfWeek(date, firstDay), 6)
+    case 'today':
+      return startOfDay(today)
+  }
+}
+
+/**
+ * The picker's keyboard: the WAI-ARIA date-grid pattern (arrows move a day or
+ * a week, PageUp/PageDown a month, with Shift a year, Home/End the week's
+ * ends), plus h/j/k/l and `t` (today) only while Vim mode is on. With Vim off
+ * a letter must never be a shortcut, the same rule the list views follow.
+ */
+export function datePickerMoveForKey(
+  key: string,
+  modifiers: { shift: boolean; vimMode: boolean }
+): DatePickerMove | null {
+  switch (key) {
+    case 'ArrowLeft':
+      return 'prev-day'
+    case 'ArrowRight':
+      return 'next-day'
+    case 'ArrowUp':
+      return 'prev-week'
+    case 'ArrowDown':
+      return 'next-week'
+    case 'PageUp':
+      return modifiers.shift ? 'prev-year' : 'prev-month'
+    case 'PageDown':
+      return modifiers.shift ? 'next-year' : 'next-month'
+    case 'Home':
+      return 'week-start'
+    case 'End':
+      return 'week-end'
+  }
+  if (!modifiers.vimMode) return null
+  switch (key) {
+    case 'h':
+      return 'prev-day'
+    case 'l':
+      return 'next-day'
+    case 'k':
+      return 'prev-week'
+    case 'j':
+      return 'next-week'
+    case 't':
+      return 'today'
+  }
+  return null
+}
diff --git a/packages/app-core/src/lib/date-prompt-requests.ts b/packages/app-core/src/lib/date-prompt-requests.ts
new file mode 100644
index 00000000..f92c8e33
--- /dev/null
+++ b/packages/app-core/src/lib/date-prompt-requests.ts
@@ -0,0 +1,50 @@
+import type { DatePickerOptions } from '../components/DatePickerModal'
+
+/**
+ * The calendar counterpart of `promptApp`: any code with no React context
+ * (a CodeMirror completion's `apply`, an ex command) can ask for a date and
+ * await the ISO string, while `DatePickerHost` renders the modal. One request
+ * at a time, like the text prompt: a second `promptDate` while one is open
+ * replaces it on screen and the first promise stays pending until settled.
+ */
+export type DatePromptRequest = {
+  options: DatePickerOptions
+  resolve: (value: string | null) => void
+}
+
+let currentRequest: DatePromptRequest | null = null
+const listeners = new Set<(request: DatePromptRequest | null) => void>()
+
+function emit(): void {
+  for (const listener of listeners) listener(currentRequest)
+}
+
+export function getDatePromptRequest(): DatePromptRequest | null {
+  return currentRequest
+}
+
+export function subscribeDatePromptRequests(
+  listener: (request: DatePromptRequest | null) => void
+): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+/** Resolves with the picked `YYYY-MM-DD`, or null when the picker is dismissed. */
+export function promptDate(options: DatePickerOptions = {}): Promise<string | null> {
+  return new Promise((resolve) => {
+    currentRequest = { options, resolve }
+    emit()
+  })
+}
+
+export function settleDatePromptRequest(request: DatePromptRequest, value: string | null): void {
+  const resolve = request.resolve
+  if (currentRequest === request) {
+    currentRequest = null
+    emit()
+  }
+  queueMicrotask(() => resolve(value))
+}
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 31c5d7c5..ddfc7311 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -51,7 +51,7 @@ export const HELP_QUICK_START: HelpCard[] = [
   {
     title: 'Insert structure while you type',
     body:
-      'Type `/` to insert headings, lists, callouts, code blocks, tables, links, images, and other markdown structures. Type `@` to insert date shortcuts like Today and Tomorrow as ISO dates, or `@time` / `@now` for the current time.'
+      'Type `/` to insert headings, lists, callouts, code blocks, tables, links, images, and other markdown structures. Type `@` to insert date shortcuts like Today and Tomorrow as ISO dates, `@time` / `@now` for the current time, or `@date` to pick any other day from a calendar.'
   },
   {
     title: 'Format a selection',
@@ -232,7 +232,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Comments attach to selected text',
     body:
-      'Select text in the editor and press `Mod+Alt+M` — or open the text menu with `m` — to start a comment, and toggle the Comments panel itself with `Mod+Shift+C`. ZenNotes stores note comments beside the note in vault metadata, then highlights the anchored text and line when the comment is active. In the panel, move with `j` / `k` and use `e` to edit, `r` to resolve, and `d` to delete.'
+      'Select text in the editor and press `Mod+Alt+M` (or open the text menu with `m`) to start a comment, and toggle the Comments panel itself with `Mod+Shift+C`. ZenNotes stores note comments beside the note in vault metadata, then highlights the anchored text and line when the comment is active. In the panel, move with `j` / `k` and use `a` to reply, `e` to edit, `r` to resolve, and `d` to delete. Comments thread: a reply sits under the comment it answers, and each one names who wrote it, so a note can be discussed the way a pull request is. An AI assistant connected through MCP can take part: `list_comments` reads the threads, `reply_to_comment` answers in one, `add_comment` starts a new thread anchored to a passage, and `resolve_comment` closes it, each signed with the assistant\'s name (Claude, Claude Code, Codex) so its replies stand apart from yours. `zn comment list|add|reply|resolve` does the same from a terminal.'
   },
   {
     title: 'The home view is where you land',
@@ -287,12 +287,12 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'The Tasks Kanban board, custom statuses, and any field',
     body:
-      'Switch Tasks to Kanban (button or `3`) for a column board. "Group by" offers Status (Today / Upcoming / In progress / Waiting / Done, derived from due dates, `[/]` and `@waiting`), Priority, Folder, Custom status, and one entry per inline `@field` you use. On the Status board a started task (`[/]`) sits in its own In progress column between Upcoming and Waiting: drop a card there (or send it with `Shift+L`) to mark it `[/]`, drop it back on Today or Upcoming to reopen it with that date, and a `@waiting` card keeps its `[/]` underneath so clearing the wait returns it to In progress. Any task field works: tag tasks with `@key:value` tokens like `@status:review`, `@sprint:24`, or `@area:backend`, and each key becomes its own board with a column per value (auto-discovered, so it appears the moment you use it). For the status field, define the columns under Settings → Tasks → Kanban statuses, or list them in order in `config.toml` under `[view]`, e.g. `kanban_statuses = ["backlog", "in_progress", "review", "done"]`; other fields sort their columns automatically. A note-level `status:` in frontmatter sets a default for that note’s tasks. A note tagged `task` is a card of its own: its frontmatter `status:` is its custom status, and without one it sits in the trailing No status column until you move it. Everything is keyboard-first: `h`/`l` move between columns, `j`/`k` between cards, `g` cycles the group-by, `Shift+H` / `Shift+L` send the focused card to the previous/next column (rewriting its `@field` token), `<` / `>` reorder the columns themselves (saved per board), and `Space`/`Enter` toggle/open. Drag does the same with the mouse — including dragging a column header to reorder, and dragging a card to a new spot inside its column to hand-prioritize it (that arrangement is saved per column and restored when you come back to the board). Renaming a column (click its title, or `[kanban_column_titles]` in `config.toml`) sets a display label only: the column still shows its underlying `@field:value` beneath the name, and moving a card in writes that value, not the label.'
+      'Switch Tasks to Kanban (button or `3`) for a column board. "Group by" offers Status (Today / Upcoming / In progress / Waiting / Done, derived from due dates, `[/]` and `@waiting`), Priority, Folder, Custom status, and one entry per inline `@field` you use. The Folder board gives every note folder its own column (`Projects/alpha`, `Areas`, the Inbox root, Quick Notes), so notes that live together group together with nothing to maintain; point it at one folder under Settings → Tasks → Folder board, with `:folderroot Projects` on the board, or with `kanban_folder_root = "Projects"` in config.toml, and that folder\'s children become the columns, deeper notes roll up to their child, and notes outside it share an Other folders column. Folder columns stay read-only: move a note to change its column. On the Status board a started task (`[/]`) sits in its own In progress column between Upcoming and Waiting: drop a card there (or send it with `Shift+L`) to mark it `[/]`, drop it back on Today or Upcoming to reopen it with that date, and a `@waiting` card keeps its `[/]` underneath so clearing the wait returns it to In progress. Any task field works: tag tasks with `@key:value` tokens like `@status:review`, `@sprint:24`, or `@area:backend`, and each key becomes its own board with a column per value (auto-discovered, so it appears the moment you use it). For the status field, define the columns under Settings → Tasks → Kanban statuses, or list them in order in `config.toml` under `[view]`, e.g. `kanban_statuses = ["backlog", "in_progress", "review", "done"]`; other fields sort their columns automatically. A note-level `status:` in frontmatter sets a default for that note’s tasks. A note tagged `task` is a card of its own: its frontmatter `status:` is its custom status, and without one it sits in the trailing No status column until you move it. Everything is keyboard-first: `h`/`l` move between columns, `j`/`k` between cards, `g` cycles the group-by, `Shift+H` / `Shift+L` send the focused card to the previous/next column (rewriting its `@field` token), `<` / `>` reorder the columns themselves (saved per board), and `Space`/`Enter` toggle/open. Drag does the same with the mouse, including dragging a column header to reorder, and dragging a card to a new spot inside its column to hand-prioritize it (that arrangement is saved per column and restored when you come back to the board). Renaming a column (click its title, or `[kanban_column_titles]` in `config.toml`) sets a display label only: the column still shows its underlying `@field:value` beneath the name, and moving a card in writes that value, not the label.'
   },
   {
     title: 'Filter the Tasks views to one project',
     body:
-      'The filter box in the Tasks header narrows all three sub-views: the list, the calendar, and the Kanban board (where cards filter out but the columns stay put, so the board keeps its shape while you type). Press `/` to focus it (Vim mode), type in it directly, or run `:filter <text>` from the ex line; `Esc` or a bare `:filter` clears it, and the query survives switching views, so a filtered list stays filtered when you jump to the board. Matching is a simple substring check across the task text, the note title, tags (with the `#`, so `#project-beta` narrows to that tag), `!high`-style priorities, and `@key:value` fields. The fields are the project trick: tag tasks with `@project:alpha`, then filter `@project:alpha` while the board is grouped by status, and you have a one-project board; the header shows how many tasks match. A filtered board is still fully live: drag or `Shift+H`/`L` still move cards, and hand-arranged card order is preserved for the cards the filter is hiding.'
+      'The filter box in the Tasks header narrows all three sub-views: the list, the calendar, and the Kanban board (where cards filter out but the columns stay put, so the board keeps its shape while you type). Press `/` to focus it (Vim mode), type in it directly, or run `:filter <text>` from the ex line; `Esc` or a bare `:filter` clears it, and the query survives switching views, so a filtered list stays filtered when you jump to the board. Matching is a simple substring check across the task text, the note title, tags (with the `#`, so `#project-beta` narrows to that tag), `!high`-style priorities, and `@key:value` fields. The fields are the project trick: tag tasks with `@project:alpha`, then filter `@project:alpha` while the board is grouped by status, and you have a one-project board; the header shows how many tasks match. A filtered board is still fully live: drag or `Shift+H`/`L` still move cards, and hand-arranged card order is preserved for the cards the filter is hiding. A query worth typing twice is worth saving: press **Save filter…** in the row under the header (or run `:savefilter <name>`) and it becomes a chip there; click a chip, run `:filter <name>`, or press `F` (Vim mode) to pick one from a list, and the command palette lists every saved filter as "Tasks: name" so you can jump to it from any note. Right-click a chip to rename or delete it. Saved filters are kept in config.toml under `[saved_filters]`, one `"Name" = "query"` line each, so they travel with your dotfiles and a hand edit applies live.'
   },
   {
     title: 'Forward a task to another note',
@@ -490,6 +490,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'Mod+2', action: 'Toggle connections', detail: 'Toggle the connections panel for the active editor pane.' },
       { keys: 'Mod+Shift+C', action: 'Toggle comments panel', detail: 'Show or hide the Comments panel for the active pane.' },
       { keys: 'Mod+Alt+M', action: 'Add comment', detail: 'Start a comment on the selected text (or the current line) without reaching for the mouse.' },
+      { keys: 'a', action: 'Reply in a comment thread', detail: 'Comments panel: open a reply box under the selected comment; `Mod+Enter` sends it, `Esc` cancels.' },
       { keys: 'Alt+H / Alt+J / Alt+K / Alt+L', action: 'Focus pane left / down / up / right', detail: 'Always-on pane-focus motions — they work even with Vim mode off and skip the Ctrl+W prefix some Linux setups intercept. (Ctrl+W h/j/k/l still works in Vim mode.) Both walk the same cycle, in the order the panels appear on screen: sidebar → note list → editor → connections → comments → outline → calendar, and back again.' },
       { keys: '↑ / ↓ / Enter / Esc', action: 'Move inside a focused panel', detail: 'Once a panel has focus, the arrows move its row cursor, Home and End jump to the ends, Enter opens the row under the cursor, and Esc (or ←) returns focus to the editor. These work with Vim mode off; the single-key motions (j / k, gg / G) stay Vim-only.' },
       { keys: 'Mod+.', action: 'Toggle Zen mode', detail: 'Hide or restore the app chrome so only the active editor, preview, or split view stays on screen.' },
@@ -610,7 +611,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
         keys: '@',
         action: 'Open date/time shortcuts',
         detail:
-          'Show inline suggestions for Today, Yesterday, Tomorrow, and the current time (`@time` / `@now`) while writing so you can insert dates and times without leaving the keyboard.'
+          'Show inline suggestions for Today, Yesterday, Tomorrow, the current time (`@time` / `@now`), and Date…, a calendar for any other day (`@date`: arrows move, PageUp/PageDown change the month, Enter inserts), so you can insert dates and times without leaving the keyboard.'
       },
       {
         keys: 'Select text, then m',
@@ -656,6 +657,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'r', action: 'Restore trashed note', detail: 'Trash view only: restore the selected trashed note.' },
       { keys: 'x / d', action: 'Delete forever', detail: 'Trash view only: permanently delete the selected trashed note after confirmation.' },
       { keys: '/', action: 'Filter the view', detail: 'Focus the local filter box for tasks, tag matches, or trashed notes.' },
+      { keys: 'F', action: 'Pick a saved Tasks filter', detail: 'Tasks view: open the list of saved filters and apply one. Save the current query with the Save filter… chip or `:savefilter <name>`.' },
       { keys: ':', action: 'Open local ex prompt', detail: 'Run the view-specific command line inside Tasks or Tags.' },
       { keys: 'Esc', action: 'Clear the filter', detail: 'Clears an active filter. These views are tabs, so Esc no longer closes them — close with :q or the ✕ in the tab header.' }
     ]
@@ -734,6 +736,31 @@ export const HELP_VIM_COMMANDS: HelpExCommand[] = [
     summary: 'Grammar and spelling with Harper',
     detail: 'Turn Harper on or off for the editor, or toggle it with no argument. The same switch as Settings, Editor, Grammar and spelling with Harper.'
   },
+  {
+    command: ':unbind action.id',
+    summary: 'Remove an action’s key entirely',
+    detail: 'Leave an action with no key at all, instead of parking it on some obscure chord: `:unbind global.zoomIn` takes Zoom in off its key until it is rebound or reset under Settings, Keymaps. Bare `:unbind` opens that page, which lists every action id. The unbind travels in `config.toml` as `\"global.zoomIn\" = \"\"`.'
+  },
+  {
+    command: ':ignorekey <key>',
+    summary: 'Ignore a key everywhere',
+    detail: 'Adds a key the app should never see, such as the KanaMode no-op a Kanata or QMK tap-hold layer sends with every keystroke, so it stops resetting `jk`, `dd`, leader chords and hints. Bare `:ignorekey` opens Settings, Keymap, where the recorder names the key. Same as `ignored_keys` under `[editor]` in config.toml.'
+  },
+  {
+    command: ':filter <text or name>',
+    summary: 'Filter the Tasks views',
+    detail: 'In the Tasks view, narrows the list, the calendar, and the Kanban board to tasks matching the text; when the text is the name of a saved filter, that filter is applied instead. Bare `:filter` (or `:f`) clears it.'
+  },
+  {
+    command: ':savefilter <name>',
+    summary: 'Save the current Tasks filter under a name',
+    detail: 'Keeps the query in the Tasks filter box as a saved filter called `<name>` (bare `:savefilter`, or `:sf`, asks for the name). It shows up as a chip under the Tasks header, in the command palette as “Tasks: name”, and in config.toml under `[saved_filters]`.'
+  },
+  {
+    command: ':delfilter <name>',
+    summary: 'Delete a saved Tasks filter',
+    detail: 'Forgets the saved filter called `<name>` (`:df` for short). Deleting the line under `[saved_filters]` in config.toml does the same.'
+  },
   {
     command: ':q',
     summary: 'Close the current tab or virtual view',
@@ -1074,7 +1101,9 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
       { label: 'Recorded sequences', detail: 'Capture single shortcuts or multi-step sequences such as Leader flows, pane prefixes, `g g`, `g d`, or fold motions without editing raw config files.' },
       { label: 'Conflict detection', detail: 'When you record a global shortcut that another action already uses, the recorder names the clash and disables Save, so two actions can no longer silently share one key. Any existing clash shows a badge on the affected rows. Vim, navigation, and view keys that deliberately reuse a key by context are left alone.' },
       { label: 'Context-menu bindings', detail: 'The same keymap table controls the context-menu action used in the sidebar, note list, and preview-side active-tab menu, so mouse-free navigation stays configurable.' },
-      { label: 'Reset controls', detail: 'Clear an individual override or reset the entire keymap table back to the shipped defaults.' }
+      { label: 'Unbind a key', detail: 'Unbind removes an action’s key entirely instead of parking it on some obscure chord: nothing triggers the action until you record a new key or reset it, the row reads “Unbound”, and the which-key hints, the command palette, and this manual stop advertising it. Unbind sits next to Change on every row and inside the recorder; `:unbind <action.id>` (for example `:unbind global.zoomIn`) does the same from the ex line, and in `config.toml` the entry is `"global.zoomIn" = ""`.' },
+      { label: 'Reset controls', detail: 'Clear an individual override, including an unbind, or reset the entire keymap table back to the shipped defaults.' },
+      { label: 'Ignored keys', detail: 'Keys the app never sees. Keyboard remappers with tap-hold layers (Kanata, QMK, ZMK) send a harmless extra key with every keystroke, on Linux usually the Katakana/Hiragana key, which reads as KanaMode, and each one used to reset a pending `jk`, `dd`, leader chord or hint. Record the key here (or `:ignorekey KanaMode`, or `ignored_keys = ["KanaMode"]` under `[editor]` in config.toml) and it is swallowed before the editor or any panel reacts.' }
     ]
   },
   {
@@ -1098,7 +1127,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
       { label: 'Create a custom template', detail: 'Author a new template as markdown with optional frontmatter (`name`, `description`, `category`, `titleTemplate`, `targetFolder`, `targetSubpath`) and variables like `{{title}}`, `{{date}}`, `{{date:FORMAT}}`, `{{time}}`, `{{week}}`, and `{{cursor}}`. It is saved as a `.md` file in `.zennotes/templates/`.' },
       { label: 'Edit or reset built-ins', detail: 'Press Edit on a built-in to fork an editable copy that shadows the original everywhere; Reset removes the copy and restores the built-in. Custom templates can be edited or deleted directly.' },
       { label: 'Remove or restore built-ins', detail: 'Hide all the shipped templates with “Remove Built-in Templates” (a button here, or the command palette; it asks first), and bring them back with “Restore Built-in Templates”. Your custom templates, and anything already pointing at a built-in by id, keep working.' },
-      { label: 'Where templates appear', detail: 'Use a template via the picker (`Space t` / `:template` / “New Note from Template…”), from a folder’s right-click “New from template”, or as the assigned daily/weekly note template. Custom templates require a local vault; built-ins work everywhere.' }
+      { label: 'Where templates appear', detail: 'Use a template via the picker (`Space t` / `:template` / “New Note from Template…”), from a folder’s right-click “New from template”, or as the assigned daily/weekly note template. Custom templates work on a local vault, in the self-hosted web client, and on a remote vault served by ZenNotes server 2.46 or later; they are `.md` files in the vault’s `.zennotes/templates/`, so one saved in any client shows up in the others. Built-ins work everywhere.' }
     ]
   },
   {
@@ -1136,7 +1165,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
       { label: 'App identity', detail: 'See the ZenNotes app icon, current version, and a short description of the app as a keyboard-first markdown workflow with Vim motions and plain local files.' },
       { label: 'Updates and releases', detail: 'Check for updates, download a newer build, install and relaunch, or jump straight to the latest GitHub release from inside the app. AUR and tarball installs get the check and the notice only; the package manager does the install.' },
       { label: 'Website, community, and issue links', detail: 'The app now exposes direct links to the ZenNotes website, Discord, GitHub repository, and issue tracker so support paths stay discoverable.' },
-      { label: 'Configuration file', detail: 'Your preferences — theme, editor, Vim, keymaps, fonts, search backend, and more — are mirrored to a plain-text `config.toml` so you can sync them across machines with git, stow, or chezmoi. It lives at `$XDG_CONFIG_HOME/zennotes/config.toml` (`~/.config/zennotes/config.toml` on macOS and Linux, `%APPDATA%\\zennotes\\config.toml` on Windows), or wherever `$ZENNOTES_CONFIG_DIR` points. The file is self-documenting: every available setting is listed with its allowed values, and every keymap action is listed with its default binding (commented out — uncomment a line and edit it to remap), so you can discover and change anything without opening the app. Settings → About has Reveal and Copy-path buttons. Existing setups are written out automatically the first time you launch this version, and edits to the file — by hand or via a synced dotfile — apply live without a restart. Machine-specific layout (window size, pane widths, collapsed folders) stays local so the file does not churn.' },
+      { label: 'Configuration file', detail: 'Your preferences (theme, editor, Vim, keymaps, fonts, search backend, and more) are mirrored to a plain-text `config.toml` so you can sync them across machines with git, stow, or chezmoi. It lives at `$XDG_CONFIG_HOME/zennotes/config.toml` (`~/.config/zennotes/config.toml` on macOS and Linux, `%APPDATA%\\zennotes\\config.toml` on Windows), or wherever `$ZENNOTES_CONFIG_DIR` points. The file is self-documenting: every available setting is listed with its allowed values, and every keymap action is listed with its default binding (commented out: uncomment a line and edit it to remap, or set it to `""` to remove the key entirely), so you can discover and change anything without opening the app. Settings → About has Reveal and Copy-path buttons. Existing setups are written out automatically the first time you launch this version, and edits to the file, by hand or via a synced dotfile, apply live without a restart. Machine-specific layout (window size, pane widths, collapsed folders) stays local so the file does not churn.' },
       { label: 'Lumary Labs', detail: 'The About section links to Lumary Labs at lumarylabs.com so company details stay easy to find from inside the app.' }
     ]
   }
@@ -1196,6 +1225,6 @@ export const HELP_CLI: HelpCard[] = [
   {
     title: 'MCP for AI agents',
     body:
-      '`zn mcp` starts the ZenNotes MCP server in stdio mode — the same one Claude Code, Claude Desktop, and Codex use under the hood. Once `zn` is installed, Settings → MCP installs configure the clients to launch `zn mcp` directly, so the install path is one stable absolute path that survives app moves. The server works on the vault the app has open: a folder on this machine, or a self-hosted ZenNotes server you connected from Settings → Vault. `vault_info` says which. A server that requires a token needs it in the MCP client\'s environment as `ZENNOTES_REMOTE_TOKEN` (the app keeps its own copy in the OS secret store, which `zn` cannot read); `ZENNOTES_SERVER` or `ZENNOTES_VAULT` in that environment point the MCP at another vault instead.'
+      '`zn mcp` starts the ZenNotes MCP server in stdio mode, the same one Claude Code, Claude Desktop, and Codex use under the hood. Once `zn` is installed, Settings → MCP installs configure the clients to launch `zn mcp` directly, so the install path is one stable absolute path that survives app moves. The server works on the vault the app has open: a folder on this machine, or a self-hosted ZenNotes server you connected from Settings → Vault. `vault_info` says which. A server that requires a token needs it in the MCP client\'s environment as `ZENNOTES_REMOTE_TOKEN` (the app keeps its own copy in the OS secret store, which `zn` cannot read); `ZENNOTES_SERVER` or `ZENNOTES_VAULT` in that environment point the MCP at another vault instead. Beyond reading and writing notes, the server can hold a review with you through comments: ask the assistant to read a note\'s comments and answer them, and its replies land in the Comments panel under yours, signed with its name (`list_comments`, `add_comment`, `reply_to_comment`, `resolve_comment`).'
   }
 ]
diff --git a/packages/app-core/src/lib/ignored-keys.test.ts b/packages/app-core/src/lib/ignored-keys.test.ts
new file mode 100644
index 00000000..b5763f6f
--- /dev/null
+++ b/packages/app-core/src/lib/ignored-keys.test.ts
@@ -0,0 +1,98 @@
+// @vitest-environment jsdom
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  MAX_IGNORED_KEYS,
+  ignoredKeyTokenFromEvent,
+  installIgnoredKeysGuard,
+  isIgnoredKeyEvent,
+  normalizeIgnoredKeys,
+  setIgnoredKeysRecorderActive
+} from './ignored-keys'
+
+describe('normalizeIgnoredKeys', () => {
+  it('keeps trimmed unique names, ignoring case, and caps the list', () => {
+    expect(normalizeIgnoredKeys([' KanaMode ', 'kanamode', 'F24', '', 3, null])).toEqual(['KanaMode', 'F24'])
+    expect(normalizeIgnoredKeys('KanaMode')).toEqual([])
+    const many = Array.from({ length: MAX_IGNORED_KEYS + 5 }, (_, i) => `F${i + 1}`)
+    expect(normalizeIgnoredKeys(many)).toHaveLength(MAX_IGNORED_KEYS)
+  })
+})
+
+describe('key matching', () => {
+  it('matches by key or by physical code, case-insensitively', () => {
+    const list = ['KanaMode', 'lang1']
+    expect(isIgnoredKeyEvent({ key: 'KanaMode', code: 'KanaMode' }, list)).toBe(true)
+    expect(isIgnoredKeyEvent({ key: 'Unidentified', code: 'Lang1' }, list)).toBe(true)
+    expect(isIgnoredKeyEvent({ key: 'j', code: 'KeyJ' }, list)).toBe(false)
+    expect(isIgnoredKeyEvent({ key: 'KanaMode', code: 'KanaMode' }, [])).toBe(false)
+  })
+
+  it('names a key by its DOM key, falling back to the code for unidentified keys', () => {
+    expect(ignoredKeyTokenFromEvent(new KeyboardEvent('keydown', { key: 'KanaMode', code: 'KanaMode' }))).toBe('KanaMode')
+    expect(ignoredKeyTokenFromEvent(new KeyboardEvent('keydown', { key: 'Unidentified', code: 'Lang1' }))).toBe('Lang1')
+    expect(ignoredKeyTokenFromEvent(new KeyboardEvent('keydown', { key: 'Dead', code: 'Quote' }))).toBe('Quote')
+  })
+})
+
+describe('installIgnoredKeysGuard', () => {
+  let uninstall: (() => void) | null = null
+  afterEach(() => {
+    uninstall?.()
+    uninstall = null
+    setIgnoredKeysRecorderActive(false)
+  })
+
+  function press(target: EventTarget, key: string, type = 'keydown'): KeyboardEvent {
+    const event = new KeyboardEvent(type, { key, code: key, bubbles: true, cancelable: true })
+    target.dispatchEvent(event)
+    return event
+  }
+
+  it('swallows listed keys before element listeners and leaves other keys alone', () => {
+    const list: string[] = ['KanaMode']
+    uninstall = installIgnoredKeysGuard(() => list)
+    const editor = document.createElement('div')
+    document.body.appendChild(editor)
+    const seen: string[] = []
+    editor.addEventListener('keydown', (e) => seen.push(`el:${e.key}`))
+    document.addEventListener('keydown', (e) => seen.push(`doc:${e.key}`), true)
+    window.addEventListener('keydown', (e) => seen.push(`win:${e.key}`), true)
+
+    const noop = press(editor, 'KanaMode')
+    expect(noop.defaultPrevented).toBe(true)
+    expect(seen).toEqual([])
+
+    const j = press(editor, 'j')
+    expect(j.defaultPrevented).toBe(false)
+    expect(seen).toEqual(['win:j', 'doc:j', 'el:j'])
+
+    // keyup goes the same way, so a held-key tracker never sees half a pair.
+    expect(press(editor, 'KanaMode', 'keyup').defaultPrevented).toBe(true)
+    editor.remove()
+  })
+
+  it('reads the list live and stands aside while the recorder is capturing', () => {
+    const list: string[] = []
+    uninstall = installIgnoredKeysGuard(() => list)
+    const target = document.createElement('div')
+    document.body.appendChild(target)
+    expect(press(target, 'KanaMode').defaultPrevented).toBe(false)
+    list.push('KanaMode')
+    expect(press(target, 'KanaMode').defaultPrevented).toBe(true)
+    setIgnoredKeysRecorderActive(true)
+    expect(press(target, 'KanaMode').defaultPrevented).toBe(false)
+    setIgnoredKeysRecorderActive(false)
+    expect(press(target, 'KanaMode').defaultPrevented).toBe(true)
+    target.remove()
+  })
+
+  it('installs once', () => {
+    const spy = vi.spyOn(window, 'addEventListener')
+    uninstall = installIgnoredKeysGuard(() => [])
+    const again = installIgnoredKeysGuard(() => [])
+    expect(again).toBe(uninstall)
+    expect(spy.mock.calls.filter((c) => c[0] === 'keydown').length).toBe(1)
+    spy.mockRestore()
+  })
+})
diff --git a/packages/app-core/src/lib/ignored-keys.ts b/packages/app-core/src/lib/ignored-keys.ts
new file mode 100644
index 00000000..55d7beff
--- /dev/null
+++ b/packages/app-core/src/lib/ignored-keys.ts
@@ -0,0 +1,94 @@
+/**
+ * Keys the app never sees (#732). Keyboard remappers with tap-hold layers
+ * (Kanata, QMK, ZMK) often emit a harmless extra key with every keystroke,
+ * on Linux typically the Katakana/Hiragana key, which Chromium reports as
+ * `KanaMode`. Editors that map only the keys they know ignore it; here every
+ * stray keydown reset a pending sequence (`jk` to leave insert mode, `dd`,
+ * a leader chord, hint mode). The user lists such keys once, and a single
+ * window-level capture guard swallows them before the editor, the panels
+ * or any shortcut handler can react, which is what "ignore" has to mean when
+ * the listeners live on a dozen elements.
+ */
+
+export const MAX_IGNORED_KEYS = 24
+export const MAX_IGNORED_KEY_LENGTH = 40
+
+/** Validate an untrusted list (config.toml, localStorage): trimmed, unique
+ *  ignoring case, capped. */
+export function normalizeIgnoredKeys(raw: unknown): string[] {
+  if (!Array.isArray(raw)) return []
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const entry of raw) {
+    if (typeof entry !== 'string') continue
+    const token = entry.trim().slice(0, MAX_IGNORED_KEY_LENGTH)
+    if (!token || seen.has(token.toLowerCase())) continue
+    seen.add(token.toLowerCase())
+    out.push(token)
+    if (out.length >= MAX_IGNORED_KEYS) break
+  }
+  return out
+}
+
+/**
+ * The name a user records for a key: its DOM `key` when it names the key
+ * (`KanaMode`, `F24`, `Lang1`), else its physical `code`, so a key the
+ * layout reports as Unidentified can still be listed by position.
+ */
+export function ignoredKeyTokenFromEvent(event: KeyboardEvent): string {
+  const key = (event.key ?? '').trim()
+  if (key && key !== 'Unidentified' && key !== 'Dead' && key !== 'Process') return key
+  return (event.code ?? '').trim()
+}
+
+/** True when the event's `key` or `code` is on the list (case-insensitive). */
+export function isIgnoredKeyEvent(
+  event: Pick<KeyboardEvent, 'key' | 'code'>,
+  ignored: readonly string[]
+): boolean {
+  if (ignored.length === 0) return false
+  const key = (event.key ?? '').toLowerCase()
+  const code = (event.code ?? '').toLowerCase()
+  for (const entry of ignored) {
+    const wanted = entry.toLowerCase()
+    if (wanted && (wanted === key || wanted === code)) return true
+  }
+  return false
+}
+
+// While the Settings recorder waits for the key to add, the guard stands
+// aside: the whole point of that moment is to see the key.
+let recorderActive = false
+
+export function setIgnoredKeysRecorderActive(active: boolean): void {
+  recorderActive = active
+}
+
+let installed: (() => void) | null = null
+
+/**
+ * Install the guard once on `window` in the capture phase, so it runs before
+ * any element listener (CodeMirror's, VimNav's, the panels'). Both keydown
+ * and keyup are swallowed: a handler that tracks a held key must not see
+ * half of the pair. Returns the uninstaller; a second call is a no-op.
+ */
+export function installIgnoredKeysGuard(getIgnored: () => readonly string[]): () => void {
+  if (installed) return installed
+  if (typeof window === 'undefined') return () => {}
+  const guard = (event: KeyboardEvent): void => {
+    if (recorderActive) return
+    if (!isIgnoredKeyEvent(event, getIgnored())) return
+    event.preventDefault()
+    event.stopImmediatePropagation()
+  }
+  window.addEventListener('keydown', guard, true)
+  window.addEventListener('keyup', guard, true)
+  window.addEventListener('keypress', guard, true)
+  installed = () => {
+    window.removeEventListener('keydown', guard, true)
+    window.removeEventListener('keyup', guard, true)
+    window.removeEventListener('keypress', guard, true)
+    installed = null
+  }
+  return installed
+}
diff --git a/packages/app-core/src/lib/keymaps.test.ts b/packages/app-core/src/lib/keymaps.test.ts
index e76d34f0..1979d403 100644
--- a/packages/app-core/src/lib/keymaps.test.ts
+++ b/packages/app-core/src/lib/keymaps.test.ts
@@ -1,10 +1,18 @@
 import { describe, expect, it } from 'vitest'
 import {
+  advanceSequence,
   eventMatchesUserOverride,
   findKeymapConflict,
   getDefaultKeymapBinding,
+  getKeymapBinding,
   getKeymapDefinition,
   getKeymapDefinitions,
+  getKeymapDisplay,
+  getSequenceTokens,
+  isKeymapUnbound,
+  labelWithShortcut,
+  matchesSequenceToken,
+  matchesShortcut,
   matchesShortcutBinding,
   normalizeKeymapOverrides,
   normalizeShortcutBinding,
@@ -387,3 +395,76 @@ describe('normalizeKeymapOverrides', () => {
     })
   })
 })
+
+describe('unbound keymaps (an override of "")', () => {
+  it('keeps an empty or blank override as an unbind instead of dropping it', () => {
+    expect(normalizeKeymapOverrides({ 'global.zoomIn': '' })).toEqual({ 'global.zoomIn': '' })
+    expect(normalizeKeymapOverrides({ 'global.zoomIn': '   ' })).toEqual({ 'global.zoomIn': '' })
+    expect(normalizeKeymapOverrides({ 'vim.leaderPrefix': '' })).toEqual({
+      'vim.leaderPrefix': ''
+    })
+  })
+
+  it('resolves an unbound action to no binding, not to its default', () => {
+    const overrides = { 'global.zoomIn': '' }
+    expect(getKeymapBinding(overrides, 'global.zoomIn')).toBe('')
+    expect(isKeymapUnbound(overrides, 'global.zoomIn')).toBe(true)
+    expect(isKeymapUnbound(overrides, 'global.zoomOut')).toBe(false)
+    expect(getKeymapBinding(overrides, 'global.zoomOut')).toBe(
+      getDefaultKeymapBinding('global.zoomOut')
+    )
+    expect(getSequenceTokens({ 'vim.leaderPrefix': '' }, 'vim.leaderPrefix')).toEqual([])
+    expect(getKeymapDisplay(overrides, 'global.zoomIn')).toBe('')
+  })
+
+  it('never matches a key event against an unbound shortcut or sequence', () => {
+    withPlatform('darwin', () => {
+      const overrides = { 'global.zoomIn': '', 'nav.moveDown': '' }
+      const zoomIn = fakeEvent({ key: '=', code: 'Equal', metaKey: true })
+      expect(matchesShortcut(zoomIn, {}, 'global.zoomIn')).toBe(true)
+      expect(matchesShortcut(zoomIn, overrides, 'global.zoomIn')).toBe(false)
+      const j = fakeEvent({ key: 'j', code: 'KeyJ' })
+      expect(matchesSequenceToken(j, {}, 'nav.moveDown')).toBe(true)
+      expect(matchesSequenceToken(j, overrides, 'nav.moveDown')).toBe(false)
+      // A keydown with no key at all must not "match" the empty binding either.
+      expect(matchesShortcutBinding(fakeEvent({ key: '', code: '' }), '')).toBe(false)
+    })
+  })
+
+  it('does not advance a sequence for an unbound binding', () => {
+    const pending = { current: 0 }
+    const timer: { current?: ReturnType<typeof setTimeout> } = {}
+    let matched = 0
+    const consumed = advanceSequence(
+      fakeEvent({ key: 'g', code: 'KeyG' }),
+      '',
+      pending,
+      timer,
+      () => {
+        matched += 1
+      },
+      () => {}
+    )
+    expect(consumed).toBe(false)
+    expect(matched).toBe(0)
+    expect(pending.current).toBe(0)
+  })
+
+  it('takes an unbound action out of global-shortcut conflict checks both ways', () => {
+    expect(findKeymapConflict({ 'global.zoomIn': '' }, 'global.zoomIn', '')).toBeNull()
+    // Zoom out may take the key that zoom in used to hold.
+    expect(findKeymapConflict({ 'global.zoomIn': '' }, 'global.zoomOut', 'Mod+=')).toBeNull()
+    expect(findKeymapConflict({}, 'global.zoomOut', 'Mod+=')?.id).toBe('global.zoomIn')
+    withPlatform('darwin', () => {
+      const zoomIn = fakeEvent({ key: '=', code: 'Equal', metaKey: true })
+      expect(eventMatchesUserOverride(zoomIn, { 'global.zoomIn': '' }, 'global.zoomOut')).toBe(
+        false
+      )
+    })
+  })
+
+  it('labels a tooltip with the key only while there is one', () => {
+    expect(labelWithShortcut('Go back', '⌃O')).toBe('Go back (⌃O)')
+    expect(labelWithShortcut('Go back', '')).toBe('Go back')
+  })
+})
diff --git a/packages/app-core/src/lib/keymaps.ts b/packages/app-core/src/lib/keymaps.ts
index 7822e949..d1e9ce4d 100644
--- a/packages/app-core/src/lib/keymaps.ts
+++ b/packages/app-core/src/lib/keymaps.ts
@@ -117,6 +117,7 @@ export type KeymapId =
   | "nav.unarchive"
   | "tasks.moveTaskUp"
   | "tasks.moveTaskDown"
+  | "tasks.savedFilters"
   | "editor.moveLineUp"
   | "editor.moveLineDown"
   | "editor.hopMarkerForward"
@@ -128,6 +129,33 @@ export type KeymapId =
 
 export type KeymapOverrides = Partial<Record<KeymapId, string>>;
 
+/**
+ * The stored form of "this action has no key". An override equal to the empty
+ * string means the user removed the binding on purpose: nothing fires the
+ * action until it is rebound or reset, the which-key hints and the manual
+ * stop advertising it, and it never collides with anything. It is distinct
+ * from a missing override (the default applies) and from a recording that
+ * has not captured a key yet. TOML has no null, so config.toml carries it
+ * as `"action.id" = ""`.
+ */
+export const UNBOUND_BINDING = "";
+
+/** What the UI calls an unbound action wherever a key would otherwise show. */
+export const UNBOUND_LABEL = "Unbound";
+
+export function isUnboundBinding(
+  binding: string | null | undefined,
+): binding is typeof UNBOUND_BINDING {
+  return binding === UNBOUND_BINDING;
+}
+
+export function isKeymapUnbound(
+  overrides: KeymapOverrides | null | undefined,
+  id: KeymapId,
+): boolean {
+  return isUnboundBinding(overrides?.[id]);
+}
+
 export interface KeymapDefinition {
   id: KeymapId;
   kind: KeymapKind;
@@ -1160,6 +1188,17 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [
     defaultBinding: "J",
     maxTokens: 1,
   },
+  {
+    id: "tasks.savedFilters",
+    kind: "sequence",
+    scope: "views",
+    group: "view-actions",
+    title: "Pick a saved Tasks filter",
+    description:
+      "Open the picker of saved Tasks filters and apply one (Tasks view, Vim mode). Save the current filter with :savefilter <name>.",
+    defaultBinding: "F",
+    maxTokens: 1,
+  },
   {
     id: "editor.hopMarkerForward",
     kind: "shortcut",
@@ -1333,7 +1372,9 @@ export function getKeymapBinding(
   id: KeymapId,
 ): string {
   const override = overrides?.[id];
-  return override || getDefaultKeymapBinding(id);
+  // A string override wins even when it is empty: that is an unbound action,
+  // not a missing override, and must not fall back to the default.
+  return typeof override === "string" ? override : getDefaultKeymapBinding(id);
 }
 
 export function getSequenceTokens(
@@ -1633,6 +1674,12 @@ export function normalizeKeymapOverrides(input: unknown): KeymapOverrides {
   for (const definition of KEYMAP_DEFINITIONS) {
     const raw = (input as Record<string, unknown>)[definition.id];
     if (typeof raw !== "string") continue;
+    // An empty (or blank) value is a deliberate unbind and survives as such;
+    // it is not a broken binding to be dropped in favor of the default.
+    if (raw.trim() === UNBOUND_BINDING) {
+      overrides[definition.id] = UNBOUND_BINDING;
+      continue;
+    }
     const normalized = normalizeKeymapBinding(definition.id, raw);
     // The platform's default, not the cross-platform one: a definition with a
     // `defaultBindingMac` has two defaults, and comparing against the wrong one
@@ -1709,6 +1756,7 @@ export function matchesShortcutBinding(
   event: KeyboardEvent,
   binding: string,
 ): boolean {
+  if (isUnboundBinding(binding)) return false;
   const normalized = shortcutBindingFromEvent(event);
   if (!!normalized && normalized === binding) return true;
   // Layouts with shifted digits (French AZERTY, Czech) type punctuation on
@@ -1749,6 +1797,7 @@ export function eventMatchesUserOverride(
   if (!overrides) return false;
   for (const [id, binding] of Object.entries(overrides)) {
     if (id === excludeId || typeof binding !== "string") continue;
+    if (isUnboundBinding(binding)) continue;
     const definition = KEYMAP_INDEX.get(id as KeymapId);
     if (!definition || definition.kind !== "shortcut") continue;
     if (definition.scope !== "app") continue;
@@ -1803,6 +1852,9 @@ export function formatKeymapBinding(binding: string, kind: KeymapKind): string {
     .join(" ");
 }
 
+/** The binding as the UI shows it, or the empty string for an unbound
+ *  action so a caller can leave the key column, chip or tooltip out
+ *  entirely. Surfaces that want a word instead use `UNBOUND_LABEL`. */
 export function getKeymapDisplay(
   overrides: KeymapOverrides | null | undefined,
   id: KeymapId,
@@ -1811,6 +1863,12 @@ export function getKeymapDisplay(
   return formatKeymapBinding(getKeymapBinding(overrides, id), definition.kind);
 }
 
+/** `label (display)` while the action has a key, the bare label once it is
+ *  unbound: a tooltip must not read "Go back ()". */
+export function labelWithShortcut(label: string, display: string): string {
+  return display ? `${label} (${display})` : label;
+}
+
 export function describeCurrentBinding(
   overrides: KeymapOverrides | null | undefined,
   id: KeymapId,
diff --git a/packages/app-core/src/lib/markdown.test.ts b/packages/app-core/src/lib/markdown.test.ts
index 32a36eff..4a4eb12a 100644
--- a/packages/app-core/src/lib/markdown.test.ts
+++ b/packages/app-core/src/lib/markdown.test.ts
@@ -535,3 +535,55 @@ describe('callout titles keep their inline markup (#549)', () => {
     expect(renderMarkdown('> [!note]x is not a marker')).not.toContain('callout')
   })
 })
+
+// A display block inside an Obsidian-style callout used to lose the reading
+// view entirely: the fence normalizer re-scanned the closing fence of the block
+// BEFORE the callout as an opener, took the callout's `> $$` for content
+// hugging a fence, and rewrote the note with a bare `$$` outside the quote
+// that swallowed everything after it (#748).
+describe('display math inside callouts (#748)', () => {
+  afterEach(() => setMarkdownMathRenderer('katex'))
+
+  it('renders a $$ block inside a callout, after a block outside it', () => {
+    const html = renderMarkdown(
+      ['$$', 'a', '$$', '', '> [!note]', '> $$', '> x_1 = 2', '> $$', '', 'After.'].join('\n')
+    )
+    expect(html.match(/katex-display/g)?.length).toBe(2)
+    expect(html).toMatch(/<div class="callout"[^>]*>[\s\S]*katex-display[\s\S]*<\/div>/)
+    expect(html).not.toContain('&gt;')
+    expect(html).toMatch(/<p[^>]*>After\.<\/p>/)
+  })
+
+  it('hands Typst the formula without the quote markers', () => {
+    setMarkdownMathRenderer('typst')
+    const html = renderMarkdown(['> [!tip]', '> $$', '> x_1 = frac(det W_1, det A)', '> $$'].join('\n'))
+    expect(html).toContain('data-typst-source="x_1 = frac(det W_1, det A)"')
+    expect(html).not.toContain('zen-typst-error')
+  })
+
+  it('expands a one-line $$x^2$$ inside a callout like it does outside', () => {
+    const html = renderMarkdown('> [!note]\n> $$x^2$$\n\nAfter.')
+    expect(html.match(/katex-display/g)?.length).toBe(1)
+    expect(html).toMatch(/<div class="callout"[^>]*>[\s\S]*katex-display[\s\S]*<\/div>/)
+    expect(html).toMatch(/<p[^>]*>After\.<\/p>/)
+  })
+
+  it('never pairs a block with a later line that merely ends in $$', () => {
+    const html = renderMarkdown(['$$', 'a', '$$', '', 'The fence is $$', '', 'After.'].join('\n'))
+    expect(html.match(/katex-display/g)?.length).toBe(1)
+    expect(html).toContain('The fence is $$')
+    expect(html).toMatch(/<p[^>]*>After\.<\/p>/)
+  })
+
+  it('keeps the quote markers out of a demoted $…$ span inside a callout', () => {
+    // Bare `$` lines are not a display block in ZenNotes; the currency guard
+    // demotes the span to text in both views. Inside a callout that text used
+    // to carry the `> ` of every continuation line.
+    const outside = renderMarkdown(['$', 'x_1 = 2', '$'].join('\n'))
+    const inside = renderMarkdown(['> [!note]', '> $', '> x_1 = 2', '> $'].join('\n'))
+    expect(outside).not.toContain('katex')
+    expect(inside).not.toContain('katex')
+    expect(inside).not.toContain('&gt;')
+    expect(inside).toMatch(/<div class="callout"[^>]*>[\s\S]*\$\nx_1 = 2\n\$[\s\S]*<\/div>/)
+  })
+})
diff --git a/packages/app-core/src/lib/markdown.ts b/packages/app-core/src/lib/markdown.ts
index 6df3f2a9..432dd9cf 100644
--- a/packages/app-core/src/lib/markdown.ts
+++ b/packages/app-core/src/lib/markdown.ts
@@ -898,7 +898,11 @@ function remarkCurrencyGuard() {
       const start = node.position?.start?.offset
       const end = node.position?.end?.offset
       if (start == null || end == null) return
-      const token = source.slice(start, end)
+      // The raw source between the node's offsets. Inside a blockquote the
+      // continuation lines still carry their `> ` markers here, which belong
+      // to the quote, not the formula: a span demoted inside a callout used
+      // to come back as `$ > x $` (#748).
+      const token = dropQuoteMarkersAfterFirstLine(source.slice(start, end))
       if (STRICT_INLINE_MATH_RE.test(token)) return
       // `$$…$$` in a table cell: genuine display math, not currency. The
       // editor's table widget renders it in display mode, so swap the node's
@@ -1105,6 +1109,28 @@ function escapeTableMathPipes(src: string): string {
   return changed ? out.join('\n') : src
 }
 
+/** The blockquote markers that open a line (`> `, `> > `) and what follows
+ *  them. A fence inside a callout carries the markers on every line, so the
+ *  normalizer looks past them and puts them back on whatever it emits. */
+const QUOTE_PREFIX_RE = /^((?:[ \t]{0,3}>[ \t]?)+)/
+
+function splitQuotePrefix(line: string): { prefix: string; depth: number; content: string } {
+  const match = line.match(QUOTE_PREFIX_RE)
+  if (!match) return { prefix: '', depth: 0, content: line }
+  const prefix = match[1]
+  return { prefix, depth: (prefix.match(/>/g) ?? []).length, content: line.slice(prefix.length) }
+}
+
+/** A raw source slice that starts mid-line: its first line has no marker
+ *  (that sits before the slice), the following lines do when the slice lives
+ *  in a blockquote. A paragraph line cannot start with `>` anywhere else, so
+ *  stripping markers from the continuation lines never touches prose. */
+function dropQuoteMarkersAfterFirstLine(text: string): string {
+  if (!text.includes('\n')) return text
+  const [first, ...rest] = text.split('\n')
+  return [first, ...rest.map((line) => splitQuotePrefix(line).content)].join('\n')
+}
+
 /**
  * remark-math only closes a `$$` block on a line containing nothing but the
  * closing fence, while the editor's live preview (cm-math-render) also accepts
@@ -1114,6 +1140,11 @@ function escapeTableMathPipes(src: string): string {
  * parses exactly what the editor renders. Fenced code is left untouched, and
  * anything the editor itself rejects (mid-line `$$`, empty or unclosed blocks)
  * passes through unchanged — canonical notes come back byte-identical.
+ *
+ * Fences inside a blockquote count as fences (#748): the quote markers are
+ * looked past when a line is read and put back on every line written, and a
+ * block only closes at its own quote depth, so a fence in a callout can never
+ * be paired with one outside it.
  */
 function normalizeBlockMathFences(src: string, loose = false): string {
   if (!src.includes('$$')) return src
@@ -1124,7 +1155,8 @@ function normalizeBlockMathFences(src: string, loose = false): string {
   let i = 0
   while (i < lines.length) {
     const raw = lines[i]
-    const trimmed = raw.trim()
+    const { prefix, depth, content } = splitQuotePrefix(raw)
+    const trimmed = content.trim()
     if (codeFence) {
       out.push(raw)
       if (trimmed.startsWith(codeFence)) codeFence = null
@@ -1143,12 +1175,12 @@ function normalizeBlockMathFences(src: string, loose = false): string {
     let indent: string | null = null
     let rest = ''
     let proseBefore = ''
-    const strictOpen = raw.match(/^( {0,3})\$\$(?!\$)(.*)$/)
+    const strictOpen = content.match(/^( {0,3})\$\$(?!\$)(.*)$/)
     if (strictOpen) {
       indent = strictOpen[1]
       rest = strictOpen[2]
     } else if (loose) {
-      const looseOpen = raw.match(/^( {0,3})(.+?)\s*\$\$(?!\$)\s*$/)
+      const looseOpen = content.match(/^( {0,3})(.+?)\s*\$\$(?!\$)\s*$/)
       if (looseOpen && !looseOpen[2].includes('$$')) {
         indent = looseOpen[1]
         proseBefore = looseOpen[2]
@@ -1166,7 +1198,7 @@ function normalizeBlockMathFences(src: string, loose = false): string {
       if (restTrimmed.endsWith('$$') && restTrimmed.indexOf('$$') === restTrimmed.length - 2) {
         const inner = restTrimmed.slice(0, -2)
         if (inner.trim() !== '') {
-          out.push(`${indent}$$`, inner, `${indent}$$`)
+          out.push(`${prefix}${indent}$$`, `${prefix}${inner}`, `${prefix}${indent}$$`)
           changed = true
           i++
           continue
@@ -1183,8 +1215,11 @@ function normalizeBlockMathFences(src: string, loose = false): string {
     let closeHasContent = false
     let closeTrailing = ''
     for (let k = i + 1; k < lines.length; k++) {
-      const t = lines[k].trim()
+      const line = splitQuotePrefix(lines[k])
+      const t = line.content.trim()
       if (!t.includes('$$')) continue
+      // A fence at another quote depth belongs to another block, or to none.
+      if (line.depth !== depth) break
       if (t === '$$') {
         close = k
       } else if (t.endsWith('$$') && t.indexOf('$$') === t.length - 2) {
@@ -1201,22 +1236,35 @@ function normalizeBlockMathFences(src: string, loose = false): string {
       }
       break
     }
-    const alreadyCanonical =
-      restTrimmed === '' && !closeHasContent && proseBefore === '' && closeTrailing === ''
-    if (close === -1 || alreadyCanonical) {
-      // Unclosed, editor-rejected, or already canonical: leave untouched.
+    if (close === -1) {
+      // Unclosed or editor-rejected: leave the line untouched.
       out.push(raw)
       i++
       continue
     }
+    const alreadyCanonical =
+      restTrimmed === '' && !closeHasContent && proseBefore === '' && closeTrailing === ''
+    if (alreadyCanonical) {
+      // Already the fence-on-its-own-line form: copy the block through and
+      // move past its closing fence. Re-scanning that fence as an opener
+      // paired it with the next `$$` in the note, and a callout's `> $$`
+      // then read as content hugging a fence: the rewrite left a bare `$$`
+      // outside the quote, and that block swallowed everything after it.
+      for (let k = i; k <= close; k++) out.push(lines[k])
+      i = close + 1
+      continue
+    }
+    // An empty quote line (`>`) keeps a blockquote open where a blank line
+    // would end it; outside a quote the prefix is empty and this is a blank.
+    const blank = prefix.trimEnd()
     if (proseBefore !== '') {
       // Prose leading the open fence becomes its own paragraph.
-      out.push(`${indent}${proseBefore}`, '')
+      out.push(`${prefix}${indent}${proseBefore}`, blank)
       changed = true
     }
-    out.push(`${indent}$$`)
+    out.push(`${prefix}${indent}$$`)
     if (restTrimmed !== '') {
-      out.push(rest)
+      out.push(`${prefix}${rest}`)
       changed = true
     }
     for (let k = i + 1; k < close; k++) out.push(lines[k])
@@ -1225,13 +1273,13 @@ function normalizeBlockMathFences(src: string, loose = false): string {
       const rawClose = lines[close]
       const idx = rawClose.lastIndexOf('$$')
       const beforeDollar = rawClose.slice(0, idx)
-      if (beforeDollar.trim() !== '') out.push(beforeDollar)
-      out.push(`${indent}$$`, '', `${indent}${closeTrailing}`)
+      if (splitQuotePrefix(beforeDollar).content.trim() !== '') out.push(beforeDollar)
+      out.push(`${prefix}${indent}$$`, blank, `${prefix}${indent}${closeTrailing}`)
       changed = true
     } else if (closeHasContent) {
       const rawClose = lines[close]
       const idx = rawClose.lastIndexOf('$$')
-      out.push(rawClose.slice(0, idx), `${indent}$$`)
+      out.push(rawClose.slice(0, idx), `${prefix}${indent}$$`)
       changed = true
     } else {
       out.push(lines[close])
diff --git a/packages/app-core/src/lib/saved-task-filters.test.ts b/packages/app-core/src/lib/saved-task-filters.test.ts
new file mode 100644
index 00000000..422a9076
--- /dev/null
+++ b/packages/app-core/src/lib/saved-task-filters.test.ts
@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest'
+import {
+  MAX_SAVED_TASK_FILTERS,
+  findSavedTaskFilterName,
+  normalizeSavedTaskFilters,
+  renameSavedTaskFilter,
+  savedTaskFilterNameForQuery,
+  savedTaskFilterQuery,
+  withSavedTaskFilter,
+  withoutSavedTaskFilter
+} from './saved-task-filters'
+
+const filters = { 'Project alpha': '@project:alpha', Blocked: '@status:blocked', 'This week': 'due:' }
+
+describe('normalizeSavedTaskFilters', () => {
+  it('keeps string entries in their order and trims them', () => {
+    expect(
+      normalizeSavedTaskFilters({ ' Blocked ': ' @status:blocked ', Alpha: '@project:alpha' })
+    ).toEqual({ Blocked: '@status:blocked', Alpha: '@project:alpha' })
+    expect(Object.keys(normalizeSavedTaskFilters(filters))).toEqual([
+      'Project alpha',
+      'Blocked',
+      'This week'
+    ])
+  })
+
+  it('drops blanks, non-strings, duplicates by case, and anything that is not a table', () => {
+    expect(normalizeSavedTaskFilters(null)).toEqual({})
+    expect(normalizeSavedTaskFilters(['a'])).toEqual({})
+    expect(normalizeSavedTaskFilters('x')).toEqual({})
+    expect(
+      normalizeSavedTaskFilters({ '': 'q', a: '', b: 3, Blocked: 'one', blocked: 'two' })
+    ).toEqual({ Blocked: 'one' })
+  })
+
+  it('caps the number of entries', () => {
+    const many: Record<string, string> = {}
+    for (let i = 0; i < MAX_SAVED_TASK_FILTERS + 5; i += 1) many[`f${i}`] = `q${i}`
+    expect(Object.keys(normalizeSavedTaskFilters(many))).toHaveLength(MAX_SAVED_TASK_FILTERS)
+  })
+})
+
+describe('lookups', () => {
+  it('finds a name and its query regardless of case', () => {
+    expect(findSavedTaskFilterName(filters, 'blocked')).toBe('Blocked')
+    expect(findSavedTaskFilterName(filters, ' PROJECT ALPHA ')).toBe('Project alpha')
+    expect(findSavedTaskFilterName(filters, 'nope')).toBeNull()
+    expect(findSavedTaskFilterName(filters, '')).toBeNull()
+    expect(savedTaskFilterQuery(filters, 'BLOCKED')).toBe('@status:blocked')
+    expect(savedTaskFilterQuery(filters, 'nope')).toBeNull()
+  })
+
+  it('maps the current query back to the chip it came from', () => {
+    expect(savedTaskFilterNameForQuery(filters, '@status:blocked')).toBe('Blocked')
+    expect(savedTaskFilterNameForQuery(filters, ' @STATUS:blocked ')).toBe('Blocked')
+    expect(savedTaskFilterNameForQuery(filters, '@status:block')).toBeNull()
+    expect(savedTaskFilterNameForQuery(filters, '')).toBeNull()
+  })
+})
+
+describe('edits keep the display order', () => {
+  it('adds a new filter at the end', () => {
+    const next = withSavedTaskFilter(filters, 'Urgent', '!high')
+    expect(Object.keys(next)).toEqual(['Project alpha', 'Blocked', 'This week', 'Urgent'])
+    expect(next.Urgent).toBe('!high')
+    expect(filters).not.toHaveProperty('Urgent')
+  })
+
+  it('overwrites an existing name in place, adopting the new spelling', () => {
+    const next = withSavedTaskFilter(filters, 'BLOCKED', '@status:waiting')
+    expect(Object.keys(next)).toEqual(['Project alpha', 'BLOCKED', 'This week'])
+    expect(next.BLOCKED).toBe('@status:waiting')
+  })
+
+  it('refuses blanks and a full list', () => {
+    expect(withSavedTaskFilter(filters, ' ', 'q')).toBe(filters)
+    expect(withSavedTaskFilter(filters, 'x', ' ')).toBe(filters)
+    const full: Record<string, string> = {}
+    for (let i = 0; i < MAX_SAVED_TASK_FILTERS; i += 1) full[`f${i}`] = `q${i}`
+    expect(withSavedTaskFilter(full, 'one more', 'q')).toBe(full)
+    expect(Object.keys(withSavedTaskFilter(full, 'F3', 'changed'))).toHaveLength(MAX_SAVED_TASK_FILTERS)
+  })
+
+  it('removes by name in any case and ignores unknown names', () => {
+    expect(Object.keys(withoutSavedTaskFilter(filters, 'blocked'))).toEqual(['Project alpha', 'This week'])
+    expect(withoutSavedTaskFilter(filters, 'nope')).toBe(filters)
+  })
+
+  it('renames in place and refuses a taken or blank name', () => {
+    const next = renameSavedTaskFilter(filters, 'blocked', 'Waiting on others')
+    expect(Object.keys(next)).toEqual(['Project alpha', 'Waiting on others', 'This week'])
+    expect(next['Waiting on others']).toBe('@status:blocked')
+    expect(renameSavedTaskFilter(filters, 'Blocked', 'this WEEK')).toBe(filters)
+    expect(renameSavedTaskFilter(filters, 'Blocked', '  ')).toBe(filters)
+    expect(renameSavedTaskFilter(filters, 'nope', 'x')).toBe(filters)
+    // Re-casing a name is a rename onto itself.
+    expect(Object.keys(renameSavedTaskFilter(filters, 'Blocked', 'BLOCKED'))).toEqual([
+      'Project alpha',
+      'BLOCKED',
+      'This week'
+    ])
+  })
+})
diff --git a/packages/app-core/src/lib/saved-task-filters.ts b/packages/app-core/src/lib/saved-task-filters.ts
new file mode 100644
index 00000000..874ff145
--- /dev/null
+++ b/packages/app-core/src/lib/saved-task-filters.ts
@@ -0,0 +1,124 @@
+/**
+ * Saved Tasks filters (#731): a name the user picks, and the filter query it
+ * stands for. The map lives in the portable prefs and mirrors to config.toml
+ * as the `[saved_filters]` table, so it is hand-editable and travels with
+ * dotfiles. Names are matched case-insensitively wherever a user types one
+ * (`:filter <name>`, the picker), while the stored spelling is what the
+ * chips show. Insertion order is the display order, and the helpers below
+ * keep it through a rename or an overwrite so a chip does not jump to the
+ * end when its query is updated.
+ */
+
+export type SavedTaskFilters = Record<string, string>
+
+export const MAX_SAVED_TASK_FILTERS = 50
+export const MAX_SAVED_TASK_FILTER_NAME_LENGTH = 60
+export const MAX_SAVED_TASK_FILTER_QUERY_LENGTH = 200
+
+/** Validate an untrusted value (config.toml, localStorage) into a clean map. */
+export function normalizeSavedTaskFilters(value: unknown): SavedTaskFilters {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const normalized: SavedTaskFilters = {}
+  for (const [rawName, rawQuery] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof rawQuery !== 'string') continue
+    const name = rawName.trim()
+    const query = rawQuery.trim()
+    if (!name || !query) continue
+    if (name.length > MAX_SAVED_TASK_FILTER_NAME_LENGTH) continue
+    if (findSavedTaskFilterName(normalized, name)) continue
+    normalized[name] = query.slice(0, MAX_SAVED_TASK_FILTER_QUERY_LENGTH)
+    if (Object.keys(normalized).length >= MAX_SAVED_TASK_FILTERS) break
+  }
+  return normalized
+}
+
+/** The stored spelling of `name`, matched case-insensitively, or null. */
+export function findSavedTaskFilterName(filters: SavedTaskFilters, name: string): string | null {
+  const wanted = name.trim().toLowerCase()
+  if (!wanted) return null
+  for (const stored of Object.keys(filters)) {
+    if (stored.toLowerCase() === wanted) return stored
+  }
+  return null
+}
+
+/** The query saved under `name` (case-insensitive), or null. */
+export function savedTaskFilterQuery(filters: SavedTaskFilters, name: string): string | null {
+  const stored = findSavedTaskFilterName(filters, name)
+  return stored === null ? null : filters[stored]
+}
+
+/**
+ * The saved filter whose query is `query` (trimmed, case-insensitive, since
+ * matching ignores case), or null. Drives the highlighted chip.
+ */
+export function savedTaskFilterNameForQuery(
+  filters: SavedTaskFilters,
+  query: string
+): string | null {
+  const wanted = query.trim().toLowerCase()
+  if (!wanted) return null
+  for (const [name, saved] of Object.entries(filters)) {
+    if (saved.trim().toLowerCase() === wanted) return name
+  }
+  return null
+}
+
+/**
+ * `filters` with `name` set to `query`. A name already present (in any
+ * casing) keeps its position and takes the new spelling and query; a new
+ * name goes last.
+ */
+export function withSavedTaskFilter(
+  filters: SavedTaskFilters,
+  name: string,
+  query: string
+): SavedTaskFilters {
+  const cleanName = name.trim().slice(0, MAX_SAVED_TASK_FILTER_NAME_LENGTH)
+  const cleanQuery = query.trim().slice(0, MAX_SAVED_TASK_FILTER_QUERY_LENGTH)
+  if (!cleanName || !cleanQuery) return filters
+  const existing = findSavedTaskFilterName(filters, cleanName)
+  const next: SavedTaskFilters = {}
+  for (const [stored, saved] of Object.entries(filters)) {
+    if (stored === existing) next[cleanName] = cleanQuery
+    else next[stored] = saved
+  }
+  if (existing === null) {
+    if (Object.keys(next).length >= MAX_SAVED_TASK_FILTERS) return filters
+    next[cleanName] = cleanQuery
+  }
+  return next
+}
+
+/** `filters` without `name` (case-insensitive); unchanged when absent. */
+export function withoutSavedTaskFilter(filters: SavedTaskFilters, name: string): SavedTaskFilters {
+  const stored = findSavedTaskFilterName(filters, name)
+  if (stored === null) return filters
+  const next: SavedTaskFilters = {}
+  for (const [key, saved] of Object.entries(filters)) {
+    if (key !== stored) next[key] = saved
+  }
+  return next
+}
+
+/**
+ * `filters` with `from` renamed to `to`, keeping its position and query.
+ * Unchanged when `from` is unknown, `to` is blank, or `to` already names a
+ * different filter.
+ */
+export function renameSavedTaskFilter(
+  filters: SavedTaskFilters,
+  from: string,
+  to: string
+): SavedTaskFilters {
+  const stored = findSavedTaskFilterName(filters, from)
+  const cleanTo = to.trim().slice(0, MAX_SAVED_TASK_FILTER_NAME_LENGTH)
+  if (stored === null || !cleanTo) return filters
+  const taken = findSavedTaskFilterName(filters, cleanTo)
+  if (taken !== null && taken !== stored) return filters
+  const next: SavedTaskFilters = {}
+  for (const [key, saved] of Object.entries(filters)) {
+    next[key === stored ? cleanTo : key] = saved
+  }
+  return next
+}
diff --git a/packages/app-core/src/lib/settings-navigation.ts b/packages/app-core/src/lib/settings-navigation.ts
index 5a402b2c..99c9cb21 100644
--- a/packages/app-core/src/lib/settings-navigation.ts
+++ b/packages/app-core/src/lib/settings-navigation.ts
@@ -1,4 +1,7 @@
-export type SettingsNavigationTarget = "cloud";
+/** Settings pages other surfaces can open directly: the Cloud page from the
+ *  status bar, the Keymaps page from `:unbind` when the action id is missing
+ *  or unknown. */
+export type SettingsNavigationTarget = "cloud" | "keymaps";
 
 let pendingSettingsTarget: SettingsNavigationTarget | null = null;
 
diff --git a/packages/app-core/src/lib/typst-math-render.test.ts b/packages/app-core/src/lib/typst-math-render.test.ts
new file mode 100644
index 00000000..57001e4b
--- /dev/null
+++ b/packages/app-core/src/lib/typst-math-render.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { styleSvg } from './typst-math-render'
+
+// Typst hands back an SVG measured in points at the 11pt text size every
+// formula is compiled at, with its paint spelled out as black. The wrapper
+// sizes it in em at KaTeX's 1.21 factor, so the two engines agree on how big a
+// formula is next to prose (a plain 1em made Typst a fifth smaller), and turns
+// every black fill and stroke into currentColor so it follows the theme (#746).
+describe('styleSvg', () => {
+  const svg = (w: number, h: number, body = '<path fill="#000000" d="M0 0"/>'): string =>
+    `<svg class="typst-doc" viewBox="0 0 ${w} ${h}" width="${w}pt" height="${h}pt" xmlns="http://www.w3.org/2000/svg">${body}</svg>`
+
+  it('sizes the formula the way KaTeX sizes Computer Modern', () => {
+    // 11pt of Typst text is one em of the compiled document, drawn at 1.21em.
+    const inline = styleSvg(svg(11, 11), false)
+    expect(inline).toContain('width: 1.2100em; height: 1.2100em;')
+    expect(inline).toContain('display: inline-block; vertical-align: middle;')
+    const block = styleSvg(svg(22, 8), true)
+    expect(block).toContain('width: 2.4200em; height: 0.8800em;')
+    expect(block).toContain('display: block; margin: 0 auto;')
+  })
+
+  it('drops the intrinsic pt size', () => {
+    const out = styleSvg(svg(11, 11), false)
+    expect(out).not.toMatch(/width="11pt"|height="11pt"/)
+  })
+
+  it('recolors black glyph fills and black shape strokes to currentColor', () => {
+    const out = styleSvg(
+      svg(
+        11,
+        11,
+        '<g fill="#000000"><path d="M0 0"/></g>' +
+          '<path class="typst-shape" fill="none" stroke="#000" d="M0 1H9"/>' +
+          '<path fill="#000" stroke="rgb(0, 0, 0)" d="M1 1"/>' +
+          '<path fill="#ff0000" d="M2 2"/>'
+      ),
+      true
+    )
+    expect(out).toContain('<g fill="currentColor">')
+    expect(out).toContain('fill="none" stroke="currentColor"')
+    expect(out).toContain('fill="currentColor" stroke="currentColor"')
+    expect(out).toContain('fill="#ff0000"')
+    expect(out).not.toMatch(/(fill|stroke)="(#000000|#000|rgb\(0, 0, 0\))"/)
+  })
+})
diff --git a/packages/app-core/src/lib/typst-math-render.ts b/packages/app-core/src/lib/typst-math-render.ts
index 6d63f64d..c326e877 100644
--- a/packages/app-core/src/lib/typst-math-render.ts
+++ b/packages/app-core/src/lib/typst-math-render.ts
@@ -42,9 +42,18 @@ const FONT_URLS = [newCMRegularUrl, newCMBoldUrl, newCMItalicUrl, newCMMathUrl]
 
 /** Text size we compile every formula at; SVG dimensions come back in points,
  *  and are converted to `em` relative to this so the rendered math scales with
- *  the reader's font size (the pt→px factor cancels: `heightEm = ptHeight / 11`). */
+ *  the reader's font size (the pt→px factor cancels: `heightEm = ptHeight / 11`,
+ *  times the KaTeX factor below). */
 const BASE_TEXT_PT = 11
 
+/** KaTeX draws Computer Modern at 1.21em of the surrounding text (its own
+ *  stylesheet: `.katex { font-size: 1.21em }`), because the family sits small
+ *  on its em square and a plain 1em reads undersized next to prose. New
+ *  Computer Modern shares those metrics, so a Typst formula sized at 1em came
+ *  out a fifth smaller than KaTeX's rendering of the same source (#746). Size
+ *  it the way KaTeX does, so switching engines does not change the size. */
+const KATEX_EM_SCALE = 1.21
+
 export type TypstRenderResult =
   | { ok: true; svg: string }
   | { ok: false; error: string }
@@ -119,21 +128,26 @@ function buildDocument(source: string, display: boolean, preamble: string): stri
   ].join('\n')
 }
 
+/** Every spelling of black Typst's SVG export uses, on a fill or a stroke.
+ *  Glyphs arrive as `fill="#000000"`; the rules a formula draws as shapes (a
+ *  square root's bar, a fraction line) arrive as `stroke="#000"`, and a
+ *  recolor that only knew fills left those black on a dark theme (#746). */
+const BLACK_PAINT_RE = /\b(fill|stroke)="(?:#000000|#000|black|rgb\(0,\s*0,\s*0\))"/g
+
 /**
- * Post-process Typst's SVG so it drops into a note: recolor black glyph fills
- * to `currentColor` (theme-aware, no re-render on theme switch) and swap the
- * intrinsic pt width/height for `em` sizes that track the surrounding font.
+ * Post-process Typst's SVG so it drops into a note: recolor black paint, fills
+ * and strokes alike, to `currentColor` (theme-aware, no re-render on theme
+ * switch) and swap the intrinsic pt width/height for `em` sizes that track the
+ * surrounding font.
  */
-function styleSvg(rawSvg: string, display: boolean): string {
-  let svg = rawSvg
-    .replace(/fill="#000000"/g, 'fill="currentColor"')
-    .replace(/fill="#000"/g, 'fill="currentColor"')
+export function styleSvg(rawSvg: string, display: boolean): string {
+  let svg = rawSvg.replace(BLACK_PAINT_RE, '$1="currentColor"')
 
   const viewBox = svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/)
   const widthPt = viewBox ? Number.parseFloat(viewBox[1]) : 0
   const heightPt = viewBox ? Number.parseFloat(viewBox[2]) : 0
-  const widthEm = (widthPt / BASE_TEXT_PT).toFixed(4)
-  const heightEm = (heightPt / BASE_TEXT_PT).toFixed(4)
+  const widthEm = ((widthPt * KATEX_EM_SCALE) / BASE_TEXT_PT).toFixed(4)
+  const heightEm = ((heightPt * KATEX_EM_SCALE) / BASE_TEXT_PT).toFixed(4)
 
   // The app's CSS reset makes every `svg` display:block; override that so inline
   // math flows in the text (centered on the line, since the SVG carries no
diff --git a/packages/app-core/src/lib/vim-half-page-keymap.test.ts b/packages/app-core/src/lib/vim-half-page-keymap.test.ts
index e3235302..fe59a21f 100644
--- a/packages/app-core/src/lib/vim-half-page-keymap.test.ts
+++ b/packages/app-core/src/lib/vim-half-page-keymap.test.ts
@@ -6,7 +6,7 @@ import { EditorState } from '@codemirror/state'
 import { EditorView, keymap } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
 import type { KeymapOverrides } from './keymaps'
-import { vimHalfPageKeymap } from './vim-half-page-keymap'
+import { keyBindingsFor, vimHalfPageKeymap } from './vim-half-page-keymap'
 
 describe('vimHalfPageKeymap', () => {
   const views: EditorView[] = []
@@ -82,4 +82,14 @@ describe('vimHalfPageKeymap', () => {
     expect(calls).toBe(0)
     expect(vimHalfPageKeymap(false, {})).toEqual([])
   })
+
+  it('binds nothing for an unbound action', () => {
+    // An override of "" is a deliberate unbind: the keymap must not carry an
+    // empty key name that CodeMirror could match against a keyless keydown.
+    expect(vimHalfPageKeymap(true, { 'nav.halfPageDown': '' }).map((b) => b.key)).toEqual([
+      'Ctrl-u'
+    ])
+    expect(keyBindingsFor('', () => true)).toEqual([])
+    expect(keyBindingsFor('Mod+L', () => true).map((b) => b.key)).toEqual(['Mod-l'])
+  })
 })
diff --git a/packages/app-core/src/lib/vim-half-page-keymap.ts b/packages/app-core/src/lib/vim-half-page-keymap.ts
index 51dfc32b..be2606c3 100644
--- a/packages/app-core/src/lib/vim-half-page-keymap.ts
+++ b/packages/app-core/src/lib/vim-half-page-keymap.ts
@@ -1,6 +1,6 @@
-import type { KeyBinding } from '@codemirror/view'
+import type { Command, KeyBinding } from '@codemirror/view'
 import { Vim, getCM } from '@replit/codemirror-vim'
-import { getKeymapBinding, type KeymapOverrides } from './keymaps'
+import { getKeymapBinding, isUnboundBinding, type KeymapOverrides } from './keymaps'
 import { toVimSequence } from './vim-key-sequence'
 
 export function toCodeMirrorKey(binding: string): string {
@@ -11,22 +11,29 @@ export function toCodeMirrorKey(binding: string): string {
   return modifiers ? `${modifiers}-${key}` : key
 }
 
+/** The CodeMirror keymap entry for a keymap binding, or none at all for an
+ *  unbound action. CodeMirror files an empty key name without complaint and
+ *  would run the command on any keydown whose `key` is empty, so an unbound
+ *  action never reaches the keymap in the first place. */
+export function keyBindingsFor(binding: string, run: Command): KeyBinding[] {
+  if (isUnboundBinding(binding)) return []
+  return [{ key: toCodeMirrorKey(binding), run }]
+}
+
 export function vimHalfPageKeymap(
   vimMode: boolean,
   overrides: KeymapOverrides
 ): KeyBinding[] {
   if (!vimMode) return []
-  return (['nav.halfPageDown', 'nav.halfPageUp'] as const).map((keymapId) => {
+  return (['nav.halfPageDown', 'nav.halfPageUp'] as const).flatMap((keymapId) => {
     const binding = getKeymapBinding(overrides, keymapId)
     const sequence = toVimSequence(binding)
-    return {
-      key: toCodeMirrorKey(binding),
-      run: (view): boolean => {
-        const cm = getCM(view)
-        const vim = cm?.state.vim
-        if (!cm || !vim || vim.insertMode || vim.visualMode || !sequence) return false
-        return !!Vim.handleKey(cm, sequence, 'user')
-      }
-    }
+    if (!sequence) return []
+    return keyBindingsFor(binding, (view): boolean => {
+      const cm = getCM(view)
+      const vim = cm?.state.vim
+      if (!cm || !vim || vim.insertMode || vim.visualMode) return false
+      return !!Vim.handleKey(cm, sequence, 'user')
+    })
   })
 }
diff --git a/packages/app-core/src/store.test.ts b/packages/app-core/src/store.test.ts
index 6235cd86..56b21161 100644
--- a/packages/app-core/src/store.test.ts
+++ b/packages/app-core/src/store.test.ts
@@ -2253,3 +2253,117 @@ describe('renaming the open note while the watcher reports the move (#713)', ()
     expect(JSON.stringify(useStore.getState().paneLayout)).not.toContain(OLD)
   })
 })
+
+describe('custom templates on the change feed (#723)', () => {
+  it('re-lists templates on a templates-scope event without touching the note tree', async () => {
+    const listTemplates = vi
+      .fn()
+      .mockResolvedValueOnce([])
+      .mockResolvedValueOnce([
+        { sourcePath: '.zennotes/templates/adr.md', raw: '---\nname: Decision Record\n---\n# {{title}}\n' }
+      ])
+    const listNotes = vi.fn().mockResolvedValue([makeNote('- [ ] old task')])
+    installZen({ listTemplates, listNotes })
+
+    const { useStore } = await loadStore()
+    await useStore.getState().loadCustomTemplates()
+    expect(useStore.getState().customTemplates).toEqual([])
+    const notesListedBefore = listNotes.mock.calls.length
+
+    await useStore.getState().applyChange({
+      kind: 'change',
+      path: '.zennotes/templates/adr.md',
+      folder: 'inbox',
+      scope: 'templates'
+    })
+
+    expect(listTemplates).toHaveBeenCalledTimes(2)
+    expect(useStore.getState().customTemplates.map((t) => [t.id, t.name])).toEqual([
+      ['custom:adr', 'Decision Record']
+    ])
+    expect(listNotes.mock.calls.length).toBe(notesListedBefore)
+  })
+
+  it('re-lists templates after a change-feed gap', async () => {
+    const listTemplates = vi.fn().mockResolvedValue([
+      { sourcePath: '.zennotes/templates/weekly.md', raw: '---\nname: Weekly\n---\n' }
+    ])
+    installZen({ listTemplates })
+
+    const { useStore } = await loadStore()
+    await useStore.getState().applyChange({ kind: 'change', path: '', folder: 'inbox', scope: 'resync' })
+
+    expect(listTemplates).toHaveBeenCalled()
+    expect(useStore.getState().customTemplates.map((t) => t.name)).toEqual(['Weekly'])
+  })
+})
+
+describe('remote workspace capabilities after boot (#723)', () => {
+  it('re-reads the workspace info once getCurrentVault has connected the server', async () => {
+    const base = {
+      mode: 'remote',
+      baseUrl: 'http://127.0.0.1:7878',
+      authConfigured: false,
+      profileId: null,
+      bootError: null
+    }
+    // The first read happens before the main process connects; capabilities
+    // are unknown then. Only the second read, after the connection, has them.
+    const getRemoteWorkspaceInfo = vi
+      .fn()
+      .mockResolvedValueOnce({ ...base, capabilities: null })
+      .mockResolvedValue({ ...base, capabilities: { supportsCustomTemplates: true, supportsWatch: true } })
+    installZen({
+      onVaultChange: vi.fn(() => vi.fn()),
+      getAppInfo: vi.fn().mockReturnValue({ runtime: 'desktop' }),
+      getServerCapabilities: vi.fn().mockResolvedValue({}),
+      getCurrentVault: vi.fn().mockResolvedValue({ root: '/srv/vault', name: 'vault' }),
+      getRemoteWorkspaceInfo
+    })
+
+    const { useStore } = await loadStore()
+    await useStore.getState().init()
+
+    expect(getRemoteWorkspaceInfo).toHaveBeenCalledTimes(2)
+    expect(useStore.getState().workspaceMode).toBe('remote')
+    expect(useStore.getState().remoteWorkspaceInfo?.capabilities).toEqual({
+      supportsCustomTemplates: true,
+      supportsWatch: true
+    })
+  })
+})
+
+describe('kanban folder root (#730)', () => {
+  it('normalizes a typed root to a clean posix path and clears junk', async () => {
+    const { normalizeKanbanFolderRoot, viewPrefsFromVault } = await import('./store')
+    expect(normalizeKanbanFolderRoot('  /Projects/  ')).toBe('Projects')
+    expect(normalizeKanbanFolderRoot('Projects\\Client work\\')).toBe('Projects/Client work')
+    expect(normalizeKanbanFolderRoot('./Projects/../x')).toBe('Projects/x')
+    expect(normalizeKanbanFolderRoot('')).toBe('')
+    expect(normalizeKanbanFolderRoot(42)).toBe('')
+    expect(viewPrefsFromVault({ view: { kanbanFolderRoot: ' Areas/ ' } } as never)).toMatchObject({ kanbanFolderRoot: 'Areas' })
+    expect(viewPrefsFromVault({ view: {} } as never)).not.toHaveProperty('kanbanFolderRoot')
+  })
+
+  it('setKanbanFolderRoot stores the normalized root', async () => {
+    const { useStore } = await import('./store')
+    useStore.getState().setKanbanFolderRoot('/Projects/')
+    expect(useStore.getState().kanbanFolderRoot).toBe('Projects')
+    useStore.getState().setKanbanFolderRoot('')
+    expect(useStore.getState().kanbanFolderRoot).toBe('')
+  })
+})
+
+describe('ignored keys (#732)', () => {
+  it('normalizes the list and edits it by name', async () => {
+    const { useStore } = await import('./store')
+    useStore.getState().setIgnoredKeys([' KanaMode ', 'kanamode', 'F24'])
+    expect(useStore.getState().ignoredKeys).toEqual(['KanaMode', 'F24'])
+    useStore.getState().addIgnoredKey('Lang1')
+    expect(useStore.getState().ignoredKeys).toEqual(['KanaMode', 'F24', 'Lang1'])
+    useStore.getState().removeIgnoredKey('f24')
+    expect(useStore.getState().ignoredKeys).toEqual(['KanaMode', 'Lang1'])
+    useStore.getState().setIgnoredKeys([])
+    expect(useStore.getState().ignoredKeys).toEqual([])
+  })
+})
diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts
index 2cb3cf92..2f8edfb9 100644
--- a/packages/app-core/src/store.ts
+++ b/packages/app-core/src/store.ts
@@ -226,6 +226,15 @@ import {
   normalizeTextReplacements,
   type TextReplacements
 } from './lib/cm-text-replacements'
+import {
+  normalizeSavedTaskFilters,
+  renameSavedTaskFilter as renameSavedTaskFilterEntry,
+  savedTaskFilterQuery,
+  withSavedTaskFilter,
+  withoutSavedTaskFilter,
+  type SavedTaskFilters
+} from './lib/saved-task-filters'
+import { normalizeIgnoredKeys } from './lib/ignored-keys'
 import { normalizeEditorTabSize } from './lib/editor-tab-size'
 import { recentNoteToggleTarget } from './lib/recent-note-toggle'
 
@@ -500,6 +509,8 @@ interface Prefs {
   /** Key sequence that exits insert mode (maps to <Esc>), e.g. "jk".
    *  Empty disables it. */
   vimInsertEscape: string
+  /** Keys the app ignores entirely (#732): a remapper's tap-hold no-op, by DOM key or code. */
+  ignoredKeys: string[]
   /** When true, Vim yank/delete/change also copy to the system clipboard and
    *  `p` / `P` paste from it (like `set clipboard=unnamed`). */
   vimYankToClipboard: boolean
@@ -569,6 +580,8 @@ interface Prefs {
   textReplacementsEnabled: boolean
   /** Trigger to replacement mappings, such as `->` to `→`. */
   textReplacements: TextReplacements
+  /** Saved Tasks filters by name, the `[saved_filters]` table in config.toml (#731). */
+  savedTaskFilters: SavedTaskFilters
   /** Auto-insert matching `[]`, `()`, and `{}` delimiters while typing. */
   autoPairs: boolean
   /** Also auto-insert matching quotes outside Markdown code spans and blocks. */
@@ -710,6 +723,7 @@ interface Prefs {
   /** Ordered status ids for the custom-status Kanban board (group-by "custom").
    *  Each id matches an inline `@status:<id>` task token. Config-driven. (#354) */
   kanbanStatuses: string[]
+  kanbanFolderRoot: string
   /** True once the user has dismissed the first-run onboarding wizard. */
   hasCompletedOnboarding: boolean
 }
@@ -778,6 +792,8 @@ function normalizeKanbanColumnTitle(title: string): string | null {
 // prefix would otherwise fail the value grammar and get silently dropped. (#389)
 const STATIC_COLUMN_TITLE_KEY_RE = /^[a-z-]+:[A-Za-z0-9_-]+$/
 const FIELD_COLUMN_TITLE_KEY_RE = /^field:[a-z][a-z0-9_-]*:(?:__none__|[\p{L}\d][\p{L}\d/_-]*)$/u
+// Folder columns are keyed by the note directory (#730): any printable path.
+const FOLDER_COLUMN_TITLE_KEY_RE = /^folder:(?:__none__|[^\u0000-\u001f]{1,256})$/u
 
 function normalizeKanbanColumnTitles(raw: unknown): Record<string, string> {
   if (!raw || typeof raw !== 'object') return {}
@@ -789,7 +805,8 @@ function normalizeKanbanColumnTitles(raw: unknown): Record<string, string> {
       STATIC_COLUMN_TITLE_KEY_RE.test(key) &&
       STATIC_KANBAN_GROUP_BYS.some((group) => key.startsWith(`${group}:`))
     const isField = FIELD_COLUMN_TITLE_KEY_RE.test(key)
-    if (!isStatic && !isField) continue
+    const isFolder = FOLDER_COLUMN_TITLE_KEY_RE.test(key)
+    if (!isStatic && !isField && !isFolder) continue
     const normalized = normalizeKanbanColumnTitle(value)
     if (normalized) out[key] = normalized
   }
@@ -797,6 +814,7 @@ function normalizeKanbanColumnTitles(raw: unknown): Record<string, string> {
 }
 
 const MAX_KANBAN_ORDERED_COLUMNS = 64
+const MAX_KANBAN_COLUMN_ID_LENGTH = 256
 
 // Manual column arrangement per board: `{ "<groupBy>": ["<columnId>", ...] }`.
 // Column ids are validated loosely (the same tag-like slugs the boards use);
@@ -810,7 +828,8 @@ function normalizeKanbanColumnOrder(raw: unknown): Record<string, string[]> {
     const seen = new Set<string>()
     for (const entry of value) {
       if (typeof entry !== 'string') continue
-      const id = entry.trim().slice(0, MAX_KANBAN_STATUS_ID_LENGTH)
+      // Folder columns are directory paths (#730), longer than a status slug.
+      const id = entry.trim().slice(0, MAX_KANBAN_COLUMN_ID_LENGTH)
       if (!id || seen.has(id)) continue
       seen.add(id)
       ids.push(id)
@@ -841,7 +860,8 @@ export function normalizeKanbanCardOrder(raw: unknown): Record<string, string[]>
       STATIC_COLUMN_TITLE_KEY_RE.test(key) &&
       STATIC_KANBAN_GROUP_BYS.some((group) => key.startsWith(`${group}:`))
     const isField = FIELD_COLUMN_TITLE_KEY_RE.test(key)
-    if (!isStatic && !isField) continue
+    const isFolder = FOLDER_COLUMN_TITLE_KEY_RE.test(key)
+    if (!isStatic && !isField && !isFolder) continue
     const cards: string[] = []
     const seen = new Set<string>()
     for (const entry of value) {
@@ -892,6 +912,23 @@ export function normalizeHiddenWorkflowPresets(raw: unknown): string[] {
   return out
 }
 
+const MAX_KANBAN_FOLDER_ROOT_LENGTH = 200
+
+/** The folder board's root (#730): a folder path relative to the notes area,
+ *  posix, no slashes at the ends, '' for none. Backslashes are accepted from
+ *  Windows-minded hands. */
+export function normalizeKanbanFolderRoot(raw: unknown): string {
+  if (typeof raw !== 'string') return ''
+  return raw
+    .trim()
+    .replace(/\\/g, '/')
+    .split('/')
+    .map((part) => part.trim())
+    .filter((part) => part && part !== '.' && part !== '..')
+    .join('/')
+    .slice(0, MAX_KANBAN_FOLDER_ROOT_LENGTH)
+}
+
 export function normalizeKanbanStatuses(raw: unknown): string[] {
   if (!Array.isArray(raw)) return []
   const out: string[] = []
@@ -950,6 +987,9 @@ export function viewPrefsFromVault(settings: VaultSettings | null | undefined):
   if (Array.isArray(v.kanbanStatuses)) {
     patch.kanbanStatuses = normalizeKanbanStatuses(v.kanbanStatuses)
   }
+  if (typeof v.kanbanFolderRoot === 'string') {
+    patch.kanbanFolderRoot = normalizeKanbanFolderRoot(v.kanbanFolderRoot)
+  }
   if (typeof v.autoReveal === 'boolean') patch.autoReveal = v.autoReveal
   if (v.systemFolderLabels && typeof v.systemFolderLabels === 'object') {
     patch.systemFolderLabels = normalizeSystemFolderLabels(v.systemFolderLabels)
@@ -985,6 +1025,7 @@ function persistVaultViewOverride(patch: VaultViewSettings): void {
 export const DEFAULT_PREFS: Prefs = {
   vimMode: true,
   vimInsertEscape: '',
+  ignoredKeys: [],
   vimYankToClipboard: false,
   vimBlockImeInNormalMode: true,
   vimWrappedLineMotions: 'display',
@@ -1012,6 +1053,7 @@ export const DEFAULT_PREFS: Prefs = {
   markdownSnippets: true,
   textReplacementsEnabled: true,
   textReplacements: { '->': '→' },
+  savedTaskFilters: {},
   autoPairs: true,
   autoPairQuotesInProse: false,
   hideBuiltinTemplates: false,
@@ -1084,6 +1126,7 @@ export const DEFAULT_PREFS: Prefs = {
   kanbanColumnOrder: {},
   kanbanCardOrder: {},
   kanbanStatuses: [],
+  kanbanFolderRoot: '',
   hasCompletedOnboarding: false
 }
 /** Coerce any loaded prefs blob into a valid Prefs object, dropping
@@ -1107,6 +1150,7 @@ function normalizePrefs(p: Partial<Prefs>): Prefs {
       typeof p.vimInsertEscape === 'string'
         ? p.vimInsertEscape.trim().slice(0, 5)
         : DEFAULT_PREFS.vimInsertEscape,
+    ignoredKeys: normalizeIgnoredKeys(p.ignoredKeys),
     vimYankToClipboard:
       typeof p.vimYankToClipboard === 'boolean'
         ? p.vimYankToClipboard
@@ -1204,6 +1248,9 @@ function normalizePrefs(p: Partial<Prefs>): Prefs {
     textReplacements: normalizeTextReplacements(
       p.textReplacements ?? DEFAULT_PREFS.textReplacements
     ),
+    savedTaskFilters: normalizeSavedTaskFilters(
+      p.savedTaskFilters ?? DEFAULT_PREFS.savedTaskFilters
+    ),
     autoPairs: typeof p.autoPairs === 'boolean' ? p.autoPairs : DEFAULT_PREFS.autoPairs,
     autoPairQuotesInProse:
       typeof p.autoPairQuotesInProse === 'boolean'
@@ -1411,6 +1458,7 @@ function normalizePrefs(p: Partial<Prefs>): Prefs {
     kanbanColumnOrder: normalizeKanbanColumnOrder(p.kanbanColumnOrder),
     kanbanCardOrder: normalizeKanbanCardOrder(p.kanbanCardOrder),
     kanbanStatuses: normalizeKanbanStatuses(p.kanbanStatuses),
+    kanbanFolderRoot: normalizeKanbanFolderRoot(p.kanbanFolderRoot),
     hasCompletedOnboarding:
       typeof p.hasCompletedOnboarding === 'boolean'
         ? p.hasCompletedOnboarding
@@ -2194,6 +2242,8 @@ async function rewriteTagAcrossVault(
 function collectPrefs(s: {
   vimMode: boolean
   vimInsertEscape: string
+  /** Keys the app ignores entirely (#732): a remapper's tap-hold no-op, by DOM key or code. */
+  ignoredKeys: string[]
   vimYankToClipboard: boolean
   vimBlockImeInNormalMode: boolean
   vimWrappedLineMotions: VimWrappedLineMotionMode
@@ -2223,6 +2273,7 @@ function collectPrefs(s: {
   markdownSnippets: boolean
   textReplacementsEnabled: boolean
   textReplacements: TextReplacements
+  savedTaskFilters: SavedTaskFilters
   autoPairs: boolean
   autoPairQuotesInProse: boolean
   hideBuiltinTemplates: boolean
@@ -2287,11 +2338,14 @@ function collectPrefs(s: {
   kanbanColumnOrder: Record<string, string[]>
   kanbanCardOrder: Record<string, string[]>
   kanbanStatuses: string[]
+  /** Folder board root (#730): group by the children of this folder; '' = each note's own folder. */
+  kanbanFolderRoot: string
   hasCompletedOnboarding: boolean
 }): Prefs {
   return {
     vimMode: s.vimMode,
     vimInsertEscape: s.vimInsertEscape,
+    ignoredKeys: s.ignoredKeys,
     vimYankToClipboard: s.vimYankToClipboard,
     vimBlockImeInNormalMode: s.vimBlockImeInNormalMode,
     vimWrappedLineMotions: s.vimWrappedLineMotions,
@@ -2321,6 +2375,7 @@ function collectPrefs(s: {
     markdownSnippets: s.markdownSnippets,
     textReplacementsEnabled: s.textReplacementsEnabled,
     textReplacements: s.textReplacements,
+    savedTaskFilters: s.savedTaskFilters,
     autoPairs: s.autoPairs,
     autoPairQuotesInProse: s.autoPairQuotesInProse,
     hideBuiltinTemplates: s.hideBuiltinTemplates,
@@ -2385,6 +2440,7 @@ function collectPrefs(s: {
     kanbanColumnOrder: s.kanbanColumnOrder,
     kanbanCardOrder: s.kanbanCardOrder,
     kanbanStatuses: s.kanbanStatuses,
+    kanbanFolderRoot: s.kanbanFolderRoot,
     hasCompletedOnboarding: s.hasCompletedOnboarding
   }
 }
@@ -2809,6 +2865,8 @@ interface Store {
   vimMode: boolean
   /** Key sequence that exits insert mode (maps to <Esc>), e.g. "jk". Persisted. */
   vimInsertEscape: string
+  /** Keys the app ignores entirely (#732): a remapper's tap-hold no-op, by DOM key or code. */
+  ignoredKeys: string[]
   /** When true, Vim yank/delete/change also copy to the system clipboard. Persisted. */
   vimYankToClipboard: boolean
   vimBlockImeInNormalMode: boolean
@@ -2845,6 +2903,7 @@ interface Store {
   markdownSnippets: boolean
   textReplacementsEnabled: boolean
   textReplacements: TextReplacements
+  savedTaskFilters: SavedTaskFilters
   /** Auto-insert matching `[]`, `()`, and `{}` delimiters while typing. Persisted. */
   autoPairs: boolean
   /** Also auto-insert matching quotes outside Markdown code spans and blocks. Persisted. */
@@ -3018,6 +3077,7 @@ interface Store {
   kanbanCardOrder: Record<string, string[]>
   /** Ordered status ids for the custom-status Kanban board (config-driven). */
   kanbanStatuses: string[]
+  kanbanFolderRoot: string
   /** True once the user has finished or skipped the first-run onboarding. */
   hasCompletedOnboarding: boolean
   /** ISO YYYY-MM-DD currently selected in the Calendar view. null = today. */
@@ -3228,6 +3288,8 @@ interface Store {
   /** Replace the ordered custom-status list (from Settings). Normalized and
    *  written back to config.toml + the per-vault view override. (#354) */
   setKanbanStatuses: (statuses: string[]) => void
+  /** Folder board root (#730); '' groups by each note's own folder. Persisted per vault and portably. */
+  setKanbanFolderRoot: (root: string) => void
   setTasksCalendarSelectedDate: (iso: string | null) => void
   setTasksCalendarMonthAnchor: (iso: string | null) => void
   setTaskCursorIndex: (idx: number) => void
@@ -3321,6 +3383,11 @@ interface Store {
   setFocusMode: (focus: boolean) => void
   setVimMode: (on: boolean) => void
   setVimInsertEscape: (sequence: string) => void
+  /** Replace the ignored-keys list (#732); persisted with the prefs and mirrored to config.toml. */
+  setIgnoredKeys: (keys: string[]) => void
+  /** Add one key to the ignored list, by the name Settings shows. */
+  addIgnoredKey: (key: string) => void
+  removeIgnoredKey: (key: string) => void
   setVimYankToClipboard: (on: boolean) => void
   setVimBlockImeInNormalMode: (on: boolean) => void
   setVimWrappedLineMotions: (mode: VimWrappedLineMotionMode) => void
@@ -3352,6 +3419,13 @@ interface Store {
   setMarkdownSnippets: (on: boolean) => void
   setTextReplacementsEnabled: (on: boolean) => void
   setTextReplacements: (replacements: TextReplacements) => void
+  /** Saved Tasks filters (#731). Names match case-insensitively; edits keep the
+   *  chip order, and every change is mirrored to config.toml with the prefs. */
+  saveTaskFilter: (name: string, query: string) => void
+  renameSavedTaskFilter: (from: string, to: string) => void
+  deleteSavedTaskFilter: (name: string) => void
+  /** Set the Tasks filter to the query saved under `name`; false when unknown. */
+  applySavedTaskFilter: (name: string) => boolean
   setAutoPairs: (on: boolean) => void
   setAutoPairQuotesInProse: (on: boolean) => void
   setHideBuiltinTemplates: (hidden: boolean) => void
@@ -4654,6 +4728,7 @@ export const useStore = create<Store>((set, get) => {
   zenRestoreState: null,
   vimMode: loadPrefs().vimMode,
   vimInsertEscape: loadPrefs().vimInsertEscape,
+  ignoredKeys: loadPrefs().ignoredKeys,
   vimYankToClipboard: loadPrefs().vimYankToClipboard,
   vimBlockImeInNormalMode: loadPrefs().vimBlockImeInNormalMode,
   vimWrappedLineMotions: loadPrefs().vimWrappedLineMotions,
@@ -4683,6 +4758,7 @@ export const useStore = create<Store>((set, get) => {
   markdownSnippets: loadPrefs().markdownSnippets,
   textReplacementsEnabled: loadPrefs().textReplacementsEnabled,
   textReplacements: loadPrefs().textReplacements,
+  savedTaskFilters: loadPrefs().savedTaskFilters,
   autoPairs: loadPrefs().autoPairs,
   autoPairQuotesInProse: loadPrefs().autoPairQuotesInProse,
   hideBuiltinTemplates: loadPrefs().hideBuiltinTemplates,
@@ -4751,6 +4827,7 @@ export const useStore = create<Store>((set, get) => {
   kanbanColumnOrder: loadPrefs().kanbanColumnOrder,
   kanbanCardOrder: loadPrefs().kanbanCardOrder,
   kanbanStatuses: loadPrefs().kanbanStatuses,
+  kanbanFolderRoot: loadPrefs().kanbanFolderRoot,
   hasCompletedOnboarding: loadPrefs().hasCompletedOnboarding,
   vaultTasks: [],
   customThemes: [],
@@ -5962,6 +6039,12 @@ export const useStore = create<Store>((set, get) => {
     savePrefs(collectPrefs(get()))
     persistVaultViewOverride({ kanbanStatuses: next })
   },
+  setKanbanFolderRoot: (root) => {
+    const next = normalizeKanbanFolderRoot(root)
+    set({ kanbanFolderRoot: next })
+    savePrefs(collectPrefs(get()))
+    persistVaultViewOverride({ kanbanFolderRoot: next })
+  },
   setTasksCalendarSelectedDate: (iso) => set({ tasksCalendarSelectedDate: iso }),
   setTasksCalendarMonthAnchor: (iso) => set({ tasksCalendarMonthAnchor: iso }),
   setTaskCursorIndex: (idx) => set({ taskCursorIndex: Math.max(0, idx) }),
@@ -6320,7 +6403,10 @@ export const useStore = create<Store>((set, get) => {
           .catch((err) => {
             console.error('resync vault settings failed', err)
           }),
-        tasksSurfaceVisible(get()) ? get().refreshTasks() : Promise.resolve()
+        tasksSurfaceVisible(get()) ? get().refreshTasks() : Promise.resolve(),
+        // Templates ride the feed too (scope 'templates'), so a gap may have
+        // swallowed a template saved on another device.
+        get().loadCustomTemplates()
       ])
       const stateAfter = get()
       const openTabs = [...new Set(allLeaves(stateAfter.paneLayout).flatMap((leaf) => leaf.tabs))]
@@ -6385,6 +6471,13 @@ export const useStore = create<Store>((set, get) => {
       await get().loadNoteComments(ev.path)
       return
     }
+    if (ev.scope === 'templates') {
+      // A custom template changed on disk: another client on this vault, a
+      // synced dotfile, or this app's own save. Re-list the templates, not
+      // the note tree; a template is not a note.
+      await get().loadCustomTemplates()
+      return
+    }
     if (ev.scope === 'database') {
       // On delete, forget the database instead of re-reading a file that's gone
       // (which throws "Database not found"); otherwise sync from disk.
@@ -7219,6 +7312,17 @@ export const useStore = create<Store>((set, get) => {
     set({ vimInsertEscape: sequence.trim().slice(0, 5) })
     savePrefs(collectPrefs(get()))
   },
+  setIgnoredKeys: (keys) => {
+    set({ ignoredKeys: normalizeIgnoredKeys(keys) })
+    savePrefs(collectPrefs(get()))
+  },
+  addIgnoredKey: (key) => {
+    get().setIgnoredKeys([...get().ignoredKeys, key])
+  },
+  removeIgnoredKey: (key) => {
+    const wanted = key.trim().toLowerCase()
+    get().setIgnoredKeys(get().ignoredKeys.filter((entry) => entry.toLowerCase() !== wanted))
+  },
   setVimYankToClipboard: (on) => {
     set({ vimYankToClipboard: on })
     savePrefs(collectPrefs(get()))
@@ -7234,8 +7338,10 @@ export const useStore = create<Store>((set, get) => {
   setKeymapBinding: (id, binding) => {
     set((s) => {
       const nextOverrides = { ...s.keymapOverrides }
-      if (binding) nextOverrides[id] = binding
-      else delete nextOverrides[id]
+      // null clears the override so the default returns; the empty string is
+      // a stored unbind and has to stay.
+      if (binding === null) delete nextOverrides[id]
+      else nextOverrides[id] = binding
       return { keymapOverrides: nextOverrides }
     })
     savePrefs(collectPrefs(get()))
@@ -7373,6 +7479,30 @@ export const useStore = create<Store>((set, get) => {
     set({ textReplacements: normalizeTextReplacements(replacements) })
     savePrefs(collectPrefs(get()))
   },
+  saveTaskFilter: (name, query) => {
+    const next = withSavedTaskFilter(get().savedTaskFilters, name, query)
+    if (next === get().savedTaskFilters) return
+    set({ savedTaskFilters: next })
+    savePrefs(collectPrefs(get()))
+  },
+  renameSavedTaskFilter: (from, to) => {
+    const next = renameSavedTaskFilterEntry(get().savedTaskFilters, from, to)
+    if (next === get().savedTaskFilters) return
+    set({ savedTaskFilters: next })
+    savePrefs(collectPrefs(get()))
+  },
+  deleteSavedTaskFilter: (name) => {
+    const next = withoutSavedTaskFilter(get().savedTaskFilters, name)
+    if (next === get().savedTaskFilters) return
+    set({ savedTaskFilters: next })
+    savePrefs(collectPrefs(get()))
+  },
+  applySavedTaskFilter: (name) => {
+    const query = savedTaskFilterQuery(get().savedTaskFilters, name)
+    if (query === null) return false
+    set({ tasksFilter: query, taskCursorIndex: 0 })
+    return true
+  },
   setAutoPairs: (on) => {
     set({ autoPairs: on })
     savePrefs(collectPrefs(get()))
@@ -9126,7 +9256,7 @@ export const useStore = create<Store>((set, get) => {
     try {
       const remoteWorkspaceProfilesPromise = get().refreshRemoteWorkspaceProfiles()
       const localVaultsPromise = get().refreshLocalVaults()
-      const [remoteWorkspaceInfo, serverCapabilities] = await Promise.all([
+      const [bootWorkspaceInfo, serverCapabilities] = await Promise.all([
         get().refreshWorkspaceContext(),
         window.zen.getServerCapabilities().catch(() => null)
       ])
@@ -9134,8 +9264,8 @@ export const useStore = create<Store>((set, get) => {
         void remoteWorkspaceProfilesPromise
         void localVaultsPromise
         set({
-          workspaceMode: workspaceModeFrom(remoteWorkspaceInfo),
-          remoteWorkspaceInfo,
+          workspaceMode: workspaceModeFrom(bootWorkspaceInfo),
+          remoteWorkspaceInfo: bootWorkspaceInfo,
           workspaceSetupError: null,
           workspaceRestored: true,
           vaultSettings: DEFAULT_VAULT_SETTINGS
@@ -9146,6 +9276,14 @@ export const useStore = create<Store>((set, get) => {
         return
       }
       const vault = await window.zen.getCurrentVault()
+      // getCurrentVault is what connects a configured remote workspace, so
+      // the info fetched above predates the connection: its capabilities and
+      // bootError are still null, and keeping it would leave Settings
+      // believing the server advertises nothing (#723). Ask again now that
+      // the answer exists.
+      const remoteWorkspaceInfo = bootWorkspaceInfo
+        ? await get().refreshWorkspaceContext()
+        : bootWorkspaceInfo
       void remoteWorkspaceProfilesPromise
       void localVaultsPromise
       if (vault) {
diff --git a/packages/bridge-contract/package.json b/packages/bridge-contract/package.json
index bf11939c..bd250581 100644
--- a/packages/bridge-contract/package.json
+++ b/packages/bridge-contract/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/bridge-contract",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "type": "module",
   "exports": {
     "./bridge": "./src/bridge.ts",
diff --git a/packages/bridge-contract/src/ipc.ts b/packages/bridge-contract/src/ipc.ts
index 56bfe3e6..ee131754 100644
--- a/packages/bridge-contract/src/ipc.ts
+++ b/packages/bridge-contract/src/ipc.ts
@@ -437,6 +437,9 @@ export interface VaultViewSettings {
   groupByKind?: boolean
   tasksViewMode?: string
   kanbanGroupBy?: string
+  /** Folder board: group by the children of this folder (relative to the
+   *  notes area); empty groups by each note's own folder. (#730) */
+  kanbanFolderRoot?: string
   kanbanColumnTitles?: Record<string, string>
   kanbanColumnOrder?: Record<string, string[]>
   kanbanCardOrder?: Record<string, string[]>
@@ -610,6 +613,11 @@ export interface NoteComment {
   createdAt: number
   updatedAt: number
   resolvedAt: number | null
+  /** Who wrote it. Absent for the vault's owner; an assistant's name (via the
+   *  MCP server or the CLI) otherwise, so a discussion reads like one. (#738) */
+  author?: string
+  /** Threads a reply under a top-level comment's id. Absent on top-level comments. */
+  parentId?: string | null
 }
 
 export interface NoteCommentInput {
@@ -622,6 +630,8 @@ export interface NoteCommentInput {
   createdAt?: number
   updatedAt?: number
   resolvedAt?: number | null
+  author?: string
+  parentId?: string | null
 }
 
 export type VaultTextSearchBackendPreference = 'auto' | 'builtin' | 'ripgrep' | 'fzf'
@@ -776,6 +786,11 @@ export interface ServerCapabilities {
   /** Server-side workflow file CRUD plus journalled apply/undo. Absent before
    *  2.29, where the web client must keep Workflows read-only. */
   supportsWorkflows?: boolean
+  /** Custom-template CRUD under `.zennotes/templates/` (the `/templates`
+   *  routes), the same files the desktop keeps for a local vault. Absent
+   *  before 2.46, which keeps Settings, Templates read-only on the web client
+   *  and on a desktop connected to that server (#723). */
+  supportsCustomTemplates?: boolean
 }
 
 export interface ServerSessionStatus {
@@ -850,12 +865,16 @@ export type VaultChangeKind = 'add' | 'change' | 'unlink'
  *  watch socket that reconnected): anything may have happened while the feed
  *  was down, so the renderer re-pulls every surface the feed keeps fresh.
  *  Servers never emit it. */
+/** `templates` is a custom template under `.zennotes/templates/` changing on
+ *  disk; the path is that file's vault-relative path, and the client re-lists
+ *  templates rather than notes. */
 export type VaultChangeScope =
   | 'content'
   | 'vault-settings'
   | 'comments'
   | 'database'
   | 'folder'
+  | 'templates'
   | 'resync'
 
 export interface VaultChangeEvent {
diff --git a/packages/shared-domain/package.json b/packages/shared-domain/package.json
index cd5961b3..00615d04 100644
--- a/packages/shared-domain/package.json
+++ b/packages/shared-domain/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/shared-domain",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "type": "module",
   "exports": {
     "./*": "./src/*.ts"
diff --git a/packages/shared-domain/src/app-config.ts b/packages/shared-domain/src/app-config.ts
index cd51bb55..ce0aa7f7 100644
--- a/packages/shared-domain/src/app-config.ts
+++ b/packages/shared-domain/src/app-config.ts
@@ -69,6 +69,7 @@ export const PORTABLE_PREF_KEYS = [
   'whichKeyHintTimeoutMs',
   // keymaps (overrides only)
   'keymapOverrides',
+  'ignoredKeys',
   // search
   'vaultTextSearchBackend',
   'ripgrepBinaryPath',
@@ -143,8 +144,11 @@ export const PORTABLE_PREF_KEYS = [
   'tasksViewMode',
   'showArchivedTasks',
   'kanbanGroupBy',
+  'kanbanFolderRoot',
   'kanbanColumnTitles',
-  'kanbanStatuses'
+  'kanbanStatuses',
+  // tasks
+  'savedTaskFilters'
 ] as const
 
 export type PortablePrefKey = (typeof PORTABLE_PREF_KEYS)[number]
@@ -191,6 +195,7 @@ export const PORTABLE_DEFAULTS: Record<PortablePrefKey, unknown> = {
   whichKeyHintMode: 'timed',
   whichKeyHintTimeoutMs: 900,
   keymapOverrides: {},
+  ignoredKeys: [],
   vaultTextSearchBackend: 'auto',
   ripgrepBinaryPath: null,
   fzfBinaryPath: null,
@@ -259,6 +264,8 @@ export const PORTABLE_DEFAULTS: Record<PortablePrefKey, unknown> = {
   tasksViewMode: 'list',
   showArchivedTasks: false,
   kanbanGroupBy: 'status',
+  kanbanFolderRoot: '',
   kanbanColumnTitles: {},
-  kanbanStatuses: []
+  kanbanStatuses: [],
+  savedTaskFilters: {}
 }
diff --git a/packages/shared-domain/src/keymaps-catalog.ts b/packages/shared-domain/src/keymaps-catalog.ts
index 35c5210a..95a93eff 100644
--- a/packages/shared-domain/src/keymaps-catalog.ts
+++ b/packages/shared-domain/src/keymaps-catalog.ts
@@ -146,6 +146,7 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [
   { id: "nav.toggleTask", group: "view-actions", defaultBinding: "x", title: "Toggle task" },
   { id: "tasks.moveTaskUp", group: "view-actions", defaultBinding: "K", title: "Move task up" },
   { id: "tasks.moveTaskDown", group: "view-actions", defaultBinding: "J", title: "Move task down" },
+  { id: "tasks.savedFilters", group: "view-actions", defaultBinding: "F", title: "Pick a saved Tasks filter" },
   { id: "editor.hopMarkerForward", group: "view-actions", defaultBinding: "Alt+]", defaultBindingMac: "Ctrl+.", title: "Hop past next marker" },
   { id: "editor.hopMarkerBackward", group: "view-actions", defaultBinding: "Alt+[", defaultBindingMac: "Ctrl+,", title: "Hop before previous marker" },
   { id: "editor.foldHeading", group: "view-actions", defaultBinding: "Alt+Mod+F", title: "Fold heading" },
diff --git a/packages/shared-domain/src/note-comments.test.ts b/packages/shared-domain/src/note-comments.test.ts
new file mode 100644
index 00000000..27ca943b
--- /dev/null
+++ b/packages/shared-domain/src/note-comments.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import {
+  lineOfOffset,
+  normalizeNoteComment,
+  normalizeNoteComments,
+  noteCommentsSidecarPath,
+  resolveCommentAnchor,
+  threadNoteComments,
+  threadRootOf
+} from './note-comments'
+
+const NOTE = 'inbox/Plan.md'
+
+describe('normalizeNoteComment', () => {
+  it('keeps an author and a parent, trimmed, and drops them when blank', () => {
+    const c = normalizeNoteComment(
+      { notePath: NOTE, anchorStart: 3, anchorEnd: 9, anchorText: 'the plan', body: ' Looks good ', author: '  Claude  Code ', parentId: ' c1 ' },
+      NOTE,
+      1000
+    )!
+    expect(c.body).toBe('Looks good')
+    expect(c.author).toBe('Claude Code')
+    expect(c.parentId).toBe('c1')
+    expect(c.createdAt).toBe(1000)
+    expect(c.resolvedAt).toBeNull()
+    const plain = normalizeNoteComment({ notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'x', author: '  ', parentId: '' }, NOTE)!
+    expect(plain).not.toHaveProperty('author')
+    expect(plain).not.toHaveProperty('parentId')
+  })
+
+  it('drops a comment without a body and mints an id when missing', () => {
+    expect(normalizeNoteComment({ notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: '  ' }, NOTE)).toBeNull()
+    const c = normalizeNoteComment({ notePath: NOTE, anchorStart: 5, anchorEnd: 2, anchorText: '', body: 'b' }, NOTE)!
+    expect(c.id.length).toBeGreaterThan(8)
+    expect(c.anchorStart).toBe(2)
+    expect(c.anchorEnd).toBe(5)
+  })
+})
+
+describe('normalizeNoteComments', () => {
+  it('reads both sidecar shapes, dedupes by id, sorts by creation, and orphans a reply whose parent is gone', () => {
+    const raw = {
+      version: 1,
+      comments: [
+        { id: 'b', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'second', createdAt: 2 },
+        { id: 'a', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'first', createdAt: 1 },
+        { id: 'a', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'dupe', createdAt: 3 },
+        { id: 'r', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'reply', createdAt: 4, parentId: 'a', author: 'Claude' },
+        { id: 'o', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'orphan', createdAt: 5, parentId: 'missing' },
+        { id: 's', notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', body: 'self', createdAt: 6, parentId: 's' },
+        null,
+        'junk'
+      ]
+    }
+    const comments = normalizeNoteComments(raw, NOTE)
+    expect(comments.map((c) => c.id)).toEqual(['a', 'b', 'r', 'o', 's'])
+    expect(comments[2].parentId).toBe('a')
+    expect(comments[3]).not.toHaveProperty('parentId')
+    expect(comments[4]).not.toHaveProperty('parentId')
+    expect(normalizeNoteComments([{ id: 'x', body: 'bare array', anchorStart: 0, anchorEnd: 0, anchorText: '', notePath: NOTE }], NOTE)).toHaveLength(1)
+    expect(normalizeNoteComments('nope', NOTE)).toEqual([])
+  })
+})
+
+describe('threadNoteComments', () => {
+  const base = { notePath: NOTE, anchorStart: 0, anchorEnd: 0, anchorText: '', updatedAt: 0, resolvedAt: null }
+  const comments = [
+    { ...base, id: 'a', body: 'A', createdAt: 1 },
+    { ...base, id: 'b', body: 'B', createdAt: 2 },
+    { ...base, id: 'a1', body: 'A reply', createdAt: 3, parentId: 'a', author: 'Claude' },
+    { ...base, id: 'a2', body: 'reply to the reply', createdAt: 4, parentId: 'a1' },
+    { ...base, id: 'b1', body: 'B reply', createdAt: 5, parentId: 'b' }
+  ]
+
+  it('groups replies under their top-level comment, one level deep, in order', () => {
+    const threads = threadNoteComments(comments)
+    expect(threads.map((t) => t.comment.id)).toEqual(['a', 'b'])
+    expect(threads[0].replies.map((r) => r.id)).toEqual(['a1', 'a2'])
+    expect(threads[1].replies.map((r) => r.id)).toEqual(['b1'])
+  })
+
+  it('finds the thread root for any id', () => {
+    expect(threadRootOf(comments, 'a2')?.id).toBe('a')
+    expect(threadRootOf(comments, 'b')?.id).toBe('b')
+    expect(threadRootOf(comments, 'zzz')).toBeNull()
+  })
+})
+
+describe('anchors and lines', () => {
+  it('re-anchors by text when the offsets drifted', () => {
+    const doc = 'intro\n\nthe plan is simple\n'
+    expect(resolveCommentAnchor({ anchorStart: 0, anchorEnd: 8, anchorText: 'the plan' }, doc)).toEqual({ from: 7, to: 15 })
+    expect(resolveCommentAnchor({ anchorStart: 7, anchorEnd: 15, anchorText: 'the plan' }, doc)).toEqual({ from: 7, to: 15 })
+    expect(resolveCommentAnchor({ anchorStart: 2, anchorEnd: 4, anchorText: 'gone' }, doc)).toEqual({ from: 2, to: 4 })
+  })
+
+  it('counts lines from one', () => {
+    const doc = 'a\nb\nc'
+    expect(lineOfOffset(doc, 0)).toBe(1)
+    expect(lineOfOffset(doc, 2)).toBe(2)
+    expect(lineOfOffset(doc, 4)).toBe(3)
+    expect(lineOfOffset(doc, 99)).toBe(3)
+  })
+
+  it('names the sidecar next to the internal dir', () => {
+    expect(noteCommentsSidecarPath('.zennotes', 'inbox/Plan.md')).toBe('.zennotes/comments/inbox/Plan.md.comments.json')
+  })
+})
diff --git a/packages/shared-domain/src/note-comments.ts b/packages/shared-domain/src/note-comments.ts
new file mode 100644
index 00000000..8c85fc53
--- /dev/null
+++ b/packages/shared-domain/src/note-comments.ts
@@ -0,0 +1,208 @@
+import type { NoteComment, NoteCommentInput } from './ipc'
+
+/**
+ * Note comments on disk and in memory (#738). A note's comments live beside
+ * it as `.zennotes/comments/<note path>.comments.json`; this module is the
+ * one place that decides what a comment record looks like, shared by the
+ * desktop main process, the MCP server and the CLI (the Go server mirrors it
+ * in internal/vault). A comment is anchored to the text it was written on,
+ * carries an optional `author` (absent for the vault's owner, the name of an
+ * assistant otherwise) and an optional `parentId` that threads a reply under
+ * a top-level comment, so a note can be discussed like an issue: comment,
+ * answer, resolve.
+ */
+
+export const NOTE_COMMENTS_DIR = 'comments'
+export const NOTE_COMMENTS_SUFFIX = '.comments.json'
+export const MAX_COMMENT_ANCHOR_TEXT_LENGTH = 500
+export const MAX_COMMENT_AUTHOR_LENGTH = 80
+
+/** Vault-relative posix path of the sidecar that holds `notePath`'s comments. */
+export function noteCommentsSidecarPath(internalDir: string, notePath: string): string {
+  return `${internalDir}/${NOTE_COMMENTS_DIR}/${notePath}${NOTE_COMMENTS_SUFFIX}`
+}
+
+function newCommentId(): string {
+  const cryptoApi = globalThis.crypto as { randomUUID?: () => string } | undefined
+  if (cryptoApi?.randomUUID) return cryptoApi.randomUUID()
+  // Node before 19 and very old browsers: a time-salted random id is still
+  // unique enough for one note's sidecar.
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`
+}
+
+function finiteOr(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback
+}
+
+export function normalizeCommentAuthor(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const author = value.replace(/\s+/g, ' ').trim().slice(0, MAX_COMMENT_AUTHOR_LENGTH)
+  return author || undefined
+}
+
+/**
+ * Validate one comment record from any source (the app, the file, a tool).
+ * A comment with no body is dropped; everything else is coerced into shape.
+ */
+export function normalizeNoteComment(
+  input: NoteCommentInput,
+  notePath: string,
+  now: number = Date.now()
+): NoteComment | null {
+  const body = typeof input.body === 'string' ? input.body.trim() : ''
+  if (!body) return null
+  const rawStart = Number.isFinite(input.anchorStart) ? Math.max(0, Math.floor(input.anchorStart)) : 0
+  const rawEnd = Number.isFinite(input.anchorEnd) ? Math.max(0, Math.floor(input.anchorEnd)) : rawStart
+  const anchorStart = Math.min(rawStart, rawEnd)
+  const anchorEnd = Math.max(rawStart, rawEnd)
+  const anchorText =
+    typeof input.anchorText === 'string'
+      ? input.anchorText.replace(/\s+/g, ' ').trim().slice(0, MAX_COMMENT_ANCHOR_TEXT_LENGTH)
+      : ''
+  const author = normalizeCommentAuthor(input.author)
+  const parentId = typeof input.parentId === 'string' && input.parentId.trim() ? input.parentId.trim() : null
+  const comment: NoteComment = {
+    id: typeof input.id === 'string' && input.id.trim() ? input.id.trim() : newCommentId(),
+    notePath,
+    anchorStart,
+    anchorEnd,
+    anchorText,
+    body,
+    createdAt: finiteOr(input.createdAt, now),
+    updatedAt: finiteOr(input.updatedAt, now),
+    resolvedAt: typeof input.resolvedAt === 'number' && Number.isFinite(input.resolvedAt) ? input.resolvedAt : null
+  }
+  if (author) comment.author = author
+  if (parentId) comment.parentId = parentId
+  return comment
+}
+
+/**
+ * Validate a whole sidecar (`{ version, comments }` or a bare array): drop
+ * malformed and duplicate records, keep creation order. A reply whose parent
+ * is missing is kept as a comment of its own rather than lost.
+ */
+export function normalizeNoteComments(raw: unknown, notePath: string, now: number = Date.now()): NoteComment[] {
+  const values = Array.isArray(raw)
+    ? raw
+    : raw && typeof raw === 'object' && Array.isArray((raw as { comments?: unknown }).comments)
+      ? (raw as { comments: unknown[] }).comments
+      : []
+  const seen = new Set<string>()
+  const comments: NoteComment[] = []
+  for (const value of values) {
+    if (!value || typeof value !== 'object') continue
+    const comment = normalizeNoteComment(value as NoteCommentInput, notePath, now)
+    if (!comment || seen.has(comment.id)) continue
+    seen.add(comment.id)
+    comments.push(comment)
+  }
+  comments.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id))
+  const ids = new Set(comments.map((c) => c.id))
+  for (const comment of comments) {
+    if (comment.parentId && (!ids.has(comment.parentId) || comment.parentId === comment.id)) {
+      delete comment.parentId
+    }
+  }
+  return comments
+}
+
+/** A top-level comment with the replies threaded under it, in creation order. */
+export interface NoteCommentThread {
+  comment: NoteComment
+  replies: NoteComment[]
+}
+
+/**
+ * Group a note's comments into threads. Replies attach to the top-level
+ * comment their `parentId` names; a reply to a reply lands in the same
+ * thread, so a thread stays one level deep like a review conversation.
+ */
+export function threadNoteComments(comments: NoteComment[]): NoteCommentThread[] {
+  const byId = new Map(comments.map((c) => [c.id, c] as const))
+  const rootOf = (comment: NoteComment): NoteComment => {
+    let current = comment
+    const visited = new Set<string>()
+    while (current.parentId && byId.has(current.parentId) && !visited.has(current.id)) {
+      visited.add(current.id)
+      current = byId.get(current.parentId)!
+    }
+    return current
+  }
+  const threads = new Map<string, NoteCommentThread>()
+  for (const comment of comments) {
+    const root = rootOf(comment)
+    if (root === comment) {
+      if (!threads.has(comment.id)) threads.set(comment.id, { comment, replies: [] })
+      continue
+    }
+    let thread = threads.get(root.id)
+    if (!thread) {
+      thread = { comment: root, replies: [] }
+      threads.set(root.id, thread)
+    }
+    thread.replies.push(comment)
+  }
+  return comments.filter((c) => rootOf(c) === c).map((c) => threads.get(c.id)!)
+}
+
+/** The top-level comment `id` belongs to (itself when it is one), or null. */
+export function threadRootOf(comments: NoteComment[], id: string): NoteComment | null {
+  for (const thread of threadNoteComments(comments)) {
+    if (thread.comment.id === id || thread.replies.some((r) => r.id === id)) return thread.comment
+  }
+  return null
+}
+
+export interface ResolvedCommentAnchor {
+  from: number
+  to: number
+}
+
+/**
+ * Where a comment's anchor sits in `doc` now: the stored offsets when the
+ * text there still matches, else the first occurrence of the anchored text,
+ * else the (clamped) stored offsets.
+ */
+export function resolveCommentAnchor(
+  comment: Pick<NoteComment, 'anchorStart' | 'anchorEnd' | 'anchorText'>,
+  doc: string
+): ResolvedCommentAnchor {
+  const docLength = doc.length
+  const from = Math.max(0, Math.min(docLength, comment.anchorStart))
+  const to = Math.max(from, Math.min(docLength, comment.anchorEnd))
+  const selected = doc.slice(from, to)
+  if (!comment.anchorText || selected === comment.anchorText) {
+    return { from, to }
+  }
+  const found = doc.indexOf(comment.anchorText)
+  if (found >= 0) return { from: found, to: found + comment.anchorText.length }
+  return { from, to }
+}
+
+export function selectionToCommentAnchor(
+  doc: string,
+  from: number,
+  to: number
+): Pick<NoteComment, 'anchorStart' | 'anchorEnd' | 'anchorText'> {
+  const start = Math.max(0, Math.min(doc.length, Math.min(from, to)))
+  const end = Math.max(start, Math.min(doc.length, Math.max(from, to)))
+  const selected = doc.slice(start, end).replace(/\s+/g, ' ').trim()
+  return {
+    anchorStart: start,
+    anchorEnd: end,
+    anchorText: selected.slice(0, MAX_COMMENT_ANCHOR_TEXT_LENGTH)
+  }
+}
+
+export function commentQuote(comment: Pick<NoteComment, 'anchorText'>): string {
+  return comment.anchorText.trim() || 'Current cursor position'
+}
+
+/** 1-based line number of `offset` in `doc`. */
+export function lineOfOffset(doc: string, offset: number): number {
+  const at = Math.max(0, Math.min(doc.length, offset))
+  let line = 1
+  for (let i = 0; i < at; i += 1) if (doc.charCodeAt(i) === 10) line += 1
+  return line
+}
diff --git a/packages/shared-ui/package.json b/packages/shared-ui/package.json
index a6122ee8..1ec9520a 100644
--- a/packages/shared-ui/package.json
+++ b/packages/shared-ui/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/shared-ui",
   "private": true,
-  "version": "2.45.0",
+  "version": "2.46.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"