From d825b149fd5c15c9365dcc023bfad3a444a0187a Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 12:45:50 -0500
Subject: [PATCH 01/10] Fix(search): note search, the buffer switcher and the
 [[ picker name a folder the same way
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

2.75.0 gave note search a folder column (#982), and it showed the whole
vault path: `inbox/Projects/Atlas/docs`. The [[ picker already showed the
same note as `Projects/Atlas/docs/`, and the buffer switcher showed the raw
parent directory, so one note read three ways depending on where you looked.
The picker had the opposite problem one area over: it stripped every area's
directory, so an archived `2025/Atlas/` looked like an inbox folder of the
same name.

All three now ask one helper, `noteFolderLabel` in vault-layout. In the
main notes area it is the folder inside the area, without the area's own
directory, following a root-mode vault and a remapped inbox the way the
sidebar does. Anywhere else it is the folder from the vault root, area
first (`archive/2025/Atlas`, or the remapped directory name), so an archived
note never passes for an inbox one. A note at the top of the main notes
area has no folder and gets '': each surface keeps its own area label there
(note search's INBOX column, the picker's `inbox/`, the switcher's `inbox`),
since that label is surface styling, not a path. A buffer whose note the
store does not list still falls back to its path's parent.

The bidi embedding around the search folder is now written as ‪ and
‬ escapes, like the buffer switcher's, instead of invisible literals.
---
 .../src/components/BufferPalette.test.ts      | 26 +++++++++++
 .../app-core/src/components/BufferPalette.tsx | 27 ++++++++---
 .../src/components/SearchPalette.test.ts      | 10 ++---
 .../app-core/src/components/SearchPalette.tsx | 20 ++++-----
 .../app-core/src/lib/link-candidates.test.ts  | 22 ++++++++-
 packages/app-core/src/lib/link-candidates.ts  | 14 +++---
 .../app-core/src/lib/vault-layout.test.ts     | 45 +++++++++++++++++++
 packages/app-core/src/lib/vault-layout.ts     | 18 ++++++++
 8 files changed, 153 insertions(+), 29 deletions(-)

diff --git a/packages/app-core/src/components/BufferPalette.test.ts b/packages/app-core/src/components/BufferPalette.test.ts
index 999bf4426..504ba84f6 100644
--- a/packages/app-core/src/components/BufferPalette.test.ts
+++ b/packages/app-core/src/components/BufferPalette.test.ts
@@ -3,6 +3,7 @@
 import { act, createElement } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { DEFAULT_VAULT_SETTINGS, type NoteFolder, type NoteMeta } from '@shared/ipc'
 import { findLeaf, type PaneLeaf } from '../lib/pane-layout'
 import { useStore } from '../store'
 import { BufferPalette } from './BufferPalette'
@@ -109,4 +110,29 @@ describe('BufferPalette (#641)', () => {
       'B'
     )
   })
+
+  it('shows the folder note search and the [[ picker show for each buffer', () => {
+    const note = (path: string, folder: NoteFolder): NoteMeta =>
+      ({ path, folder, title: 'Overview', tags: [], wikilinks: [] }) as unknown as NoteMeta
+    const tabs = [
+      'inbox/Projects/Atlas/Overview.md',
+      'archive/2025/Atlas/Overview.md',
+      'inbox/Overview.md',
+      'inbox/Unlisted/Overview.md'
+    ]
+    useStore.setState({
+      paneLayout: { kind: 'leaf', id: 'pane-a', tabs, pinnedTabs: [], activeTab: tabs[0] },
+      selectedPath: tabs[0],
+      notes: [note(tabs[0], 'inbox'), note(tabs[1], 'archive'), note(tabs[2], 'inbox')],
+      vaultSettings: { ...DEFAULT_VAULT_SETTINGS, primaryNotesLocation: 'inbox' }
+    })
+    act(() => root.render(createElement(BufferPalette)))
+    // Natural order: the hidden tabs, then the current one. A tab whose note
+    // is not listed falls back to its path's folder.
+    expect(
+      [...document.querySelectorAll<HTMLElement>('[data-buf-idx] span[dir="rtl"]')].map((span) =>
+        span.textContent?.replace(/[\u202A\u202C]/g, '')
+      )
+    ).toEqual(['archive/2025/Atlas', 'inbox', 'inbox/Unlisted', 'Projects/Atlas'])
+  })
 })
diff --git a/packages/app-core/src/components/BufferPalette.tsx b/packages/app-core/src/components/BufferPalette.tsx
index 8a4ac349a..6637a2987 100644
--- a/packages/app-core/src/components/BufferPalette.tsx
+++ b/packages/app-core/src/components/BufferPalette.tsx
@@ -29,6 +29,7 @@ import { isTrashTabPath } from '@shared/trash'
 import { isQuickNotesTabPath } from '@shared/quick-notes'
 import { resolveSystemFolderLabels, type SystemFolderLabels } from '../lib/system-folder-labels'
 import { focusEditorNormalMode } from '../lib/editor-focus'
+import { noteFolderLabel } from '../lib/vault-layout'
 import { Modal } from './ui/Modal'
 
 interface BufferEntry {
@@ -47,9 +48,11 @@ function fallbackTitle(path: string): string {
   return filename.replace(/\.md$/i, '') || path
 }
 
-/** The row's secondary column: the note's folder, not the full path — the
- *  filename part would just repeat the title, and it was crowding the title
- *  out of the row (#635). The full path stays searchable via keywords. */
+/** The row's secondary column: the note's folder, not the full path, since
+ *  the filename part would just repeat the title, and it was crowding the title
+ *  out of the row (#635). The full path stays searchable via keywords. A note
+ *  the store knows gets the folder note search and the [[ picker show
+ *  (`noteFolderLabel`); this is only for a tab whose note is not listed. */
 function parentDir(path: string): string {
   const idx = path.lastIndexOf('/')
   return idx > 0 ? path.slice(0, idx) : ''
@@ -63,6 +66,7 @@ interface BuildDeps {
   notes: ReturnType<typeof useStore.getState>['notes']
   noteDirty: ReturnType<typeof useStore.getState>['noteDirty']
   systemFolderLabels: SystemFolderLabels
+  vaultSettings: ReturnType<typeof useStore.getState>['vaultSettings']
 }
 
 function buildEntries(deps: BuildDeps): BufferEntry[] {
@@ -201,7 +205,7 @@ function buildEntries(deps: BuildDeps): BufferEntry[] {
     entries.push({
       path,
       title,
-      subtitle: parentDir(path),
+      subtitle: meta ? noteFolderLabel(meta, deps.vaultSettings) || meta.folder : parentDir(path),
       keywords: [title, path, meta?.folder].filter(Boolean).join(' '),
       badge,
       current: isCurrent,
@@ -249,6 +253,7 @@ export function BufferPalette(): JSX.Element {
   const notes = useStore((s) => s.notes)
   const noteDirty = useStore((s) => s.noteDirty)
   const systemFolderLabels = useStore((s) => s.systemFolderLabels)
+  const vaultSettings = useStore((s) => s.vaultSettings)
 
   const entries = useMemo(
     () =>
@@ -259,9 +264,19 @@ export function BufferPalette(): JSX.Element {
         noteContents,
         notes,
         noteDirty,
-        systemFolderLabels
+        systemFolderLabels,
+        vaultSettings
       }),
-    [paneLayout, activePaneId, selectedPath, noteContents, notes, noteDirty, systemFolderLabels]
+    [
+      paneLayout,
+      activePaneId,
+      selectedPath,
+      noteContents,
+      notes,
+      noteDirty,
+      systemFolderLabels,
+      vaultSettings
+    ]
   )
 
   const [query, setQuery] = useState('')
diff --git a/packages/app-core/src/components/SearchPalette.test.ts b/packages/app-core/src/components/SearchPalette.test.ts
index f8789b9a1..f3772ffb9 100644
--- a/packages/app-core/src/components/SearchPalette.test.ts
+++ b/packages/app-core/src/components/SearchPalette.test.ts
@@ -295,7 +295,7 @@ describe('SearchPalette: the create row opens a New note form', () => {
     type(search(), 'Alph')
     const rows = [...document.querySelectorAll<HTMLElement>('[data-search-idx]')]
     expect(rows.map((r) => r.dataset.searchIdx)).toEqual(['0', '1'])
-    expect(rows[0].textContent).toBe('Alpha‪inbox‬')
+    expect(rows[0].textContent).toBe('Alphainbox')
     expect(rows[1].hasAttribute('data-search-create')).toBe(true)
     expect(highlighted()).toBe('0')
 
@@ -609,14 +609,14 @@ describe('SearchPalette: each row shows the note\'s folder (#982)', () => {
   const shown = (): { title: string; folder: string }[] =>
     [...document.querySelectorAll<HTMLButtonElement>('[data-search-idx]')].map((row) => {
       const [title, folder] = [...row.querySelectorAll('span')].map((s) => s.textContent ?? '')
-      return { title, folder: folder.replace(/[‪‬]/g, '') }
+      return { title, folder: folder.replace(/[\u202A\u202C]/g, '') }
     })
 
   it('tells notes that share a name apart by their folder', () => {
     act(() => root.render(createElement(SearchPalette)))
     expect(shown()).toEqual([
-      { title: 'Overview', folder: 'inbox/Projects/Atlas/docs' },
-      { title: 'Overview', folder: 'inbox/Projects/Billing/docs' },
+      { title: 'Overview', folder: 'Projects/Atlas/docs' },
+      { title: 'Overview', folder: 'Projects/Billing/docs' },
       { title: 'Overview', folder: 'archive/2025/Atlas' },
       { title: 'Overview', folder: 'inbox' }
     ])
@@ -629,7 +629,7 @@ describe('SearchPalette: each row shows the note\'s folder (#982)', () => {
     for (const dir of dirs) {
       // rtl puts the ellipsis on the left; the embedding keeps the path LTR.
       expect(dir.getAttribute('dir')).toBe('rtl')
-      expect(dir.textContent?.startsWith('‪')).toBe(true)
+      expect(dir.textContent?.startsWith('\u202A')).toBe(true)
       expect(dir.className).toContain('truncate')
     }
     const rootRow = document.querySelector('[data-search-idx="3"]')!
diff --git a/packages/app-core/src/components/SearchPalette.tsx b/packages/app-core/src/components/SearchPalette.tsx
index 1562f5dae..8c5a30dd9 100644
--- a/packages/app-core/src/components/SearchPalette.tsx
+++ b/packages/app-core/src/components/SearchPalette.tsx
@@ -9,7 +9,6 @@ import {
   searchNoteIndex
 } from '../lib/note-search'
 import { focusEditorNormalMode } from '../lib/editor-focus'
-import { parentDirOf } from '../lib/manual-order'
 import {
   destinationLabel,
   parseDestinationText,
@@ -18,7 +17,7 @@ import {
   type SearchCreateDraft
 } from '../lib/search-create'
 import { resolveSystemFolderLabels } from '../lib/system-folder-labels'
-import { isPrimaryNotesAtRoot } from '../lib/vault-layout'
+import { isPrimaryNotesAtRoot, noteFolderLabel } from '../lib/vault-layout'
 import { useToastStore } from '../lib/toast'
 import { Modal } from './ui/Modal'
 import { SearchCreateForm, type SearchCreateTarget } from './SearchCreateForm'
@@ -200,7 +199,7 @@ export function SearchPalette(): JSX.Element {
             <div className="px-4 py-6 text-center text-sm text-ink-400">No matches.</div>
           ) : (
             results.map((n, i) => {
-              const dir = parentDirOf(n.path)
+              const dir = noteFolderLabel(n, vaultSettings)
               return (
                 <button
                   key={n.path}
@@ -213,12 +212,13 @@ export function SearchPalette(): JSX.Element {
                   ].join(' ')}
                 >
                   {/* Notes that share a name differ only by folder, so the row
-                      shows the folder the way the buffer switcher does (#635,
-                      #982): the title keeps its natural width and the path takes
-                      what is left, losing its head first (dir="rtl", with the
-                      LRE/PDF embedding keeping the path itself left-to-right).
-                      A note at the vault root has no folder to show and keeps
-                      its area label. */}
+                      shows the folder the way the buffer switcher and the [[
+                      picker do (noteFolderLabel, #635, #982): the title keeps
+                      its natural width and the path takes what is left, losing
+                      its head first (dir="rtl", with the LRE/PDF embedding
+                      keeping the path itself left-to-right). A note at the top
+                      of the main notes area has no folder to show and keeps its
+                      area label. */}
                   <span className="min-w-0 truncate text-sm font-medium text-ink-900">
                     {n.title}
                   </span>
@@ -228,7 +228,7 @@ export function SearchPalette(): JSX.Element {
                       data-search-dir
                       className="min-w-0 flex-1 truncate text-xs text-ink-400"
                     >
-                      {`‪${dir}‬`}
+                      {`\u202A${dir}\u202C`}
                     </span>
                   ) : (
                     <span className="ml-auto shrink-0 text-xs uppercase tracking-wide text-ink-400">
diff --git a/packages/app-core/src/lib/link-candidates.test.ts b/packages/app-core/src/lib/link-candidates.test.ts
index 8fbee40a6..837d04d62 100644
--- a/packages/app-core/src/lib/link-candidates.test.ts
+++ b/packages/app-core/src/lib/link-candidates.test.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest'
 import type { FolderEntry, NoteFolder, NoteMeta } from '@shared/ipc'
 import { DEFAULT_VAULT_SETTINGS } from '@shared/ipc'
-import { linkCandidates, noteLinkTarget, notesMatchingSource } from './link-candidates'
+import { linkCandidates, noteLinkTarget, noteSubtitle, notesMatchingSource } from './link-candidates'
 
 const makeNote = (path: string, title: string, folder: NoteFolder = 'inbox'): NoteMeta =>
   ({
@@ -129,3 +129,23 @@ describe('notesMatchingSource (#500)', () => {
     expect(notesMatchingSource(notes, { kind: 'tag', tag: 'person' }).map((n) => n.title)).toEqual(['Jane'])
   })
 })
+
+describe('noteSubtitle: the [[ picker shows the folder note search shows', () => {
+  it('drops the main area directory and keeps every other area', () => {
+    expect(noteSubtitle(makeNote('inbox/Projects/Atlas/Overview.md', 'Overview'), settings)).toBe(
+      'Projects/Atlas/'
+    )
+    expect(
+      noteSubtitle(makeNote('archive/2025/Atlas/Overview.md', 'Overview', 'archive'), settings)
+    ).toBe('archive/2025/Atlas/')
+  })
+
+  it('labels a note at the top of an area with the area', () => {
+    expect(noteSubtitle(makeNote('inbox/Overview.md', 'Overview'), settings)).toBe('inbox/')
+    expect(noteSubtitle(makeNote('archive/Overview.md', 'Overview', 'archive'), settings)).toBe(
+      'archive/'
+    )
+    const rootMode = { ...settings, primaryNotesLocation: 'root' as const }
+    expect(noteSubtitle(makeNote('Overview.md', 'Overview'), rootMode)).toBe('')
+  })
+})
diff --git a/packages/app-core/src/lib/link-candidates.ts b/packages/app-core/src/lib/link-candidates.ts
index da8143147..1271dbbcd 100644
--- a/packages/app-core/src/lib/link-candidates.ts
+++ b/packages/app-core/src/lib/link-candidates.ts
@@ -8,7 +8,7 @@
 import type { AssetMeta, NoteMeta, VaultSettings } from '@shared/ipc'
 import type { FolderEntry } from '@shared/ipc'
 import type { SelectOptionsSource } from '@shared/databases'
-import { isPrimaryNotesAtRoot, noteFolderSubpath } from './vault-layout'
+import { isPrimaryNotesAtRoot, noteFolderLabel } from './vault-layout'
 import { listDatabaseLinkTargets, type DatabaseLinkTarget } from './database-links'
 
 /**
@@ -48,16 +48,16 @@ function stripMdExtension(value: string): string {
   return value.replace(/\.md$/i, '')
 }
 
-/** `folder/` prefix shown beside a note suggestion (empty at a root-mode root). */
+/** `folder/` prefix shown beside a note suggestion, the folder note search and
+ *  the buffer switcher show (`noteFolderLabel`); a note at the top of the
+ *  inbox shows `inbox/`, and nothing at a root-mode vault's root. */
 export function noteSubtitle(
   note: NoteMeta,
   vaultSettings: VaultSettings | null | undefined
 ): string {
-  const subpath = noteFolderSubpath(note, vaultSettings)
-  if (note.folder === 'inbox' && isPrimaryNotesAtRoot(vaultSettings)) {
-    return subpath ? `${subpath}/` : ''
-  }
-  return subpath ? `${subpath}/` : `${note.folder}/`
+  const folder = noteFolderLabel(note, vaultSettings)
+  if (folder) return `${folder}/`
+  return note.folder === 'inbox' && isPrimaryNotesAtRoot(vaultSettings) ? '' : `${note.folder}/`
 }
 
 export function assetSubtitle(asset: AssetMeta): string {
diff --git a/packages/app-core/src/lib/vault-layout.test.ts b/packages/app-core/src/lib/vault-layout.test.ts
index fa02b3429..d12c2ee94 100644
--- a/packages/app-core/src/lib/vault-layout.test.ts
+++ b/packages/app-core/src/lib/vault-layout.test.ts
@@ -12,6 +12,7 @@ import {
   folderForVaultRelativePath,
   isCalendarToggleAvailable,
   isFavoriteFolderKey,
+  noteFolderLabel,
   noteFolderSubpath,
   normalizeVaultSettings,
   resolveCreateLocation,
@@ -618,6 +619,50 @@ describe('folderForVaultRelativePath with remapped system folders (#398)', () =>
   })
 })
 
+describe('noteFolderLabel: the folder note search, the buffer switcher and the [[ picker show', () => {
+  const inboxMode = { primaryNotesLocation: 'inbox' } as VaultSettings
+  const rootMode = { primaryNotesLocation: 'root' } as VaultSettings
+
+  it('shows a main-area folder without the area directory, in either vault mode', () => {
+    expect(noteFolderLabel({ folder: 'inbox', path: 'inbox/Projects/Atlas/n.md' }, inboxMode)).toBe(
+      'Projects/Atlas'
+    )
+    expect(noteFolderLabel({ folder: 'inbox', path: 'Projects/Atlas/n.md' }, rootMode)).toBe(
+      'Projects/Atlas'
+    )
+  })
+
+  it('follows a remapped notes area', () => {
+    const remapped = {
+      primaryNotesLocation: 'inbox',
+      systemFolderPaths: { inbox: '00 - Notes' }
+    } as VaultSettings
+    expect(noteFolderLabel({ folder: 'inbox', path: '00 - Notes/Projects/n.md' }, remapped)).toBe(
+      'Projects'
+    )
+  })
+
+  it('leaves a note at the top of the main area for the caller to label', () => {
+    expect(noteFolderLabel({ folder: 'inbox', path: 'inbox/n.md' }, inboxMode)).toBe('')
+    expect(noteFolderLabel({ folder: 'inbox', path: 'n.md' }, rootMode)).toBe('')
+  })
+
+  it('keeps the area directory for every other area, as it is named on disk', () => {
+    expect(noteFolderLabel({ folder: 'archive', path: 'archive/2025/Atlas/n.md' }, inboxMode)).toBe(
+      'archive/2025/Atlas'
+    )
+    expect(noteFolderLabel({ folder: 'archive', path: 'archive/n.md' }, rootMode)).toBe('archive')
+    expect(noteFolderLabel({ folder: 'quick', path: 'quick/n.md' }, inboxMode)).toBe('quick')
+    const remapped = {
+      primaryNotesLocation: 'inbox',
+      systemFolderPaths: { archive: '99 - Archive' }
+    } as VaultSettings
+    expect(noteFolderLabel({ folder: 'archive', path: '99 - Archive/2025/n.md' }, remapped)).toBe(
+      '99 - Archive/2025'
+    )
+  })
+})
+
 describe('favorites', () => {
   it('discriminates folder keys from note paths by the colon', () => {
     expect(isFavoriteFolderKey('inbox:Projects')).toBe(true)
diff --git a/packages/app-core/src/lib/vault-layout.ts b/packages/app-core/src/lib/vault-layout.ts
index 13770b071..99b7db2b6 100644
--- a/packages/app-core/src/lib/vault-layout.ts
+++ b/packages/app-core/src/lib/vault-layout.ts
@@ -1054,6 +1054,24 @@ export function noteFolderSubpath(
   return parts.length > 1 ? parts.slice(0, -1).join('/') : ''
 }
 
+/**
+ * Where a note lives, as the folder column of note search, the buffer
+ * switcher and the [[ picker show it. In the main notes area it is the folder
+ * inside that area, without the area's own directory: most notes live there,
+ * and `inbox/` on every row only crowded the title out. Anywhere else it is
+ * the whole folder path, area directory first, so `archive/2025/Atlas` never
+ * reads as an inbox folder of the same name (#982). A note at the top of the
+ * main notes area has no folder to show and gets '', for the caller to label.
+ */
+export function noteFolderLabel(
+  note: Pick<NoteMeta, 'folder' | 'path'>,
+  settings: VaultSettings | null | undefined
+): string {
+  if (note.folder === 'inbox') return noteFolderSubpath(note, settings)
+  const end = note.path.lastIndexOf('/')
+  return end === -1 ? '' : note.path.slice(0, end)
+}
+
 export function noteBelongsToFolderView(
   note: Pick<NoteMeta, 'folder' | 'path'>,
   folder: NoteFolder,

From 0b3c8ce91939814c9e3ddae1f547ad6a5b660b87 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 12:45:54 -0500
Subject: [PATCH 02/10] Fix(assets): Move asset accepts a folder like v1..2 and
 says where an empty answer goes

The Move asset prompt (sidebar tree, a folder's note list, a rendered
image's menu) refused any path containing two dots in a row, so `v1..2` or
`Notes..old` could never receive an asset: the same substring check that
broke dotted names in the Android vault (zennotesandroid#130). Its copy also
promised that an empty answer moves the asset to the vault root, while every
host files it in `assets/` instead: the desktop vault and the server
(`cleanAssetTargetDir`) and the phone shells' local vaults alike.

The three copies of the prompt are now one, `lib/move-asset.ts`. It refuses
only a whole `..` segment, with either separator, keeps the refusal of the
internal `.zennotes` folder, and says "Leave empty to move it to the assets/
folder." The renderer turns an empty answer into `assets` before its no-op
check, so the move does what the copy says: an asset loose at the vault root
now goes to assets/ on an empty answer (it used to stay put), and an asset
already in assets/ makes no round trip. The hosts still resolve the target
against the vault and refuse an escape on their own; this check is for the
message.
---
 packages/app-core/src/components/NoteList.tsx | 22 ++------
 packages/app-core/src/components/Preview.tsx  | 22 ++------
 packages/app-core/src/components/Sidebar.tsx  | 22 ++------
 packages/app-core/src/lib/move-asset.test.ts  | 52 +++++++++++++++++++
 packages/app-core/src/lib/move-asset.ts       | 43 +++++++++++++++
 5 files changed, 110 insertions(+), 51 deletions(-)
 create mode 100644 packages/app-core/src/lib/move-asset.test.ts
 create mode 100644 packages/app-core/src/lib/move-asset.ts

diff --git a/packages/app-core/src/components/NoteList.tsx b/packages/app-core/src/components/NoteList.tsx
index b8089eacc..2cb3e9a34 100644
--- a/packages/app-core/src/components/NoteList.tsx
+++ b/packages/app-core/src/components/NoteList.tsx
@@ -16,6 +16,7 @@ import { ContextMenu, type ContextMenuItem } from './ContextMenu'
 import { ResizeHandle } from './ResizeHandle'
 import { Button, IconButton } from './ui/Button'
 import { buildMoveNotePrompt, moveNoteVocabulary, parseMoveNoteTarget } from '../lib/move-note'
+import { assetMoveTargetDir, buildMoveAssetPrompt } from '../lib/move-asset'
 import { naturalCompare } from '../lib/natural-sort'
 import { extractTags } from '../lib/tags'
 import { setDragPayload } from '../lib/dnd'
@@ -353,23 +354,10 @@ export function NoteList(): JSX.Element {
       items.push({
         label: 'Move…',
         onSelect: async () => {
-          const target = await promptApp({
-            title: 'Move asset',
-            description: 'Enter a vault-relative folder path. Leave empty to move to the vault root.',
-            initialValue: currentDir,
-            placeholder: 'media/screenshots',
-            okLabel: 'Move',
-            allowEmptySubmit: true,
-            validate: (value) => {
-              const clean = value.trim()
-              if (clean.includes('..')) return 'Path cannot contain ..'
-              if (clean.split('/').includes('.zennotes')) {
-                return 'Cannot move assets into internal ZenNotes files'
-              }
-              return null
-            }
-          })
-          if (target === null || target === currentDir) return
+          const value = await promptApp(buildMoveAssetPrompt(currentDir))
+          if (value === null) return
+          const target = assetMoveTargetDir(value)
+          if (target === currentDir) return
           await moveAsset(asset.path, target)
         }
       })
diff --git a/packages/app-core/src/components/Preview.tsx b/packages/app-core/src/components/Preview.tsx
index f9c1d2f30..45395d5db 100644
--- a/packages/app-core/src/components/Preview.tsx
+++ b/packages/app-core/src/components/Preview.tsx
@@ -82,6 +82,7 @@ import { NoteHoverPreview } from "./NoteHoverPreview";
 import { ContextMenu, type ContextMenuItem } from "./ContextMenu";
 import { ArrowUpRightIcon, MaximizeIcon, MinimizeIcon } from "./icons";
 import { promptApp } from "../lib/prompt-requests";
+import { assetMoveTargetDir, buildMoveAssetPrompt } from "../lib/move-asset";
 import { renderMermaidSvg } from "../lib/mermaid-render";
 import { confirmApp } from "../lib/confirm-requests";
 
@@ -1051,23 +1052,10 @@ export const Preview = memo(function Preview({
       items.push({
         label: "Move…",
         onSelect: async () => {
-          const target = await promptApp({
-            title: "Move asset",
-            description: "Enter a vault-relative folder path. Leave empty to move to the vault root.",
-            initialValue: currentDir,
-            placeholder: "media/screenshots",
-            okLabel: "Move",
-            allowEmptySubmit: true,
-            validate: (value) => {
-              const clean = value.trim();
-              if (clean.includes("..")) return "Path cannot contain ..";
-              if (clean.split("/").includes(".zennotes")) {
-                return "Cannot move assets into internal ZenNotes files";
-              }
-              return null;
-            },
-          });
-          if (target === null || target === currentDir) return;
+          const value = await promptApp(buildMoveAssetPrompt(currentDir));
+          if (value === null) return;
+          const target = assetMoveTargetDir(value);
+          if (target === currentDir) return;
           await moveAsset(vaultRel, target);
         },
       });
diff --git a/packages/app-core/src/components/Sidebar.tsx b/packages/app-core/src/components/Sidebar.tsx
index d4eaa4d0b..d9443b32c 100644
--- a/packages/app-core/src/components/Sidebar.tsx
+++ b/packages/app-core/src/components/Sidebar.tsx
@@ -25,6 +25,7 @@ import {
 } from "../store";
 import { Button } from "./ui/Button";
 import { buildMoveNotePrompt, moveNoteVocabulary, parseMoveNoteTarget } from "../lib/move-note";
+import { assetMoveTargetDir, buildMoveAssetPrompt } from "../lib/move-asset";
 import { buildTagTree, extractTags, flattenTagTree } from "../lib/tags";
 import { isTypstPreamblePath, resolveTypstPreambleFolder } from "../lib/typst-preamble";
 import { focusEditorNormalMode } from "../lib/editor-focus";
@@ -2476,23 +2477,10 @@ export function Sidebar(): JSX.Element {
       items.push({
         label: "Move…",
         onSelect: async () => {
-          const target = await promptApp({
-            title: "Move asset",
-            description: "Enter a vault-relative folder path. Leave empty to move to the vault root.",
-            initialValue: currentDir,
-            placeholder: "media/screenshots",
-            okLabel: "Move",
-            allowEmptySubmit: true,
-            validate: (value) => {
-              const clean = value.trim();
-              if (clean.includes("..")) return "Path cannot contain ..";
-              if (clean.split("/").includes(".zennotes")) {
-                return "Cannot move assets into internal ZenNotes files";
-              }
-              return null;
-            },
-          });
-          if (target === null || target === currentDir) return;
+          const value = await promptApp(buildMoveAssetPrompt(currentDir));
+          if (value === null) return;
+          const target = assetMoveTargetDir(value);
+          if (target === currentDir) return;
           await moveAsset(asset.path, target);
         },
       });
diff --git a/packages/app-core/src/lib/move-asset.test.ts b/packages/app-core/src/lib/move-asset.test.ts
new file mode 100644
index 000000000..a499f2221
--- /dev/null
+++ b/packages/app-core/src/lib/move-asset.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import { assetMoveTargetDir, buildMoveAssetPrompt, validateAssetMoveTarget } from './move-asset'
+
+describe('validateAssetMoveTarget', () => {
+  it('refuses a whole .. segment, with either separator', () => {
+    expect(validateAssetMoveTarget('..')).toBe('Path cannot contain a .. folder')
+    expect(validateAssetMoveTarget('media/../secrets')).toBe('Path cannot contain a .. folder')
+    expect(validateAssetMoveTarget(' ../media ')).toBe('Path cannot contain a .. folder')
+    expect(validateAssetMoveTarget('media\\..\\secrets')).toBe('Path cannot contain a .. folder')
+  })
+
+  it('accepts folder names that only contain two dots', () => {
+    expect(validateAssetMoveTarget('Notes..old')).toBeNull()
+    expect(validateAssetMoveTarget('media/v1..2/shots')).toBeNull()
+    expect(validateAssetMoveTarget('...')).toBeNull()
+    expect(validateAssetMoveTarget('')).toBeNull()
+  })
+
+  it('keeps assets out of the internal folder', () => {
+    expect(validateAssetMoveTarget('.zennotes/x')).toBe(
+      'Cannot move assets into internal ZenNotes files'
+    )
+    expect(validateAssetMoveTarget('media/.zennotes')).toBe(
+      'Cannot move assets into internal ZenNotes files'
+    )
+    expect(validateAssetMoveTarget('media/.zennotes-old')).toBeNull()
+  })
+})
+
+describe('assetMoveTargetDir', () => {
+  it('sends an empty answer to the assets folder, where every host puts it', () => {
+    expect(assetMoveTargetDir('')).toBe('assets')
+    expect(assetMoveTargetDir('  ')).toBe('assets')
+    expect(assetMoveTargetDir('/')).toBe('assets')
+  })
+
+  it('keeps a typed folder, without its outer slashes', () => {
+    expect(assetMoveTargetDir('media/screenshots')).toBe('media/screenshots')
+    expect(assetMoveTargetDir(' /media/screenshots/ ')).toBe('media/screenshots')
+  })
+})
+
+describe('buildMoveAssetPrompt', () => {
+  it('opens on the current folder and says where an empty answer goes', () => {
+    const prompt = buildMoveAssetPrompt('media')
+    expect(prompt.initialValue).toBe('media')
+    expect(prompt.allowEmptySubmit).toBe(true)
+    expect(prompt.description).toContain('Leave empty to move it to the assets/ folder.')
+    expect(prompt.description).not.toContain('vault root')
+    expect(prompt.validate?.('a/../b')).toBe('Path cannot contain a .. folder')
+  })
+})
diff --git a/packages/app-core/src/lib/move-asset.ts b/packages/app-core/src/lib/move-asset.ts
new file mode 100644
index 000000000..b0469efff
--- /dev/null
+++ b/packages/app-core/src/lib/move-asset.ts
@@ -0,0 +1,43 @@
+import type { PromptOptions } from '../components/PromptModal'
+
+/**
+ * Where an asset goes when the Move asset field is left empty. Every host files
+ * it there rather than loose at the vault root: the desktop vault, the server
+ * (`cleanAssetTargetDir` in both) and the phone shells' local vaults.
+ */
+export const DEFAULT_ASSET_FOLDER = 'assets'
+
+/**
+ * Why `value` cannot be a Move asset destination, or null. Only a whole `..`
+ * segment is refused, never a name that merely contains two dots, so
+ * `Notes..old` and `v1..2` stay valid folders (the substring check this
+ * replaces refused them, the same bug class as zennotesandroid#130). The
+ * hosts resolve the path against the vault and refuse an escape on their own;
+ * this check is for the message.
+ */
+export function validateAssetMoveTarget(value: string): string | null {
+  const segments = value.trim().split(/[\\/]/)
+  if (segments.includes('..')) return 'Path cannot contain a .. folder'
+  if (segments.includes('.zennotes')) return 'Cannot move assets into internal ZenNotes files'
+  return null
+}
+
+/** The folder an asset moves to for what the prompt returned: the typed path,
+ *  or the assets folder for an empty one. */
+export function assetMoveTargetDir(value: string): string {
+  return value.trim().replace(/^\/+|\/+$/g, '') || DEFAULT_ASSET_FOLDER
+}
+
+/** The Move asset prompt shared by the sidebar tree, a folder's note list and
+ *  a rendered image's menu. It opens on the asset's current folder. */
+export function buildMoveAssetPrompt(currentDir: string): PromptOptions {
+  return {
+    title: 'Move asset',
+    description: `Enter a vault-relative folder path. Leave empty to move it to the ${DEFAULT_ASSET_FOLDER}/ folder.`,
+    initialValue: currentDir,
+    placeholder: 'media/screenshots',
+    okLabel: 'Move',
+    allowEmptySubmit: true,
+    validate: validateAssetMoveTarget
+  }
+}

From 5a34aea72d2f7c3bd347c9dba79322d5b4318688 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 13:23:42 -0500
Subject: [PATCH 03/10] Fix(cloud): a stuck phone's conflicts can be settled
 either way, and none deletes a note

Dave (Discord, 2026-10-23) came back to two Untitled.md conflicts on his
phone after its sync had been stuck for a while. Keeping the computer's
version said "trash/Daily Notes/Untitled.md already exists"; after he kept
the phone's version of the first, the second refused both choices, keeping
the phone's as "The file changed again on another device". Reproduced with
two devices against a local Cloud server, it was three problems.

A note this device never had was queued against one of its files. While the
phone was offline the computer made a new Untitled.md at the path of the
note the phone was editing and trashed it. Catching up, the phone met that
new note at its own edited file and queued a conflict there, then only
moved the queued Cloud side when the note went on to the trash. Both
conflicts now claimed the phone's one file. Keeping the phone's version of
the first gave that path to the first note in Cloud, so the second was
refused for good, and taking the computer's version of the second deleted
the phone's file, which was never that note's: the run after pushed the
delete and the kept note was gone from both devices. Such a conflict now
settles after each pull: once Cloud has moved the note off the file it met,
it lands where Cloud keeps it, as any new file would, and the device's file
is left alone; a deleted one just leaves the queue. A decision made on one
an older version saved settles it the same way and never touches the file.

The other device's version could not take its place. It goes where that
device put it, and any file of this device already there blocked the
choice, including an unrelated one: the phone had trashed an Untitled.md of
its own into the slot the computer's went to. That file now moves to the
next free name beside it, Untitled 2.md and on, the way a second note
moved into the folder is named (cloudSyncFreePath). Only the other
device's version makes room; a name the user typed for keeping both still
refuses a taken path, anything but a plain file still refuses, and a failed
write moves the file back.

A Cloud path taken by another file read as "changed again". The server
answers PATH_CONFLICT when a different file holds the destination, which
choosing again can never fix; that now says another file in Cloud uses the
name.

The phone shells' own staged resolve gets the same room-making in their
repos; the settling reaches the phones with the next core.
---
 .../src/main/cloud-sync-filesystem.test.ts    |  58 +++++++
 .../desktop/src/main/cloud-sync-filesystem.ts |  56 ++++++-
 packages/app-core/src/lib/help.ts             |   2 +-
 .../src/cloud-sync-bootstrap.test.ts          |   2 +-
 .../src/cloud-sync-coordinator.test.ts        | 146 +++++++++++++++++-
 .../src/cloud-sync-coordinator.ts             |  84 +++++++++-
 .../cloud-sync-portable-filesystem.test.ts    |  36 +++++
 .../src/cloud-sync-portable-filesystem.ts     |  25 ++-
 .../src/cloud-sync-resolution.test.ts         |   2 +-
 packages/shared-domain/src/cloud-sync.ts      |  24 +++
 10 files changed, 418 insertions(+), 17 deletions(-)

diff --git a/apps/desktop/src/main/cloud-sync-filesystem.test.ts b/apps/desktop/src/main/cloud-sync-filesystem.test.ts
index 9b98a5c73..60be8ea6e 100644
--- a/apps/desktop/src/main/cloud-sync-filesystem.test.ts
+++ b/apps/desktop/src/main/cloud-sync-filesystem.test.ts
@@ -567,6 +567,64 @@ describe('DesktopCloudSyncRepository: decisions and writes', () => {
     expect(await readFile(path.join(root, 'Deck.pdf'), 'utf8')).toBe('cloud bytes')
   }, 20_000)
 
+  it('puts the other device\'s version where it went and moves this device\'s different file beside it', async () => {
+    // Dave (2026-10-23): the computer trashed the note his phone edited, and
+    // the phone had trashed an Untitled.md of its own into the same slot.
+    const root = await temporaryRoot()
+    const note = 'inbox/Daily Notes/Untitled.md'
+    await mkdir(path.join(root, 'inbox/Daily Notes'), { recursive: true })
+    await mkdir(path.join(root, 'trash/Daily Notes'), { recursive: true })
+    await writeFile(path.join(root, note), 'edited here')
+    await writeFile(path.join(root, 'trash/Daily Notes/Untitled.md'), 'own scratch')
+    await writeFile(path.join(root, 'trash/Daily Notes/Untitled 2.md'), 'already second')
+    const cloud = upsert('trash/Daily Notes/Untitled.md', 'from the computer').content!
+    const { data, ...contentMetadata } = cloud
+    const reference = { ...contentMetadata, item_id: 'item-remote', revision: 2 }
+    const repository = new DesktopCloudSyncRepository(root, {
+      stagingDirectory: await temporaryRoot(),
+      fetchImplementation: async () => new Response(data)
+    })
+    const file = await repository.stageCloudContent({
+      reference,
+      previewLimitBytes: 0,
+      getInstruction: async () => ({
+        item_id: reference.item_id, revision: reference.revision, content: contentMetadata,
+        download: { method: 'GET', url: 'https://objects.example.test/immutable', headers: {}, expires_at: '2099-10-01T12:00:00Z' }
+      })
+    })
+    try {
+      await repository.resolveStagedCloudConflict({
+        expected_path: note, expected_sha256: hash('edited here'), cloud_path: 'trash/Daily Notes/Untitled.md', file
+      })
+    } finally {
+      await releaseCloudSyncStagedFile(file)
+    }
+
+    expect(await readFile(path.join(root, 'trash/Daily Notes/Untitled.md'), 'utf8')).toBe('from the computer')
+    expect(await readFile(path.join(root, 'trash/Daily Notes/Untitled 3.md'), 'utf8')).toBe('own scratch')
+    expect(await readFile(path.join(root, 'trash/Daily Notes/Untitled 2.md'), 'utf8')).toBe('already second')
+    await expect(readFile(path.join(root, note), 'utf8')).rejects.toThrow()
+  })
+
+  it('moves only for the other device\'s version: a chosen name that is taken still refuses', async () => {
+    const root = await temporaryRoot()
+    await writeFile(path.join(root, 'Plan.md'), 'edited here')
+    await writeFile(path.join(root, 'Taken.md'), 'someone else')
+    const repository = new DesktopCloudSyncRepository(root)
+    const cloud = upsert('Taken.md', 'cloud').content!
+
+    await expect(repository.applyConflictResolutionFiles({
+      expected_path: 'Plan.md', expected_sha256: hash('edited here'),
+      files: [{ path: 'Taken.md', content: cloud }]
+    })).rejects.toThrow('already exists')
+    await repository.applyConflictResolutionFiles({
+      expected_path: 'Plan.md', expected_sha256: hash('edited here'),
+      files: [{ path: 'Taken.md', content: cloud, displace_existing: true }]
+    })
+    expect(await readFile(path.join(root, 'Taken.md'), 'utf8')).toBe('cloud')
+    expect(await readFile(path.join(root, 'Taken 2.md'), 'utf8')).toBe('someone else')
+  })
+
   it('refuses to write a snapshot that carries no bytes and no source', async () => {
     const root = await temporaryRoot()
     await writeFile(path.join(root, 'Deck.pdf'), 'agreed')
diff --git a/apps/desktop/src/main/cloud-sync-filesystem.ts b/apps/desktop/src/main/cloud-sync-filesystem.ts
index 521b400de..bdfd880db 100644
--- a/apps/desktop/src/main/cloud-sync-filesystem.ts
+++ b/apps/desktop/src/main/cloud-sync-filesystem.ts
@@ -13,6 +13,7 @@ import type {
 import {
   CLOUD_SYNC_SETTINGS_CONFLICT_PATH,
   CLOUD_SYNC_VAULT_SETTINGS_PATH,
+  cloudSyncFreePath,
   cloudSyncPathKey,
   isCloudSyncVaultSettingsPath,
   normalizeCloudSyncPath,
@@ -136,8 +137,11 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
     const local = expected ? await this.localItemOrNull(expected) : null
     if ((local?.content.sha256 ?? null) !== input.expected_sha256) throw new Error('This file changed on this device.')
     const replacing = expected !== null && cloudSyncPathKey(expected) === cloudSyncPathKey(cloud)
-    if (!replacing && await exists(this.resolve(cloud))) throw new Error(`A file named “${cloud}” already exists. Choose another name.`)
+    // The other device's version goes where that device put it.
+    const displacement = replacing ? null
+      : await this.displacementFor(cloud, new Set([cloud, ...(keep ? [keep] : [])].map(cloudSyncPathKey)))
     let keptCopy: Stats | undefined
+    let displaced = false
     let cloudPublished = false
     try {
       if (keep) {
@@ -149,6 +153,10 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
       if (expected && ((await this.localItemOrNull(expected))?.content.sha256 ?? null) !== input.expected_sha256) {
         throw new Error('This file changed on this device.')
       }
+      if (displacement) {
+        await renameWithRetry(this.resolve(displacement.from), this.resolve(displacement.to))
+        displaced = true
+      }
       await this.publishFile(cloud, handle.path, input.file.reference, replacing ? input.expected_sha256 : null, handle.signal)
       cloudPublished = true
       if (expected && !replacing) {
@@ -162,10 +170,37 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
         // intact. An edit, replacement or unverifiable file must survive.
         await this.rollbackStagedConflictCopy(keep, expected, local.content, keptCopy).catch(() => {})
       }
+      if (displacement && displaced && !cloudPublished) await this.undoDisplacement(displacement).catch(() => {})
       throw error
     }
   }
 
+  /**
+   * A different file of this device where the other device's version has to
+   * go (see CloudSyncRepository.applyConflictResolutionFiles): the next free
+   * name beside it, or null when the path is free. Anything but a plain file
+   * there keeps the choice refused.
+   */
+  private async displacementFor(relPath: string, reserved: Set<string>): Promise<{ from: string; to: string } | null> {
+    let stats: Stats
+    try {
+      stats = await fs.lstat(this.resolve(relPath))
+    } catch (error) {
+      if (isMissingFileError(error)) return null
+      throw error
+    }
+    if (!stats.isFile()) throw new Error(`A file named “${relPath}” already exists. Choose another name.`)
+    const to = await cloudSyncFreePath(relPath, async (candidate) =>
+      reserved.has(cloudSyncPathKey(candidate)) || await exists(this.resolve(candidate)))
+    reserved.add(cloudSyncPathKey(to))
+    return { from: relPath, to }
+  }
+
+  private async undoDisplacement(move: { from: string; to: string }): Promise<void> {
+    if (await exists(this.resolve(move.from))) return
+    await renameWithRetry(this.resolve(move.to), this.resolve(move.from))
+  }
+
   private async rollbackStagedConflictCopy(relPath: string, originalPath: string, content: CloudSyncContent, created: Stats): Promise<void> {
     const filename = this.resolve(relPath)
     const before = await fs.lstat(filename)
@@ -370,7 +405,7 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
   async applyConflictResolutionFiles(input: {
     expected_path: string | null
     expected_sha256: string | null
-    files: Array<{ path: string; content: CloudSyncContent }>
+    files: Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }>
   }): Promise<void> {
     const expectedPath = input.expected_path ? normalizeCloudSyncPath(input.expected_path) : null
     const current = expectedPath ? await this.localItemOrNull(expectedPath) : null
@@ -382,9 +417,14 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
 
     const files = normalizedResolutionFiles(input.files)
     const expectedKey = expectedPath ? cloudSyncPathKey(expectedPath) : null
+    const reserved = new Set(files.map((file) => cloudSyncPathKey(file.path)))
+    const displacements: Array<{ from: string; to: string }> = []
     for (const file of files) {
       if (cloudSyncPathKey(file.path) === expectedKey) continue
-      if (await exists(this.resolve(file.path))) {
+      if (file.displace_existing) {
+        const displacement = await this.displacementFor(file.path, reserved)
+        if (displacement) displacements.push(displacement)
+      } else if (await exists(this.resolve(file.path))) {
         throw new Error(`A file named “${file.path}” already exists. Choose another name.`)
       }
     }
@@ -399,7 +439,12 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
           : 0
     )
     const newPaths: string[] = []
+    const displaced: Array<{ from: string; to: string }> = []
     try {
+      for (const move of displacements) {
+        await renameWithRetry(this.resolve(move.from), this.resolve(move.to))
+        displaced.push(move)
+      }
       for (const file of ordered) {
         if (cloudSyncPathKey(file.path) !== expectedKey) newPaths.push(file.path)
         await this.writeContent(file.path, file.content, cloudSyncPathKey(file.path) === expectedKey ? input.expected_sha256 : null)
@@ -412,6 +457,7 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
       for (const createdPath of newPaths.reverse()) {
         await fs.rm(this.resolve(createdPath), { force: true }).catch(() => undefined)
       }
+      for (const move of displaced.reverse()) await this.undoDisplacement(move).catch(() => undefined)
       throw error
     }
   }
@@ -579,8 +625,8 @@ export class DesktopCloudSyncRepository implements CloudSyncRepository {
 }
 
 function normalizedResolutionFiles(
-  files: Array<{ path: string; content: CloudSyncContent }>
-): Array<{ path: string; content: CloudSyncContent }> {
+  files: Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }>
+): Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }> {
   const normalized = files.map((file) => ({
     ...file,
     path: normalizeCloudSyncPath(file.path)
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 05fdbfe64..a797192a9 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -588,7 +588,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'Space p', action: 'Note outline', detail: 'Jump to any heading in the active note via a searchable overlay.' },
       { keys: 'Space v', action: 'Switch vault', detail: 'Open the command palette directly to the local vault switcher.' },
       { keys: 'Space a', action: 'Open workflows', detail: 'Open the Workflows view, where saved pipelines over your notes are built and run. Workflows are off by default; turn them on under Settings → Workflows first.' },
-      { keys: 'Space r', action: 'Review Cloud conflicts', detail: 'Open whatever Cloud sync is waiting on: the queue of files two devices changed at once, one decision at a time, or the vault settings question, which lists each setting that differs with this device’s value beside the cloud’s and lets you pick a side per setting. When the open note is one of the waiting files, the queue starts on it. A waiting note also says so across its top, in Edit and Preview alike: sync is paused for it until you choose what to keep, and its Review button opens the queue on it. A notification with Review appears once when a new conflict arrives. When the Cloud vault this vault syncs with is deleted, on this device, another device or the website, the status bar says Cloud vault deleted and the binding opens Settings → Cloud instead, where This vault says what happened until you choose a cloud vault, start a new one, or dismiss the notice. If another device moved it into an end-to-end encrypted vault, the status bar says Cloud vault now encrypted instead, and This vault asks you to unlock this device if needed, then choose the encrypted vault. The binding and the command palette entry appear only while something is waiting, and open the same place as Review in the status bar.' },
+      { keys: 'Space r', action: 'Review Cloud conflicts', detail: 'Open whatever Cloud sync is waiting on: the queue of files two devices changed at once, one decision at a time, or the vault settings question, which lists each setting that differs with this device’s value beside the cloud’s and lets you pick a side per setting. When the open note is one of the waiting files, the queue starts on it. A waiting note also says so across its top, in Edit and Preview alike: sync is paused for it until you choose what to keep, and its Review button opens the queue on it. Choosing the other device’s version puts the file where that device left it; when this device already has a different file there, that file moves beside it under the next free name, such as Untitled 2.md. A notification with Review appears once when a new conflict arrives. When the Cloud vault this vault syncs with is deleted, on this device, another device or the website, the status bar says Cloud vault deleted and the binding opens Settings → Cloud instead, where This vault says what happened until you choose a cloud vault, start a new one, or dismiss the notice. If another device moved it into an end-to-end encrypted vault, the status bar says Cloud vault now encrypted instead, and This vault asks you to unlock this device if needed, then choose the encrypted vault. The binding and the command palette entry appear only while something is waiting, and open the same place as Review in the status bar.' },
       { keys: 'Space g', action: 'Open atlas', detail: 'Open the Atlas view: the whole vault drawn as a map of notes and links.' },
       { keys: 'Space q', action: 'Quick capture window', detail: 'Open the floating, always-on-top capture window, same as the global hotkey.' },
       { keys: 'Space b', action: 'Hide to tray', detail: 'With Settings → Appearance → Keep running in the tray on, hide this window. ZenNotes keeps running, Cloud sync and the Quick capture hotkey keep working, and the tray icon brings the window back. Hide Window to Tray in the command palette does the same.' },
diff --git a/packages/shared-domain/src/cloud-sync-bootstrap.test.ts b/packages/shared-domain/src/cloud-sync-bootstrap.test.ts
index b8dddda50..43d597e05 100644
--- a/packages/shared-domain/src/cloud-sync-bootstrap.test.ts
+++ b/packages/shared-domain/src/cloud-sync-bootstrap.test.ts
@@ -873,7 +873,7 @@ describe('metadata-first Cloud bootstrap', () => {
     expect(f.revision).toHaveBeenCalledExactlyOnceWith('vault', 'item-1', 2)
     expect(written).toHaveBeenCalledWith(
       expect.objectContaining({
-        files: [{ path: 'large.bin', content: cloud[1].content }]
+        files: [{ path: 'large.bin', content: cloud[1].content, displace_existing: true }]
       })
     )
     expect(Object.keys(f.state()?.pending_conflicts ?? {})).toEqual(['item-0'])
diff --git a/packages/shared-domain/src/cloud-sync-coordinator.test.ts b/packages/shared-domain/src/cloud-sync-coordinator.test.ts
index 6a4a09760..792a111e7 100644
--- a/packages/shared-domain/src/cloud-sync-coordinator.test.ts
+++ b/packages/shared-domain/src/cloud-sync-coordinator.test.ts
@@ -2632,7 +2632,7 @@ describe('CloudSyncCoordinator: decisions on queued conflicts', () => {
       expected_cloud_revision: 2
     })
 
-    expect(written).toEqual([{ path, content: expect.objectContaining({ data: cloudText }) }])
+    expect(written).toEqual([{ path, content: expect.objectContaining({ data: cloudText }), displace_existing: true }])
   })
 
   it('uploads a large local file from disk without rewriting it as empty', async () => {
@@ -3053,3 +3053,147 @@ describe('CloudSyncCoordinator: a cursor older than the change log (CURSOR_EXPIR
     expect(states.current?.cursor).toBe(40)
   })
 })
+
+describe('CloudSyncCoordinator: a file that only passed through this device (Dave, 2026-10-23)', () => {
+  const note = 'inbox/Daily Notes/Untitled.md'
+  const trashed = 'trash/Daily Notes/Untitled.md'
+  const second = 'trash/Daily Notes/Untitled 2.md'
+
+  function manifestItem(itemId: string, itemPath: string, revision: number, data: string) {
+    const content = realContent(data)
+    return {
+      item_id: itemId, path: itemPath, kind: 'text' as const, revision,
+      sha256: content.sha256, byte_length: content.byte_length, media_type: content.media_type, content
+    }
+  }
+
+  // While this device's sync was stuck it edited Untitled.md; the computer
+  // trashed it, made a new Untitled.md at the same path and trashed that too.
+  function computerChurn() {
+    return {
+      changes: [
+        { sequence: 2, item_id: 'plan', type: 'move' as const, path: trashed, previous_path: note, revision: 2 },
+        upsert(3, 'second', note, 'second note'),
+        { sequence: 4, item_id: 'second', type: 'move' as const, path: second, previous_path: note, revision: 4 }
+      ],
+      manifest: {
+        data: [manifestItem('plan', trashed, 2, 'agreed'), manifestItem('second', second, 4, 'second note')],
+        cursor: 4,
+        next_page: null
+      }
+    }
+  }
+
+  function storedPhantom(): CloudSyncStoredConflict {
+    return {
+      id: 'second', item_id: 'second', kind: 'move', sequence: 4,
+      base: { path: null, revision: null, kind: 'text', content: null },
+      local: { path: note, revision: null, kind: 'text', content: realContent('edited here') },
+      cloud: { path: second, revision: 4, kind: 'text', content: realContent('second note') }
+    }
+  }
+
+  it('lands the computer\'s second note in the trash instead of queuing it against this device\'s note', async () => {
+    const fs = memoryFileSystem({ [note]: 'edited here' })
+    const states = memoryState({ version: 1, vault_id: 'vault-1', cursor: 1, items: { plan: tracked('plan', note, 1, 'agreed') } })
+    const server = remote(computerChurn())
+
+    const result = await new CloudSyncCoordinator('vault-1', server, new PortableCloudSyncRepository(fs), states, ids()).sync()
+
+    expect(result.pendingConflicts).toEqual([
+      expect.objectContaining({ id: 'plan', kind: 'move', path: note, cloud_path: trashed })
+    ])
+    expect(fs.files.get(note)).toBe('edited here')
+    expect(fs.files.get(second)).toBe('second note')
+    expect(states.current?.items.second).toMatchObject({ path: second, revision: 4 })
+    expect(server.mutations).toEqual([])
+  })
+
+  it('settles a queued conflict an earlier version left on this device\'s note', async () => {
+    const fs = memoryFileSystem({ [note]: 'edited here' })
+    const states = memoryState({
+      version: 1, vault_id: 'vault-1', cursor: 4,
+      items: { plan: tracked('plan', trashed, 2, 'agreed'), second: tracked('second', second, 4, 'second note') },
+      pending_conflicts: { second: storedPhantom() }
+    })
+    const server = remote({ manifest: computerChurn().manifest })
+
+    const result = await new CloudSyncCoordinator('vault-1', server, new PortableCloudSyncRepository(fs), states, ids()).sync()
+
+    expect(result.pendingConflicts).toEqual([])
+    expect(fs.files.get(note)).toBe('edited here')
+    expect(fs.files.get(second)).toBe('second note')
+  })
+
+  for (const choice of ['local', 'cloud'] as const) {
+    it(`never deletes this device's note when "${choice}" is chosen on such a conflict`, async () => {
+      const fs = memoryFileSystem({ [note]: 'edited here' })
+      const states = memoryState({
+        version: 1, vault_id: 'vault-1', cursor: 4,
+        items: { second: tracked('second', second, 4, 'second note') },
+        pending_conflicts: { second: storedPhantom() }
+      })
+      const server = remote({ manifest: computerChurn().manifest })
+      const coordinator = new CloudSyncCoordinator('vault-1', server, new PortableCloudSyncRepository(fs), states, ids())
+
+      await coordinator.resolveConflict({
+        conflict_id: 'second', choice,
+        expected_local_sha256: realContent('edited here').sha256, expected_cloud_revision: 4
+      })
+
+      expect(fs.files.get(note)).toBe('edited here')
+      expect(fs.files.get(second)).toBe('second note')
+      expect(states.current?.pending_conflicts?.second).toBeUndefined()
+      expect(server.mutations).toEqual([])
+    })
+  }
+
+  it('moves this device\'s own trashed note aside when the computer\'s version is chosen', async () => {
+    const fs = memoryFileSystem({ [note]: 'edited here', [trashed]: 'the phone\'s own scratch' })
+    const states = memoryState({ version: 1, vault_id: 'vault-1', cursor: 1, items: { plan: tracked('plan', note, 1, 'agreed') } })
+    const churn = computerChurn()
+    const server = remote({
+      changes: [churn.changes[0]],
+      manifest: { data: [manifestItem('plan', trashed, 2, 'agreed')], cursor: 2, next_page: null }
+    })
+    const coordinator = new CloudSyncCoordinator('vault-1', server, new PortableCloudSyncRepository(fs), states, ids())
+    await coordinator.sync()
+    const details = await coordinator.getConflict('plan')
+
+    await coordinator.resolveConflict({
+      conflict_id: 'plan', choice: 'cloud',
+      expected_local_sha256: details.local.sha256, expected_cloud_revision: 2
+    })
+
+    expect(fs.files.get(trashed)).toBe('agreed')
+    expect(fs.files.get(second)).toBe('the phone\'s own scratch')
+    expect(fs.files.has(note)).toBe(false)
+  })
+
+  it('says another Cloud file holds the name instead of "changed again"', async () => {
+    const fs = memoryFileSystem({ [note]: 'edited here' })
+    const states = memoryState({ version: 1, vault_id: 'vault-1', cursor: 1, items: { plan: tracked('plan', note, 1, 'agreed') } })
+    const churn = computerChurn()
+    const server = remote({
+      changes: [churn.changes[0]],
+      manifest: { data: [manifestItem('plan', trashed, 2, 'agreed')], cursor: 2, next_page: null },
+      mutate: (body) => ({
+        acknowledged: [],
+        conflicts: body.mutations.map((mutation) => ({
+          operation_id: mutation.operation_id, item_id: mutation.item_id,
+          code: 'PATH_CONFLICT' as const, current_revision: null, current_path: note
+        })),
+        cursor: 2
+      })
+    })
+    const coordinator = new CloudSyncCoordinator('vault-1', server, new PortableCloudSyncRepository(fs), states, ids())
+    await coordinator.sync()
+    const details = await coordinator.getConflict('plan')
+
+    await expect(coordinator.resolveConflict({
+      conflict_id: 'plan', choice: 'local',
+      expected_local_sha256: details.local.sha256, expected_cloud_revision: 2
+    })).rejects.toThrow(`Another file in Cloud already uses “${note}”`)
+    expect(fs.files.get(note)).toBe('edited here')
+  })
+})
diff --git a/packages/shared-domain/src/cloud-sync-coordinator.ts b/packages/shared-domain/src/cloud-sync-coordinator.ts
index 44d735c0a..cc5db432a 100644
--- a/packages/shared-domain/src/cloud-sync-coordinator.ts
+++ b/packages/shared-domain/src/cloud-sync-coordinator.ts
@@ -51,6 +51,8 @@ const CONFLICT_SETTLED =
 /** The other side moved on while the person was choosing. */
 const CONFLICT_CHANGED_AGAIN =
   'The file changed again on another device while you were reviewing it. Choose Sync now to load the newest version, then choose again.'
+const pathTakenInCloud = (path: string) =>
+  `Another file in Cloud already uses “${path}”, so this version cannot be saved there. Choose the other version, or save this one under a different name.`
 const CHOICE_UNCONFIRMED = "ZenNotes Cloud didn't confirm your choice, so nothing changed yet. Try again."
 const NEEDS_UPDATE = "This version of ZenNotes can't do that yet. Update ZenNotes, then try again."
 
@@ -127,13 +129,17 @@ export interface CloudSyncRepository {
   }): Promise<void>
   /** Materialize the complete local result of a decision without overwriting
    * an unrelated destination. The expected file is removed only after all
-   * replacement files have been written successfully. */
+   * replacement files have been written successfully. A file marked
+   * `displace_existing` is the other device's version going where that device
+   * put it: a different file of this device already there moves to the next
+   * free name beside it (`cloudSyncFreePath`) instead of blocking the choice. */
   applyConflictResolutionFiles?(input: {
     expected_path: string | null
     expected_sha256: string | null
     files: Array<{
       path: string
       content: CloudSyncContent
+      displace_existing?: boolean
     }>
   }): Promise<void>
   /** Apply the local filesystem half of an explicit first-sync decision. */
@@ -237,6 +243,16 @@ export class CloudSyncCoordinator {
     const state = await this.requireState()
     const stored = state.pending_conflicts?.[resolution.conflict_id]
     if (!stored) throw new Error(CONFLICT_SETTLED)
+    if (movedArrival(stored)) {
+      // Neither version is this device's: the file only met one of this
+      // device's own files on its way in. Whichever is chosen, it lands where
+      // Cloud keeps it and that file stays as it is.
+      const settled = await this.settleMovedArrivals(state, [], stored.id)
+      if (!settled.state.pending_conflicts?.[stored.id]) {
+        await this.states.save(settled.state)
+        return
+      }
+    }
     const local = await this.currentLocalSnapshot(stored)
     if ((local.content?.sha256 ?? null) !== resolution.expected_local_sha256) {
       throw new Error(
@@ -336,7 +352,11 @@ export class CloudSyncCoordinator {
     const response = await this.remote.mutate(this.vaultId, request)
     const conflict = response.conflicts.find((item) => item.operation_id === operationId)
     if (conflict) {
-      throw new Error(CONFLICT_CHANGED_AGAIN)
+      // A different Cloud file holding the destination is not a newer edit
+      // of this one: "choose again" would only ever fail the same way.
+      throw new Error(conflict.code === 'PATH_CONFLICT' && mutation.type !== 'delete'
+        ? pathTakenInCloud(mutation.path)
+        : CONFLICT_CHANGED_AGAIN)
     }
     if (!response.acknowledged.some((item) => item.operation_id === operationId)) {
       throw new Error(CHOICE_UNCONFIRMED)
@@ -488,6 +508,12 @@ export class CloudSyncCoordinator {
     state = initialPull.state
     pulled += initialPull.pulled
     localConflicts.push(...initialPull.localConflicts)
+    const settled = await this.settleMovedArrivals(state, localConflicts)
+    if (settled.state !== state) {
+      state = settled.state
+      pulled += settled.pulled
+      await this.states.save(state)
+    }
 
     let localItems = await this.repository.scan()
     const repositoryPendingPaths = (await this.repository.pendingConflictPaths?.()) ?? []
@@ -950,6 +976,44 @@ export class CloudSyncCoordinator {
     return state
   }
 
+  /**
+   * A file new to this device that met one of this device's own files on its
+   * way in was queued as a conflict at that path, and the queue kept it after
+   * Cloud moved the file on. Dave's phone (2026-10-23): its sync was stuck
+   * while the computer made an Untitled.md and trashed it, so the phone's own
+   * edited Untitled.md was claimed by two conflicts. Keeping this device's
+   * version for the second was refused as "changed again", and taking the
+   * other device's deleted the phone's note, which was never that file's.
+   * Once nothing collides, the file lands where Cloud keeps it, as any new
+   * file would, and leaves this device's file alone; a deleted one just
+   * leaves the queue. Landing on another of this device's files queues a
+   * conflict there, at the path where the two really meet.
+   */
+  private async settleMovedArrivals(
+    state: CloudSyncState,
+    localConflicts: CloudSyncLocalConflict[],
+    onlyId?: string
+  ): Promise<{ state: CloudSyncState; pulled: number }> {
+    const waiting = Object.values(state.pending_conflicts ?? {}).filter(
+      (conflict) => (onlyId === undefined || conflict.id === onlyId) && movedArrival(conflict)
+    )
+    if (waiting.length === 0) return { state, pulled: 0 }
+    const manifest = await this.stableManifest(false)
+    let pulled = 0
+    for (const conflict of waiting) {
+      const item = manifest.items.find((entry) => entry.item_id === conflict.item_id)
+      if (item && conflict.local.path !== null &&
+          cloudSyncPathKey(item.path) === cloudSyncPathKey(conflict.local.path)) continue
+      state = withoutConflict(state, conflict.id)
+      if (!item) continue
+      const change = manifestUpsert(await this.hydrateManifestItem(item), manifest.cursor)
+      state = await this.landRemoteChange(state, change, undefined, localConflicts)
+      state = { ...state, items: { ...state.items, [item.item_id]: trackedManifestItem(item) } }
+      pulled++
+    }
+    return { state, pulled }
+  }
+
   private async retryPendingMerges(
     initialState: CloudSyncState,
     localItems: CloudSyncLocalItem[],
@@ -1209,7 +1273,7 @@ export class CloudSyncCoordinator {
         expected_sha256: local.content?.sha256 ?? null,
         files:
           conflict.cloud.path && conflict.cloud.content
-            ? [{ path: conflict.cloud.path, content: conflict.cloud.content }]
+            ? [{ path: conflict.cloud.path, content: conflict.cloud.content, displace_existing: true }]
             : []
       })
       return
@@ -1240,7 +1304,7 @@ export class CloudSyncCoordinator {
         expected_path: local.path,
         expected_sha256: local.content.sha256,
         files: [
-          { path: conflict.cloud.path, content: conflict.cloud.content },
+          { path: conflict.cloud.path, content: conflict.cloud.content, displace_existing: true },
           { path: keepBothPath, content: local.content }
         ]
       })
@@ -1935,6 +1999,18 @@ function withConflict(state: CloudSyncState, conflict: CloudSyncStoredConflict):
   return { ...state, pending_conflicts: { ...state.pending_conflicts, [conflict.id]: conflict } }
 }
 
+/**
+ * A conflict for a file this device never had (no base) whose Cloud copy no
+ * longer sits on the local file it met: Cloud moved or deleted it since.
+ * See settleMovedArrivals.
+ */
+function movedArrival(conflict: CloudSyncStoredConflict): boolean {
+  if (conflict.base.path !== null || conflict.base.revision !== null) return false
+  if (conflict.cloud.path === null) return true
+  return conflict.local.path !== null &&
+    cloudSyncPathKey(conflict.cloud.path) !== cloudSyncPathKey(conflict.local.path)
+}
+
 function withoutConflict(state: CloudSyncState, conflictId: string): CloudSyncState {
   const pending = { ...state.pending_conflicts }
   delete pending[conflictId]
diff --git a/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts b/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts
index 4d7ef0e9f..f0b63a9f1 100644
--- a/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts
+++ b/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts
@@ -463,6 +463,42 @@ describe('PortableCloudSyncRepository', () => {
     expect(fs.text('blocked/Plan.md')).toBeNull()
   })
 
+  it('moves a different file of this device aside for the other device\'s version', async () => {
+    // Dave's phone: the computer trashed the note the phone edited, and the
+    // phone had trashed an Untitled.md of its own into the same slot.
+    const edited = await textContent('edited on the phone')
+    const cloud = await textContent('written on the computer')
+    const fs = new MemoryFileSystem({
+      'inbox/Daily Notes/Untitled.md': 'edited on the phone',
+      'trash/Daily Notes/Untitled.md': 'the phone\'s own scratch',
+      'trash/Daily Notes/Untitled 2.md': 'already the second one'
+    })
+    await new PortableCloudSyncRepository(fs).applyConflictResolutionFiles({
+      expected_path: 'inbox/Daily Notes/Untitled.md',
+      expected_sha256: edited.sha256,
+      files: [{ path: 'trash/Daily Notes/Untitled.md', content: cloud, displace_existing: true }]
+    })
+    expect(fs.text('trash/Daily Notes/Untitled.md')).toBe('written on the computer')
+    expect(fs.text('trash/Daily Notes/Untitled 3.md')).toBe('the phone\'s own scratch')
+    expect(fs.text('trash/Daily Notes/Untitled 2.md')).toBe('already the second one')
+    expect(fs.text('inbox/Daily Notes/Untitled.md')).toBeNull()
+  })
+
+  it('moves this device\'s file back when the other device\'s version cannot be written', async () => {
+    const edited = await textContent('edited')
+    const fs = new FailingMemoryFileSystem({ 'inbox/a.md': 'edited', 'trash/a.md': 'scratch' }, 'trash/a.md')
+    await expect(
+      new PortableCloudSyncRepository(fs).applyConflictResolutionFiles({
+        expected_path: 'inbox/a.md',
+        expected_sha256: edited.sha256,
+        files: [{ path: 'trash/a.md', content: await textContent('cloud'), displace_existing: true }]
+      })
+    ).rejects.toThrow('Cannot write trash/a.md')
+    expect(fs.text('trash/a.md')).toBe('scratch')
+    expect(fs.text('trash/a 2.md')).toBeNull()
+    expect(fs.text('inbox/a.md')).toBe('edited')
+  })
+
   it('reports a parked settings choice until its cloud copy is removed', async () => {
     const fs = new MemoryFileSystem({
       '.zennotes/vault.json': '{"favorites":["local.md"]}'
diff --git a/packages/shared-domain/src/cloud-sync-portable-filesystem.ts b/packages/shared-domain/src/cloud-sync-portable-filesystem.ts
index 952ebf33f..6838756cd 100644
--- a/packages/shared-domain/src/cloud-sync-portable-filesystem.ts
+++ b/packages/shared-domain/src/cloud-sync-portable-filesystem.ts
@@ -6,6 +6,7 @@ import type {
 import {
   CLOUD_SYNC_SETTINGS_CONFLICT_PATH,
   CLOUD_SYNC_VAULT_SETTINGS_PATH,
+  cloudSyncFreePath,
   cloudSyncPathKey,
   isCloudSyncVaultSettingsPath,
   normalizeCloudSyncPath,
@@ -305,7 +306,7 @@ export class PortableCloudSyncRepository implements CloudSyncRepository {
   async applyConflictResolutionFiles(input: {
     expected_path: string | null
     expected_sha256: string | null
-    files: Array<{ path: string; content: CloudSyncContent }>
+    files: Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }>
   }): Promise<void> {
     const expectedPath = input.expected_path ? this.path(input.expected_path) : null
     const current = expectedPath ? await this.readItemOrNull(expectedPath) : null
@@ -319,11 +320,19 @@ export class PortableCloudSyncRepository implements CloudSyncRepository {
     // Validate every source before creating a copy or replacing the original.
     for (const file of files) await this.validateContent(file.content)
     const expectedKey = expectedPath ? cloudSyncPathKey(expectedPath) : null
+    const reserved = new Set(files.map((file) => cloudSyncPathKey(file.path)))
+    const displacements: Array<{ from: string; to: string }> = []
     for (const file of files) {
       if (cloudSyncPathKey(file.path) === expectedKey) continue
-      if ((await this.fs.stat(file.path)) !== null) {
+      const occupant = await this.fs.stat(file.path)
+      if (occupant === null) continue
+      if (!file.displace_existing || occupant !== 'file') {
         throw new Error(`A file named “${file.path}” already exists. Choose another name.`)
       }
+      const to = await cloudSyncFreePath(file.path, async (candidate) =>
+        reserved.has(cloudSyncPathKey(candidate)) || (await this.fs.stat(candidate)) !== null)
+      reserved.add(cloudSyncPathKey(to))
+      displacements.push({ from: file.path, to })
     }
 
     const ordered = [...files].sort((left, right) =>
@@ -334,8 +343,13 @@ export class PortableCloudSyncRepository implements CloudSyncRepository {
           : 0
     )
     const newPaths: string[] = []
+    const displaced: Array<{ from: string; to: string }> = []
     let replacingExpected = false
     try {
+      for (const move of displacements) {
+        await this.fs.rename(move.from, move.to)
+        displaced.push(move)
+      }
       for (const file of ordered) {
         if (cloudSyncPathKey(file.path) === expectedKey) replacingExpected = true
         else newPaths.push(file.path)
@@ -352,6 +366,9 @@ export class PortableCloudSyncRepository implements CloudSyncRepository {
         if (current) await this.write(expectedPath, current.content).catch(() => undefined)
         else await this.fs.deleteFile(expectedPath).catch(() => undefined)
       }
+      for (const move of displaced.reverse()) {
+        await this.fs.rename(move.to, move.from).catch(() => undefined)
+      }
       throw error
     }
   }
@@ -564,8 +581,8 @@ export class PortableCloudSyncRepository implements CloudSyncRepository {
 }
 
 function normalizedResolutionFiles(
-  files: Array<{ path: string; content: CloudSyncContent }>
-): Array<{ path: string; content: CloudSyncContent }> {
+  files: Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }>
+): Array<{ path: string; content: CloudSyncContent; displace_existing?: boolean }> {
   const normalized = files.map((file) => ({
     ...file,
     path: normalizeCloudSyncPath(file.path)
diff --git a/packages/shared-domain/src/cloud-sync-resolution.test.ts b/packages/shared-domain/src/cloud-sync-resolution.test.ts
index 8fb39ef15..13bdcd151 100644
--- a/packages/shared-domain/src/cloud-sync-resolution.test.ts
+++ b/packages/shared-domain/src/cloud-sync-resolution.test.ts
@@ -161,7 +161,7 @@ describe('single-note Cloud resolution', () => {
       expect(f.mutate).not.toHaveBeenCalled()
       expect(f.write).toHaveBeenCalledWith(
         expect.objectContaining({
-          files: expect.arrayContaining([{ path: 'Note.md', content: content('cloud') }])
+          files: expect.arrayContaining([{ path: 'Note.md', content: content('cloud'), displace_existing: true }])
         })
       )
       expect(f.state().pending_conflicts).toEqual({})
diff --git a/packages/shared-domain/src/cloud-sync.ts b/packages/shared-domain/src/cloud-sync.ts
index 8e9e340f7..2b7e46c58 100644
--- a/packages/shared-domain/src/cloud-sync.ts
+++ b/packages/shared-domain/src/cloud-sync.ts
@@ -136,6 +136,30 @@ export function cloudSyncConflictCopyPath(path: string, attempt: number): string
   return `${directory}${stem} ${suffix}${extension}`
 }
 
+/**
+ * The first free name beside `path` for a file that has to make room:
+ * `Note 2.md`, then `Note 3.md`, the names the app gives a note moved into a
+ * folder that already holds one of the same name (Move to Trash, Archive).
+ * `taken` answers for this device; nothing here knows what Cloud holds.
+ */
+export async function cloudSyncFreePath(
+  path: string,
+  taken: (candidate: string) => Promise<boolean>
+): Promise<string> {
+  const normalized = normalizeCloudSyncPath(path)
+  const slash = normalized.lastIndexOf('/')
+  const directory = slash === -1 ? '' : normalized.slice(0, slash + 1)
+  const name = normalized.slice(slash + 1)
+  const dot = name.lastIndexOf('.')
+  const stem = dot > 0 ? name.slice(0, dot) : name
+  const extension = dot > 0 ? name.slice(dot) : ''
+  for (let n = 2; n <= 10_000; n++) {
+    const candidate = `${directory}${stem} ${n}${extension}`
+    if (!(await taken(candidate))) return candidate
+  }
+  throw new Error(`Every name for “${normalized}” is taken. Rename a few of those files, then try again.`)
+}
+
 /** Recognize copies created by pre-v2.44 sync without treating them as safe
  * to delete. The returned original path is only a review hint. */
 export function cloudSyncLegacyConflictOriginalPath(value: string): string | null {

From 1bf79403911d4b31a44478ea558451d7a151e694 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 14:10:30 -0500
Subject: [PATCH 04/10] Feat(tasks): choose any due date from the task menu, or
 with @ (#991)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Davi (#991) asked for a date picker under the due presets. The task menu
stopped at next week, so a day further out meant looking it up on a
calendar first and then typing `due:2026-11-04` on the line, which is the
most work on a phone.

Choose a date… now follows Due next week in the menu every task surface
shares: the Tasks list, the board, both calendars, and on the phones a
long-press on a task. It opens the month calendar typing `@date` already
opens in a note, on the task's due date or today, and a tap on a day sets
it, so it is two taps from the menu. `@` opens it on the selected task in
the list, the board and the Tasks calendar, Vim-gated like x, i, c and >,
and named in their footer hints and the manual; with Vim off the menu entry
stays. The calendar's help line now ends "Enter picks the day", which reads
right for both uses.

Picking a daily-note task's own date writes it out, so it stays when the
task moves; picking the date a task already has, or dismissing, leaves the
line alone.
---
 .../src/components/DatePickerModal.tsx        |  4 +-
 .../app-core/src/components/TasksCalendar.tsx |  8 +-
 .../app-core/src/components/TasksKanban.tsx   |  9 +-
 .../app-core/src/components/TasksView.tsx     | 14 ++-
 packages/app-core/src/lib/help.ts             |  3 +-
 .../src/lib/task-context-menu.test.ts         | 99 +++++++++++++++++++
 .../app-core/src/lib/task-context-menu.ts     | 22 ++++-
 7 files changed, 149 insertions(+), 10 deletions(-)
 create mode 100644 packages/app-core/src/lib/task-context-menu.test.ts

diff --git a/packages/app-core/src/components/DatePickerModal.tsx b/packages/app-core/src/components/DatePickerModal.tsx
index cc80c1647..43a030d21 100644
--- a/packages/app-core/src/components/DatePickerModal.tsx
+++ b/packages/app-core/src/components/DatePickerModal.tsx
@@ -102,8 +102,8 @@ export function DatePickerModal({
   }
 
   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.'
+    ? 'h j k l or arrows move, t is today. PageUp/PageDown change the month, with Shift the year. Enter picks the day.'
+    : 'Arrows move. PageUp/PageDown change the month, with Shift the year. Enter picks the day.'
 
   return (
     <Modal
diff --git a/packages/app-core/src/components/TasksCalendar.tsx b/packages/app-core/src/components/TasksCalendar.tsx
index 48f737e75..34c27ce6c 100644
--- a/packages/app-core/src/components/TasksCalendar.tsx
+++ b/packages/app-core/src/components/TasksCalendar.tsx
@@ -26,7 +26,7 @@ import { InlineMarkdown } from '../lib/inline-markdown'
 import { CloudTaskConflictIndicator } from './CloudTaskConflictIndicator'
 import { resolveWeekStartDay } from '../lib/week-start'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
-import { buildTaskMenuItems } from '../lib/task-context-menu'
+import { buildTaskMenuItems, chooseTaskDueDate } from '../lib/task-context-menu'
 import { isOverlayOrDialogOpen } from '../lib/overlay-open'
 
 interface Props {
@@ -520,6 +520,12 @@ export function TasksCalendar({
             void cancelTaskFromList(active)
             return
           }
+          // Any due date from the calendar `@date` opens (#991).
+          if (vimMode && e.key === '@') {
+            consume()
+            void chooseTaskDueDate(active)
+            return
+          }
           if (e.key === 'e') {
             consume()
             setEditingTaskId(active.id)
diff --git a/packages/app-core/src/components/TasksKanban.tsx b/packages/app-core/src/components/TasksKanban.tsx
index b87c6cd4a..4dc1af1ee 100644
--- a/packages/app-core/src/components/TasksKanban.tsx
+++ b/packages/app-core/src/components/TasksKanban.tsx
@@ -48,7 +48,7 @@ import {
 import { filterTasks } from '../lib/tasks-filter'
 import { isOverlayOrDialogOpen } from '../lib/overlay-open'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
-import { buildTaskMenuItems } from '../lib/task-context-menu'
+import { buildTaskMenuItems, chooseTaskDueDate } from '../lib/task-context-menu'
 import { ArrowUpRightIcon, PencilIcon } from './icons'
 import { InlineMarkdown } from '../lib/inline-markdown'
 import { CloudTaskConflictIndicator } from './CloudTaskConflictIndicator'
@@ -1811,6 +1811,13 @@ export function TasksKanban({ tasks, filter, today, onOpenTask, onToggleTask }:
             void cancelTaskFromList(focusedTask)
           }
           return
+        // Any due date from the calendar `@date` opens (#991).
+        case '@':
+          if (vimMode && focusedTask) {
+            consume()
+            void chooseTaskDueDate(focusedTask)
+          }
+          return
         default:
           return
       }
diff --git a/packages/app-core/src/components/TasksView.tsx b/packages/app-core/src/components/TasksView.tsx
index b51d61092..1f5c072d3 100644
--- a/packages/app-core/src/components/TasksView.tsx
+++ b/packages/app-core/src/components/TasksView.tsx
@@ -10,7 +10,7 @@ import { TasksKanban } from './TasksKanban'
 import { CalendarIcon, CheckSquareIcon, KanbanIcon, ListIcon } from './icons'
 import { advanceSequence, getKeymapBinding, matchesSequenceToken } from '../lib/keymaps'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
-import { buildTaskMenuItems } from '../lib/task-context-menu'
+import { buildTaskMenuItems, chooseTaskDueDate } from '../lib/task-context-menu'
 import { isImeComposing } from '../lib/ime'
 import { isOverlayOrDialogOpen } from '../lib/overlay-open'
 import { promptApp } from '../lib/prompt-requests'
@@ -748,6 +748,12 @@ export function TasksView(): JSX.Element {
         void startTaskFromList(currentTask)
         return
       }
+      // Any due date from the calendar `@date` opens (#991). Vim-gated single key.
+      if (vimMode && key === '@' && currentTask) {
+        consume()
+        void chooseTaskDueDate(currentTask)
+        return
+      }
     }
     window.addEventListener('keydown', handler, true)
     return () => window.removeEventListener('keydown', handler, true)
@@ -1040,14 +1046,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 · F saved filters · right-click actions · :q close'
+              ? 'j/k move · J/K reorder · Enter/o open · x toggle · i start · c cancel · @ due date · 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 · F saved filters · drag to move · right-click actions · :q'
+                ? 'h/j/k/l day · [ ] month · Tab pick · x toggle · i start · c cancel · @ due date · F saved filters · drag to move · right-click actions · :q'
                 : '←/→/↑/↓ day · Tab pick · Space toggle · drag to move · right-click actions'
               : vimMode
-                ? 'h/l column · j/k card · x toggle · i start · c cancel · Enter open · s order · F saved filters · right-click actions · :q close'
+                ? 'h/l column · j/k card · x toggle · i start · c cancel · @ due date · Enter open · s order · F saved filters · right-click actions · :q close'
                 : '←/→ column · ↑/↓ card · Space toggle · Enter open · right-click actions'}
         </div>
       )}
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index a797192a9..fc12b33fe 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -337,7 +337,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Right-click a task for actions',
     body:
-      'Every task surface has the same right-click menu: the Tasks list, the Kanban board, the Tasks calendar, and the calendar side panel. It carries Open note, Mark done, Mark in progress, Cancel, @waiting, Forward to note…, due-date presets (today / tomorrow / next week / clear), priority, and Delete, with the keyboard equivalent shown beside each one so the menu doubles as a reminder of the shortcut. Right-clicking also moves the cursor to that task, so the menu and the keyboard always act on the same row. The menu takes typing as a filter: right-click, type “prio”, and only the priority entries stay. Editing a task inline is offered on the calendar surfaces, which have an edit field; elsewhere “Open note” takes you to the line.'
+      'Every task surface has the same right-click menu: the Tasks list, the Kanban board, the Tasks calendar, and the calendar side panel. It carries Open note, Mark done, Mark in progress, Cancel, @waiting, Forward to note…, due-date presets (today / tomorrow / next week / clear) with Choose a date… for any other day, priority, and Delete, with the keyboard equivalent shown beside each one so the menu doubles as a reminder of the shortcut. Right-clicking also moves the cursor to that task, so the menu and the keyboard always act on the same row. The menu takes typing as a filter: right-click, type “prio”, and only the priority entries stay. Editing a task inline is offered on the calendar surfaces, which have an edit field; elsewhere “Open note” takes you to the line.'
   },
   {
     title: 'Mark a task in progress',
@@ -703,6 +703,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: '>', action: 'Forward task', detail: 'Tasks list only: forward the selected task to another note. Opens a note picker that filters as you type and preselects the first match, so Enter forwards without reaching for an arrow key. The original becomes a forwarded record (`[>]`) linking to the target, and a fresh copy is added there, backlinked home, subtasks and all. Forwarded tasks live under a “Forwarded” group.' },
       { keys: 'i', action: 'Mark task in progress', detail: 'Tasks list only: mark the selected task as started (`- [/]`), or set it back to open. In-progress tasks stay in Today and on the calendar, so the row keeps its place.' },
       { keys: 'c', action: 'Cancel task', detail: 'Tasks list only: mark the selected task as intentionally abandoned (`- [-]`), or un-cancel it. Cancelled tasks live under a “Cancelled” group, out of Today and Done.' },
+      { keys: '@', action: 'Choose due date', detail: 'Tasks list, board, and calendar: give the selected task any due date from the month calendar that typing `@date` opens in a note, the same as Choose a date… in its right-click menu. It starts on the task’s due date (today without one); arrows move, Enter sets the day, or type a date.' },
       { keys: 'K / J', action: 'Move task up / down', detail: 'Tasks list only: reorder the selected task within its group. Works with Vim mode on or off.' },
       { 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.' },
diff --git a/packages/app-core/src/lib/task-context-menu.test.ts b/packages/app-core/src/lib/task-context-menu.test.ts
new file mode 100644
index 000000000..4afd3984e
--- /dev/null
+++ b/packages/app-core/src/lib/task-context-menu.test.ts
@@ -0,0 +1,99 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { VaultTask } from '@shared/tasks'
+import { useStore } from '../store'
+import { buildTaskMenuItems, chooseTaskDueDate } from './task-context-menu'
+
+const promptMocks = vi.hoisted(() => ({
+  promptDate: vi.fn<(options?: unknown) => Promise<string | null>>()
+}))
+
+vi.mock('./date-prompt-requests', () => ({
+  promptDate: promptMocks.promptDate
+}))
+
+const today = new Date(2026, 9, 23)
+
+function task(fields: Partial<VaultTask> = {}): VaultTask {
+  return {
+    id: 'inbox/Plan.md:3',
+    path: 'inbox/Plan.md',
+    line: 3,
+    content: 'Book museum tickets',
+    rawText: '- [ ] Book museum tickets',
+    checked: false,
+    forwarded: false,
+    cancelled: false,
+    inProgress: false,
+    waiting: false,
+    tags: [],
+    ...fields
+  } as VaultTask
+}
+
+describe('Choose a date… in the task menu (#991)', () => {
+  let originalState: ReturnType<typeof useStore.getState>
+  const applyTaskMutation = vi.fn(async () => {})
+
+  beforeEach(() => {
+    originalState = useStore.getState()
+    useStore.setState({ applyTaskMutation } as Partial<ReturnType<typeof useStore.getState>>)
+    promptMocks.promptDate.mockReset()
+    applyTaskMutation.mockClear()
+  })
+
+  afterEach(() => {
+    useStore.setState(originalState, true)
+  })
+
+  it('follows the due presets, naming @ only where the key works', () => {
+    const labels = buildTaskMenuItems(task(), { today }).map((item) => ('label' in item ? item.label : '-'))
+    expect(labels.slice(labels.indexOf('Due today'), labels.indexOf('Due today') + 4)).toEqual([
+      'Due today',
+      'Due tomorrow',
+      'Due next week',
+      'Choose a date…'
+    ])
+    const entry = (hints: boolean) =>
+      buildTaskMenuItems(task(), { today, showKeyHints: hints }).find(
+        (item) => 'label' in item && item.label === 'Choose a date…'
+      )
+    expect(entry(true)).toMatchObject({ hint: '@' })
+    expect(entry(false)).toMatchObject({ hint: undefined })
+  })
+
+  it('opens on the task\'s due date and writes the picked day', async () => {
+    promptMocks.promptDate.mockResolvedValueOnce('2026-11-04')
+    const planned = task({ due: '2026-10-30' })
+
+    await chooseTaskDueDate(planned, today)
+
+    expect(promptMocks.promptDate).toHaveBeenCalledWith({
+      title: 'Due date',
+      description: 'Book museum tickets',
+      initialDate: '2026-10-30',
+      okLabel: 'Set due date'
+    })
+    expect(applyTaskMutation).toHaveBeenCalledWith(planned, { kind: 'set-due', due: '2026-11-04' })
+  })
+
+  it('starts on today without a due date, and leaves the line alone when nothing changes', async () => {
+    promptMocks.promptDate.mockResolvedValueOnce(null)
+    await chooseTaskDueDate(task(), today)
+    expect(promptMocks.promptDate).toHaveBeenCalledWith(expect.objectContaining({ initialDate: '2026-10-23' }))
+
+    promptMocks.promptDate.mockResolvedValueOnce('2026-10-30')
+    await chooseTaskDueDate(task({ due: '2026-10-30' }), today)
+    expect(applyTaskMutation).not.toHaveBeenCalled()
+  })
+
+  it('writes the day of a daily-note task even when it matches the inferred date', async () => {
+    // The inferred date comes from the note the task sits in; picking it makes
+    // it the task's own, so it stays when the task moves.
+    promptMocks.promptDate.mockResolvedValueOnce('2026-10-23')
+    const daily = task({ due: '2026-10-23', dueInferred: true })
+
+    await chooseTaskDueDate(daily, today)
+
+    expect(applyTaskMutation).toHaveBeenCalledWith(daily, { kind: 'set-due', due: '2026-10-23' })
+  })
+})
diff --git a/packages/app-core/src/lib/task-context-menu.ts b/packages/app-core/src/lib/task-context-menu.ts
index fb7b1028d..9e23136bb 100644
--- a/packages/app-core/src/lib/task-context-menu.ts
+++ b/packages/app-core/src/lib/task-context-menu.ts
@@ -2,6 +2,7 @@ import type { VaultTask } from '@shared/tasks'
 import { toIsoDateLocal } from '@shared/tasks'
 import type { ContextMenuItem } from '../components/ContextMenu'
 import { useStore } from '../store'
+import { promptDate } from './date-prompt-requests'
 import { forwardTaskWithPicker } from './forward-task'
 
 /**
@@ -40,6 +41,24 @@ function addDaysIso(today: Date, n: number): string {
   return toIsoDateLocal(new Date(today.getFullYear(), today.getMonth(), today.getDate() + n))
 }
 
+/**
+ * Any due date from a month calendar (#991). The presets stop at next week, and
+ * a day further out meant looking it up first, then typing `due:` on the line,
+ * which is the most work on a phone. The calendar is the one `@date` opens in a
+ * note, so it starts on the task's due date (today without one) and takes a
+ * tap, arrows or a typed date. Behind the menu entry and the `@` key alike.
+ */
+export async function chooseTaskDueDate(task: VaultTask, today: Date = new Date()): Promise<void> {
+  const iso = await promptDate({
+    title: 'Due date',
+    description: task.content,
+    initialDate: task.due ?? toIsoDateLocal(today),
+    okLabel: 'Set due date'
+  })
+  if (!iso || (iso === task.due && !task.dueInferred)) return
+  await useStore.getState().applyTaskMutation(task, { kind: 'set-due', due: iso })
+}
+
 export function buildTaskMenuItems(
   task: VaultTask,
   options: TaskMenuOptions = {}
@@ -96,7 +115,8 @@ export function buildTaskMenuItems(
       label: 'Due next week',
       hint: dueIn(7),
       onSelect: () => mutate({ kind: 'set-due', due: dueIn(7) })
-    }
+    },
+    { label: 'Choose a date…', hint: key('@'), onSelect: () => void chooseTaskDueDate(task, today) }
   )
   // An inferred due date comes from the daily note the task lives in, not from a
   // `due:` token, so there is nothing on the line to clear.

From 032e5da2082757c133363e580767f5cc812bf133 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 14:37:39 -0500
Subject: [PATCH 05/10] Fix(tasks): a task with no due date waits under No due
 date, not Today (#990)

Davi (#990) made a task with + New task and found it under Today: it had
no due date, only the dateCreated New task writes, and the "No due date"
he went looking for did not exist. The grouping has filed every undated
open task under Today since the first Tasks view, so Today mixed what is
due with what has no date at all, and Home's Today did the same.

Undated tasks now have their own group in the shared grouping. The Tasks
list shows No due date after Upcoming; the Kanban status board gets a No
due date column between Upcoming and In progress, and dropping a card there
reopens it and clears its `due:`; Home's Today keeps only what is due today
or overdue. A saved column order from before slots the new column after
Upcoming.

The daily-note workflow keeps its tasks in Today. A task in a daily note is
due on the note's date wherever "Tasks are due on the note's date" is on,
which the Tasks views already applied; Home and getTodayTasks now apply it
too, so their Today and overdue count match the list. Such a task's date is
its note's, not a `due:` on the line, so the board refuses to drop it on No
due date rather than let it bounce back, as the menu offers no Clear due
date for it. The setting's description now says where it applies.

The zn terminal app mirrors the rule on its own branch.
---
 packages/app-core/src/components/HomeView.tsx | 12 +++--
 .../app-core/src/components/SettingsModal.tsx |  2 +-
 .../src/components/TasksKanban.test.ts        | 31 +++++++++++--
 .../app-core/src/components/TasksKanban.tsx   |  5 ++-
 .../app-core/src/components/TasksView.tsx     |  4 +-
 packages/app-core/src/lib/help.ts             | 10 ++---
 .../app-core/src/lib/task-column-mutations.ts | 12 +++++
 .../app-core/src/lib/tasks-filter.test.ts     |  2 +-
 packages/app-core/src/lib/tasks-filter.ts     |  6 ++-
 packages/app-core/src/tasks.ts                |  6 ++-
 .../shared-domain/src/tasks-cancelled.test.ts |  2 +-
 packages/shared-domain/src/tasks-due.test.ts  | 44 ++++++++++++++++++-
 .../shared-domain/src/tasks-forward.test.ts   |  2 +-
 .../src/tasks-in-progress.test.ts             |  7 +--
 packages/shared-domain/src/tasks.ts           | 18 ++++++--
 15 files changed, 135 insertions(+), 28 deletions(-)

diff --git a/packages/app-core/src/components/HomeView.tsx b/packages/app-core/src/components/HomeView.tsx
index c2e337920..fb88f981f 100644
--- a/packages/app-core/src/components/HomeView.tsx
+++ b/packages/app-core/src/components/HomeView.tsx
@@ -1,12 +1,13 @@
 import { useCallback, useEffect, useMemo, useRef } from 'react'
 import type { NoteMeta } from '@shared/ipc'
-import { filterTasksForDisplay, type VaultTask } from '@shared/tasks'
+import { filterTasksForDisplay, inferDailyTaskDueDates, type VaultTask } from '@shared/tasks'
 import { useStore } from '../store'
 import { computeTasksRender } from '../lib/tasks-filter'
 import { focusEditorNormalMode } from '../lib/editor-focus'
 import { InlineMarkdown } from '../lib/inline-markdown'
 import { getSystemFolderLabel } from '../lib/system-folder-labels'
 import {
+  buildDailyNoteDateByPath,
   isPrimaryNotesAtRoot,
   noteFolderSubpath,
   resolveFavoriteItems,
@@ -33,6 +34,7 @@ const MAX_TASKS = 6
 const NO_COLLAPSE = {
   today: false,
   upcoming: false,
+  undated: false,
   waiting: false,
   forwarded: false,
   done: false,
@@ -220,15 +222,19 @@ export function HomeView({
     [sidebarOpen, onShowSidebar, setView]
   )
 
+  // Today is what is due today or overdue, as in the Tasks list: a task in a
+  // daily note takes the note's date there, and an undated one waits under No
+  // due date instead (#990), so Home applies the same daily-note dates.
   const { today, overdueCount } = useMemo(() => {
+    const dueByPath = buildDailyNoteDateByPath(notes, vaultSettings)
     const render = computeTasksRender(
-      filterTasksForDisplay(vaultTasks, showArchivedTasks),
+      inferDailyTaskDueDates(filterTasksForDisplay(vaultTasks, showArchivedTasks), dueByPath),
       '',
       new Date(now),
       NO_COLLAPSE
     )
     return { today: render.groups.today, overdueCount: render.groups.overdueCount }
-  }, [vaultTasks, showArchivedTasks, now])
+  }, [vaultTasks, showArchivedTasks, now, notes, vaultSettings])
 
   const visibleTasks = today.slice(0, MAX_TASKS)
   const hiddenTaskCount = today.length - visibleTasks.length
diff --git a/packages/app-core/src/components/SettingsModal.tsx b/packages/app-core/src/components/SettingsModal.tsx
index 6f947d108..d85cc22ce 100644
--- a/packages/app-core/src/components/SettingsModal.tsx
+++ b/packages/app-core/src/components/SettingsModal.tsx
@@ -4864,7 +4864,7 @@ export function SettingsModal(): JSX.Element {
                     />
                     <ToggleRow
                       label="Tasks are due on the note's date"
-                      description="A task written inside a daily note appears on the calendar for that day automatically, without typing a due date. An explicit `due:YYYY-MM-DD` still wins."
+                      description="A task written inside a daily note is due that day automatically, in the Tasks list, board and calendar and on Home, without typing a due date. An explicit `due:YYYY-MM-DD` still wins."
                       value={
                         vaultSettings.dailyNotes.tasksDueOnNoteDate !== false
                       }
diff --git a/packages/app-core/src/components/TasksKanban.test.ts b/packages/app-core/src/components/TasksKanban.test.ts
index 447e23e7f..0755e87ac 100644
--- a/packages/app-core/src/components/TasksKanban.test.ts
+++ b/packages/app-core/src/components/TasksKanban.test.ts
@@ -281,10 +281,13 @@ describe('statusColumns (#677)', () => {
       ],
       TODAY
     )
-    expect(columns.map((c) => c.id)).toEqual(['today', 'upcoming', IN_PROGRESS_COLUMN_ID, 'waiting', 'done'])
-    expect(columnIds(columns, 'today')).toEqual(['todo'])
+    expect(columns.map((c) => c.id)).toEqual(['today', 'upcoming', 'undated', IN_PROGRESS_COLUMN_ID, 'waiting', 'done'])
+    // An undated task has its own column (#990); started, it still goes to In progress.
+    expect(columnIds(columns, 'today')).toEqual([])
+    expect(columnIds(columns, 'undated')).toEqual(['todo'])
     expect(columnIds(columns, 'upcoming')).toEqual(['later'])
-    expect(columnIds(columns, IN_PROGRESS_COLUMN_ID)).toEqual(['started', 'started later'])
+    // Started work follows the list's order: dated first, undated last.
+    expect(columnIds(columns, IN_PROGRESS_COLUMN_ID)).toEqual(['started later', 'started'])
     // @waiting wins over [/]: the card reads as blocked until the wait clears.
     expect(columnIds(columns, 'waiting')).toEqual(['blocked'])
     expect(columnIds(columns, 'done')).toEqual(['shipped'])
@@ -321,11 +324,33 @@ describe('dropMutationsFor on the Status board (#677)', () => {
   it('dropping into Waiting keeps the [/] underneath', () => {
     expect(kinds('waiting', { inProgress: true })).toEqual(['set-checked', 'set-waiting'])
   })
+
+  it('dropping into No due date clears the due date and reopens the task (#990)', () => {
+    const mutations = dropMutationsFor('status', 'undated', card({ content: 'x', due: '2026-09-01', inProgress: true }), TODAY)
+    expect(mutations).toContainEqual({ kind: 'set-due', due: null })
+    expect(mutations).toContainEqual({ kind: 'set-in-progress', inProgress: false })
+  })
+
+  it('refuses No due date for a daily-note task, whose date is its note\'s, not a due: to clear', () => {
+    expect(dropMutationsFor('status', 'undated', card({ content: 'x', due: '2026-08-15', dueInferred: true }), TODAY)).toBeNull()
+  })
 })
 
 describe('completeStatusOrder (#677)', () => {
   const built = ['today', 'upcoming', IN_PROGRESS_COLUMN_ID, 'waiting', 'done']
 
+  it('slots No due date after Upcoming in an order saved before it existed (#990)', () => {
+    const withUndated = ['today', 'upcoming', 'undated', IN_PROGRESS_COLUMN_ID, 'waiting', 'done']
+    expect(completeStatusOrder(['done', 'upcoming', 'today', IN_PROGRESS_COLUMN_ID, 'waiting'], withUndated)).toEqual([
+      'done',
+      'upcoming',
+      'undated',
+      'today',
+      IN_PROGRESS_COLUMN_ID,
+      'waiting'
+    ])
+  })
+
   it('leaves an empty saved order alone (built order applies)', () => {
     expect(completeStatusOrder([], built)).toEqual([])
   })
diff --git a/packages/app-core/src/components/TasksKanban.tsx b/packages/app-core/src/components/TasksKanban.tsx
index 4dc1af1ee..b81a46aa5 100644
--- a/packages/app-core/src/components/TasksKanban.tsx
+++ b/packages/app-core/src/components/TasksKanban.tsx
@@ -120,9 +120,10 @@ export function statusColumns(tasks: VaultTask[], today: Date): Column[] {
   // started work gets its own column between the to-do buckets and Done, and
   // a glance shows how much is in flight (#677). `@waiting` still wins: a
   // blocked card reads as blocked and comes back here when the wait clears.
-  const inProgress = [...groups.today, ...groups.upcoming].filter((t) => t.inProgress)
+  const inProgress = [...groups.today, ...groups.upcoming, ...groups.undated].filter((t) => t.inProgress)
   const today_ = groups.today.filter((t) => !t.inProgress)
   const upcoming = groups.upcoming.filter((t) => !t.inProgress)
+  const undated = groups.undated.filter((t) => !t.inProgress)
   const overdueBadge = (list: VaultTask[]): Column['badge'] => {
     const value = list.filter((t) => isTaskOverdue(t, today)).length
     return value > 0 ? { kind: 'overdue', value } : undefined
@@ -130,6 +131,8 @@ export function statusColumns(tasks: VaultTask[], today: Date): Column[] {
   return [
     { id: 'today', label: 'Today', tasks: today_, badge: overdueBadge(today_) },
     { id: 'upcoming', label: 'Upcoming', tasks: upcoming },
+    // Open work with no date (#990); dropping a card here clears its `due:`.
+    { id: 'undated', label: 'No due date', tasks: undated },
     {
       id: IN_PROGRESS_COLUMN_ID,
       label: 'In progress',
diff --git a/packages/app-core/src/components/TasksView.tsx b/packages/app-core/src/components/TasksView.tsx
index 1f5c072d3..58f59815a 100644
--- a/packages/app-core/src/components/TasksView.tsx
+++ b/packages/app-core/src/components/TasksView.tsx
@@ -17,11 +17,12 @@ 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'
+type GroupKey = 'today' | 'upcoming' | 'undated' | 'waiting' | 'forwarded' | 'done' | 'cancelled'
 
 const GROUP_LABELS: Record<GroupKey, string> = {
   today: 'Today',
   upcoming: 'Upcoming',
+  undated: 'No due date',
   waiting: 'Waiting',
   forwarded: 'Forwarded',
   done: 'Done',
@@ -102,6 +103,7 @@ export function TasksView(): JSX.Element {
   const [collapsed, setCollapsed] = useState<Record<GroupKey, boolean>>({
     today: false,
     upcoming: false,
+    undated: false,
     waiting: false,
     forwarded: true,
     done: true,
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index fc12b33fe..3d8ace546 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -267,7 +267,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'The home view is where you land',
     body:
-      'When no note is open (outside Zen mode), ZenNotes shows a light home view instead of a blank pane: a greeting, quick-create actions (new note, database, drawing, plus daily and weekly notes when those are enabled in Settings), your most recently edited notes, your Favorites, and today’s open tasks with an overdue count. The Favorites section sits right after Recent and mirrors the sidebar’s list in the same order: a favorited note opens in place, a favorited folder opens that folder in the note list (bringing the sidebar back if it was hidden), and the section stays out of the way until you favorite something. Favorite a note from the sidebar row’s context menu, `Space l s`, or the command palette’s “Add Note to Favorites” (on the phones, the same entry sits in the ••• sheet and in the long-press note menu). Click a note or task to open it, tick a checkbox to complete a task in place, and use ↑/↓ (or j/k in Vim mode) then Enter to move and open from the keyboard.'
+      'When no note is open (outside Zen mode), ZenNotes shows a light home view instead of a blank pane: a greeting, quick-create actions (new note, database, drawing, plus daily and weekly notes when those are enabled in Settings), your most recently edited notes, your Favorites, and the tasks due today or overdue, with an overdue count. The Favorites section sits right after Recent and mirrors the sidebar’s list in the same order: a favorited note opens in place, a favorited folder opens that folder in the note list (bringing the sidebar back if it was hidden), and the section stays out of the way until you favorite something. Favorite a note from the sidebar row’s context menu, `Space l s`, or the command palette’s “Add Note to Favorites” (on the phones, the same entry sits in the ••• sheet and in the long-press note menu). Click a note or task to open it, tick a checkbox to complete a task in place, and use ↑/↓ (or j/k in Vim mode) then Enter to move and open from the keyboard.'
   },
   {
     title: 'Sessions restore on relaunch',
@@ -282,7 +282,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Tasks, tags, archive, and trash are vault-wide views',
     body:
-      'Tasks scans every note for checkboxes, Tags lets you browse notes that carry all of the selected tags (toggle Match to Any for a union), Archive gives you a dedicated list of cold-storage notes, and Trash gives you a recovery surface for deleted notes without turning the left rail into a second browser. Selected tags accumulate so you can narrow across several at once; clear them with the Selected strip’s “Clear all”, the `c` key, or a right-click on any tag chip (which also offers “Unselect others” to keep just that one). A tag chip’s context menu also carries “Rename Tag…” and “Delete Tag…”, which rewrite or remove that hashtag across the whole vault. Tags work in any script (`#тест` and `#标签` are tags), while headings (`# x`) and hex colors (`#1971c2`) are not.'
+      'Tasks scans every note for checkboxes and groups the open ones by when they are due: Today (due today or overdue), Upcoming, and No due date, then Waiting, Forwarded, Done, and Cancelled. A task written in a daily note counts as due on that note’s date while “Tasks are due on the note’s date” is on (Settings → Daily notes). Tags lets you browse notes that carry all of the selected tags (toggle Match to Any for a union), Archive gives you a dedicated list of cold-storage notes, and Trash gives you a recovery surface for deleted notes without turning the left rail into a second browser. Selected tags accumulate so you can narrow across several at once; clear them with the Selected strip’s “Clear all”, the `c` key, or a right-click on any tag chip (which also offers “Unselect others” to keep just that one). A tag chip’s context menu also carries “Rename Tag…” and “Delete Tag…”, which rewrite or remove that hashtag across the whole vault. Tags work in any script (`#тест` and `#标签` are tags), while headings (`# x`) and hex colors (`#1971c2`) are not.'
   },
   {
     title: 'Archiving a note retires its tasks',
@@ -317,7 +317,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'The Tasks Kanban board, custom statuses, and any field',
     body:
-      'Switch Tasks to Kanban (the button, or `3` in Vim mode) 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. Finished and cancelled tasks leave the boards, with one exception: a task note whose `status:` names one of your Kanban statuses stays in that column on the Custom status board, so a `done` column holds the task notes you finished, still checked. 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). To have the cards follow their dates instead, set **Order** in the board\'s toolbar to Due date (`s` in Vim mode, `:order due` on the ex line, or `kanban_card_sort = "due"` under `[view]` in config.toml): every column on every board, custom status boards included, then sorts by due date, earliest first and cards without one last, and a card dropped into another column lands in its date slot. Your dragged arrangement is kept meanwhile, and Manual brings it back. On a board wider than the window, hold a dragged card or column header near the board\'s left or right edge and the board scrolls that way, faster the closer you get to the edge; a card held near the top or bottom of a long column scrolls the column. After a drop the cursor sits on the card or column you moved, so the keyboard picks up where the mouse left off. 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 (the button, or `3` in Vim mode) for a column board. "Group by" offers Status (Today / Upcoming / No due date / 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 No due date 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 (or on No due date to reopen it without one: that drop clears its `due:`, and a daily-note task, whose date is its note’s, cannot take it), 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. Finished and cancelled tasks leave the boards, with one exception: a task note whose `status:` names one of your Kanban statuses stays in that column on the Custom status board, so a `done` column holds the task notes you finished, still checked. 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). To have the cards follow their dates instead, set **Order** in the board\'s toolbar to Due date (`s` in Vim mode, `:order due` on the ex line, or `kanban_card_sort = "due"` under `[view]` in config.toml): every column on every board, custom status boards included, then sorts by due date, earliest first and cards without one last, and a card dropped into another column lands in its date slot. Your dragged arrangement is kept meanwhile, and Manual brings it back. On a board wider than the window, hold a dragged card or column header near the board\'s left or right edge and the board scrolls that way, faster the closer you get to the edge; a card held near the top or bottom of a long column scrolls the column. After a drop the cursor sits on the card or column you moved, so the keyboard picks up where the mouse left off. 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',
@@ -342,7 +342,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Mark a task in progress',
     body:
-      'A task you have started but not finished can say so: `- [/]`. Write it directly, run “Mark Task In Progress” from the command palette with the cursor on a task, or press `i` on a task in the Tasks list (press `i` again to set it back to open). It renders as a half-filled box in the editor and the reading view, and that box is clickable on both surfaces: a click checks the task off, the same `[/]` to `[x]` the toggle command performs (the forwarded and cancelled markers stay unclickable records). Moving an in-progress card between live Kanban columns keeps the `/` too. Unlike forwarded or cancelled, an in-progress task is still live work: it keeps its place in Today, stays on the calendar and the Kanban board, and rolls forward with your unfinished tasks when you roll over a daily note, `/` and all. A whole-note task file uses `status: in-progress` in its frontmatter (`doing`, `started` and `wip` are read the same way).'
+      'A task you have started but not finished can say so: `- [/]`. Write it directly, run “Mark Task In Progress” from the command palette with the cursor on a task, or press `i` on a task in the Tasks list (press `i` again to set it back to open). It renders as a half-filled box in the editor and the reading view, and that box is clickable on both surfaces: a click checks the task off, the same `[/]` to `[x]` the toggle command performs (the forwarded and cancelled markers stay unclickable records). Moving an in-progress card between live Kanban columns keeps the `/` too. Unlike forwarded or cancelled, an in-progress task is still live work: it keeps its place in Today, Upcoming, or No due date, stays on the calendar and the Kanban board, and rolls forward with your unfinished tasks when you roll over a daily note, `/` and all. A whole-note task file uses `status: in-progress` in its frontmatter (`doing`, `started` and `wip` are read the same way).'
   },
   {
     title: 'Subtask progress on the parent',
@@ -701,7 +701,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'Enter / o', action: 'Open current result', detail: 'Open the selected task source note, tagged note, or trashed note.' },
       { keys: 'x', action: 'Toggle task', detail: 'Tasks view only: check or uncheck the selected task. A checked task lingers in place for a couple of seconds before it drops into Done, so you can toggle it again to undo. Space also toggles unless Space is your Vim leader key, in which case it starts a leader sequence.' },
       { keys: '>', action: 'Forward task', detail: 'Tasks list only: forward the selected task to another note. Opens a note picker that filters as you type and preselects the first match, so Enter forwards without reaching for an arrow key. The original becomes a forwarded record (`[>]`) linking to the target, and a fresh copy is added there, backlinked home, subtasks and all. Forwarded tasks live under a “Forwarded” group.' },
-      { keys: 'i', action: 'Mark task in progress', detail: 'Tasks list only: mark the selected task as started (`- [/]`), or set it back to open. In-progress tasks stay in Today and on the calendar, so the row keeps its place.' },
+      { keys: 'i', action: 'Mark task in progress', detail: 'Tasks list only: mark the selected task as started (`- [/]`), or set it back to open. In-progress tasks keep their group and their day on the calendar, so the row keeps its place.' },
       { keys: 'c', action: 'Cancel task', detail: 'Tasks list only: mark the selected task as intentionally abandoned (`- [-]`), or un-cancel it. Cancelled tasks live under a “Cancelled” group, out of Today and Done.' },
       { keys: '@', action: 'Choose due date', detail: 'Tasks list, board, and calendar: give the selected task any due date from the month calendar that typing `@date` opens in a note, the same as Choose a date… in its right-click menu. It starts on the task’s due date (today without one); arrows move, Enter sets the day, or type a date.' },
       { keys: 'K / J', action: 'Move task up / down', detail: 'Tasks list only: reorder the selected task within its group. Works with Vim mode on or off.' },
diff --git a/packages/app-core/src/lib/task-column-mutations.ts b/packages/app-core/src/lib/task-column-mutations.ts
index d6cfde822..675030549 100644
--- a/packages/app-core/src/lib/task-column-mutations.ts
+++ b/packages/app-core/src/lib/task-column-mutations.ts
@@ -36,6 +36,18 @@ export function dropMutationsFor(
           }
         ]
       }
+      case 'undated':
+        // A daily note's date is not on the line, so there is no `due:` to
+        // clear: the card would land straight back in its day. Refuse the
+        // drop rather than pretend (#990), as the menu offers no Clear due
+        // date for such a task.
+        if (task.dueInferred) return null
+        return [
+          { kind: 'set-checked', checked: false },
+          { kind: 'set-waiting', waiting: false },
+          { kind: 'set-in-progress', inProgress: false },
+          { kind: 'set-due', due: null }
+        ]
       case 'in-progress':
         // Started work: `[/]`. The due date is left alone, so a card dragged
         // back to Today or Upcoming keeps the date it had.
diff --git a/packages/app-core/src/lib/tasks-filter.test.ts b/packages/app-core/src/lib/tasks-filter.test.ts
index 6f62274b0..e7438af0b 100644
--- a/packages/app-core/src/lib/tasks-filter.test.ts
+++ b/packages/app-core/src/lib/tasks-filter.test.ts
@@ -23,7 +23,7 @@ function task(sourcePath: string, taskIndex: number, overrides?: Partial<VaultTa
 }
 
 function groups(today: VaultTask[]): VaultTaskGroups {
-  return { today, upcoming: [], waiting: [], done: [], forwarded: [], cancelled: [], overdueCount: 0 }
+  return { today, upcoming: [], undated: [], waiting: [], done: [], forwarded: [], cancelled: [], overdueCount: 0 }
 }
 
 describe('filterTasks', () => {
diff --git a/packages/app-core/src/lib/tasks-filter.ts b/packages/app-core/src/lib/tasks-filter.ts
index 6ebaec80f..37f601b23 100644
--- a/packages/app-core/src/lib/tasks-filter.ts
+++ b/packages/app-core/src/lib/tasks-filter.ts
@@ -26,7 +26,7 @@ export function filterTasks(tasks: VaultTask[], query: string): VaultTask[] {
 export interface FlattenedTaskRow {
   kind: 'header' | 'task'
   /** Group the row belongs to — drives the collapse state for 'task' rows. */
-  group: 'today' | 'upcoming' | 'waiting' | 'forwarded' | 'done' | 'cancelled'
+  group: 'today' | 'upcoming' | 'undated' | 'waiting' | 'forwarded' | 'done' | 'cancelled'
   /** Only set when kind === 'task'. */
   task?: VaultTask
   /** Only set when kind === 'header'. */
@@ -42,6 +42,7 @@ export function flattenRows(
   collapsed: {
     today: boolean
     upcoming: boolean
+    undated: boolean
     waiting: boolean
     forwarded: boolean
     done: boolean
@@ -66,6 +67,7 @@ export function flattenRows(
   }
   push('today', groups.today, { overdueCount: groups.overdueCount })
   push('upcoming', groups.upcoming)
+  push('undated', groups.undated)
   push('waiting', groups.waiting)
   push('forwarded', groups.forwarded)
   push('done', groups.done)
@@ -96,6 +98,7 @@ export function applyFileOrder(groups: VaultTaskGroups): VaultTaskGroups {
     ...groups,
     today: sortByFileOrder(groups.today),
     upcoming: sortByFileOrder(groups.upcoming),
+    undated: sortByFileOrder(groups.undated),
     waiting: sortByFileOrder(groups.waiting),
     forwarded: sortByFileOrder(groups.forwarded),
     done: sortByFileOrder(groups.done),
@@ -113,6 +116,7 @@ export function computeTasksRender(
   collapsed: {
     today: boolean
     upcoming: boolean
+    undated: boolean
     waiting: boolean
     forwarded: boolean
     done: boolean
diff --git a/packages/app-core/src/tasks.ts b/packages/app-core/src/tasks.ts
index a4ab6f6de..4a7090fbb 100644
--- a/packages/app-core/src/tasks.ts
+++ b/packages/app-core/src/tasks.ts
@@ -2,8 +2,9 @@ import { captureNavigationContext } from './lib/navigation-context'
 import { useSyncExternalStore } from 'react'
 import type { VaultTask } from '@bridge-contract/tasks'
 import { useStore, type KanbanGroupBy } from './store'
-import { filterTasksForDisplay } from '@shared/tasks'
+import { filterTasksForDisplay, inferDailyTaskDueDates } from '@shared/tasks'
 import { computeTasksRender } from './lib/tasks-filter'
+import { buildDailyNoteDateByPath } from './lib/vault-layout'
 import { dropMutationsFor } from './lib/task-column-mutations'
 
 export type { KanbanGroupBy } from './store'
@@ -83,7 +84,8 @@ export function getTodayTasks(now = new Date()): { readonly tasks: readonly Task
   const state = useStore.getState()
   const livePaths = new Set(state.notes.filter(note => note.folder !== 'trash').map(note => note.path))
   const live = filterTasksForDisplay(state.vaultTasks, state.showArchivedTasks).filter(task => livePaths.has(task.sourcePath))
-  const render = computeTasksRender(live, '', now, { today: false, upcoming: false, waiting: false, forwarded: false, done: false, cancelled: false })
+  const dated = inferDailyTaskDueDates(live, buildDailyNoteDateByPath(state.notes, state.vaultSettings))
+  const render = computeTasksRender(dated, '', now, { today: false, upcoming: false, undated: false, waiting: false, forwarded: false, done: false, cancelled: false })
   const publicTasks = new Map(getTasksSnapshot().tasks.map(task => [task.id, task]))
   return Object.freeze({ tasks: Object.freeze(render.groups.today.map(task => publicTasks.get(task.id)!)), overdueCount: render.groups.overdueCount ?? 0 })
 }
diff --git a/packages/shared-domain/src/tasks-cancelled.test.ts b/packages/shared-domain/src/tasks-cancelled.test.ts
index 0a27bf3a1..7e331e2d5 100644
--- a/packages/shared-domain/src/tasks-cancelled.test.ts
+++ b/packages/shared-domain/src/tasks-cancelled.test.ts
@@ -38,7 +38,7 @@ describe('task cancelling primitives (#450)', () => {
     const tasks = parseTasksFromBody('- [ ] open\n- [x] done\n- [>] gone [[X]]\n- [-] scrapped', ctx)
     const g = groupTasks(tasks, new Date(2026, 0, 1))
     expect(g.cancelled.map((t) => t.content)).toEqual(['scrapped'])
-    expect(g.today.map((t) => t.content)).toEqual(['open'])
+    expect(g.undated.map((t) => t.content)).toEqual(['open'])
     expect(g.done.map((t) => t.content)).toEqual(['done'])
     expect(g.forwarded.map((t) => t.content)).toEqual(['gone [[X]]'])
   })
diff --git a/packages/shared-domain/src/tasks-due.test.ts b/packages/shared-domain/src/tasks-due.test.ts
index 9e2347ece..aa4bd9d43 100644
--- a/packages/shared-domain/src/tasks-due.test.ts
+++ b/packages/shared-domain/src/tasks-due.test.ts
@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { parseTasksFromBody, type ParseTasksContext } from './tasks'
+import {
+  groupTasks,
+  inferDailyTaskDueDates,
+  parseTaskFile,
+  parseTasksFromBody,
+  type ParseTasksContext
+} from './tasks'
 
 const ctx: ParseTasksContext = { path: 'inbox/t.md', title: 't', folder: 'inbox' }
 const parse = (line: string) => parseTasksFromBody(line, ctx)[0]
@@ -23,3 +29,39 @@ describe('parseTasksFromBody — inline due dates (#343)', () => {
     expect(parse('- [ ] task due: someday').due).toBeUndefined()
   })
 })
+
+describe('groupTasks: a task with no due date has its own group (#990)', () => {
+  const today = new Date(2026, 9, 23)
+  const lines = (body: string) => parseTasksFromBody(body, ctx)
+
+  it('keeps Today for what is due today or overdue', () => {
+    const g = groupTasks(
+      lines('- [ ] someday\n- [ ] now due:2026-10-23\n- [ ] late due:2026-10-20\n- [ ] next due:2026-11-04'),
+      today
+    )
+    expect(g.today.map((t) => t.content)).toEqual(['late', 'now'])
+    expect(g.overdueCount).toBe(1)
+    expect(g.upcoming.map((t) => t.content)).toEqual(['next'])
+    expect(g.undated.map((t) => t.content)).toEqual(['someday'])
+  })
+
+  it('puts a task note made with New task, which has only dateCreated, under no due date', () => {
+    const file = parseTaskFile(
+      '---\ntitle: Plan the trip\nstatus: open\ntags: [task]\ndateCreated: 2026-10-23T19:15:52.087Z\n---\n',
+      { path: 'inbox/Plan the trip.md', title: 'Plan the trip', folder: 'inbox' }
+    )
+    expect(file).not.toBeNull()
+    const g = groupTasks([file!], today)
+    expect(g.undated.map((t) => t.content)).toEqual(['Plan the trip'])
+    expect(g.today).toEqual([])
+  })
+
+  it('counts a daily-note task as due on its note\'s date once inferred', () => {
+    const daily = parseTasksFromBody('- [ ] from the daily note', {
+      path: 'daily/2026-10-23.md', title: '2026-10-23', folder: 'inbox'
+    })
+    const dated = inferDailyTaskDueDates(daily, new Map([['daily/2026-10-23.md', '2026-10-23']]))
+    expect(groupTasks(dated, today).today.map((t) => t.content)).toEqual(['from the daily note'])
+    expect(groupTasks(daily, today).undated.map((t) => t.content)).toEqual(['from the daily note'])
+  })
+})
diff --git a/packages/shared-domain/src/tasks-forward.test.ts b/packages/shared-domain/src/tasks-forward.test.ts
index 3c5744c53..c9fcec9c9 100644
--- a/packages/shared-domain/src/tasks-forward.test.ts
+++ b/packages/shared-domain/src/tasks-forward.test.ts
@@ -35,7 +35,7 @@ describe('task forwarding primitives (#316)', () => {
     const tasks = parseTasksFromBody('- [ ] open\n- [x] done\n- [>] gone [[X]]', ctx)
     const g = groupTasks(tasks, new Date(2026, 0, 1))
     expect(g.forwarded.map((t) => t.content)).toEqual(['gone [[X]]'])
-    expect(g.today.map((t) => t.content)).toEqual(['open'])
+    expect(g.undated.map((t) => t.content)).toEqual(['open'])
     expect(g.done.map((t) => t.content)).toEqual(['done'])
   })
 })
diff --git a/packages/shared-domain/src/tasks-in-progress.test.ts b/packages/shared-domain/src/tasks-in-progress.test.ts
index 5886436ca..1333b2949 100644
--- a/packages/shared-domain/src/tasks-in-progress.test.ts
+++ b/packages/shared-domain/src/tasks-in-progress.test.ts
@@ -51,9 +51,10 @@ describe('task in-progress primitives (#512)', () => {
       ctx
     )
     const g = groupTasks(tasks, new Date(2026, 0, 1))
-    // In progress is still today's work: it sits beside the open task rather
-    // than collecting under a group of its own like forwarded/cancelled do.
-    expect(g.today.map((t) => t.content)).toEqual(['open', 'started'])
+    // In progress is still open work: it sits beside the open task (both are
+    // undated here) rather than collecting under a group of its own like
+    // forwarded/cancelled do.
+    expect(g.undated.map((t) => t.content)).toEqual(['open', 'started'])
     expect(g.done.map((t) => t.content)).toEqual(['done'])
     expect(g.forwarded.map((t) => t.content)).toEqual(['gone [[X]]'])
     expect(g.cancelled.map((t) => t.content)).toEqual(['scrapped'])
diff --git a/packages/shared-domain/src/tasks.ts b/packages/shared-domain/src/tasks.ts
index 5e83416e5..f737d4270 100644
--- a/packages/shared-domain/src/tasks.ts
+++ b/packages/shared-domain/src/tasks.ts
@@ -24,6 +24,8 @@ export type { TaskPriority, VaultTask } from '@zennotes/bridge-contract/tasks'
 export interface VaultTaskGroups {
   today: VaultTask[]
   upcoming: VaultTask[]
+  /** Open tasks with no due date, written or inferred from a daily note (#990). */
+  undated: VaultTask[]
   waiting: VaultTask[]
   done: VaultTask[]
   forwarded: VaultTask[]
@@ -440,13 +442,20 @@ export function filterTasksForDisplay(tasks: VaultTask[], showArchived: boolean)
   return tasks.filter((task) => task.noteFolder !== 'archive')
 }
 
-/** Group using a "today" anchor — caller supplies it so tests are stable and
+/** Group using a "today" anchor the caller supplies, so tests are stable and
  *  the user's timezone is respected. Waiting overrides everything except Done.
- *  Tasks without a due date land in Today. */
+ *
+ *  Tasks without a due date have their own group. They used to land in Today,
+ *  so a task made with New task (only `dateCreated` in its frontmatter) sat
+ *  among today's work and the "No due date" a user went looking for did not
+ *  exist (#990). A task in a daily note counts as due on that note's date
+ *  when the caller has applied `inferDailyTaskDueDates`, so the daily-note
+ *  workflow keeps its tasks in Today. */
 export function groupTasks(tasks: VaultTask[], today: Date): VaultTaskGroups {
   const todayIso = toIsoDate(today)
   const today_: VaultTask[] = []
   const upcoming: VaultTask[] = []
+  const undated: VaultTask[] = []
   const waiting: VaultTask[] = []
   const done: VaultTask[] = []
   const forwarded: VaultTask[] = []
@@ -471,7 +480,7 @@ export function groupTasks(tasks: VaultTask[], today: Date): VaultTaskGroups {
       continue
     }
     if (!task.due) {
-      today_.push(task)
+      undated.push(task)
       continue
     }
     if (task.due < todayIso) {
@@ -504,6 +513,7 @@ export function groupTasks(tasks: VaultTask[], today: Date): VaultTaskGroups {
 
   today_.sort(byPriorityThenDue)
   upcoming.sort(byDueThenPath)
+  undated.sort(byPriorityThenDue)
   waiting.sort(byPriorityThenDue)
   done.sort((a, b) => {
     if (a.sourcePath !== b.sourcePath) return a.sourcePath < b.sourcePath ? -1 : 1
@@ -515,7 +525,7 @@ export function groupTasks(tasks: VaultTask[], today: Date): VaultTaskGroups {
     return a.taskIndex - b.taskIndex
   })
 
-  return { today: today_, upcoming, waiting, done, forwarded, cancelled, overdueCount }
+  return { today: today_, upcoming, undated, waiting, done, forwarded, cancelled, overdueCount }
 }
 
 /** Helper for UIs that need to know whether a task is overdue relative to now. */

From 712a0e7a72952807d63b36f7b1c0eb867811c42d Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 15:23:10 -0500
Subject: [PATCH 06/10] Feat(tasks): order the Tasks list by priority, still
 grouped by date (#989)

Davi (#989) could see tasks by priority only on the Kanban board. The list
groups by date, and inside each group it always follows the notes' line
order, so Shift+J/K and dragging move the real lines; the priority shown on
every row never changed where it sat.

The list now has an Order menu above it, Note order or Priority, the
counterpart of the board's card order. Priority puts high before medium
before low before none inside Today, Upcoming, No due date and Waiting,
ties by due date and then line order; forwarded, done and cancelled keep
line order. `s` switches it in Vim mode, as on the board; `:order priority`
and `:order note` set it, and bare `:order` in the list switches it; it is
also in Settings, the palette, and `tasks_list_order` under `[view]` in
config.toml, so it travels like the board's order.

Reordering moves lines in the note, which only shows in Note order, so in
Priority order Shift+J/K say so instead of moving lines out of sight, and
rows cannot be dragged; the footer drops "J/K reorder" there.

Also: dragging a task inside the No due date group (#990) reorders it now;
the drag handler did not know the group existed.
---
 apps/desktop/src/main/app-config.test.ts      |  3 +
 apps/desktop/src/main/app-config.ts           |  5 ++
 .../app-core/src/components/SettingsModal.tsx | 33 +++++++
 .../app-core/src/components/TasksView.tsx     | 90 ++++++++++++++++---
 packages/app-core/src/lib/commands.ts         | 13 +++
 packages/app-core/src/lib/help.ts             | 12 +--
 .../app-core/src/lib/tasks-filter.test.ts     | 30 ++++++-
 packages/app-core/src/lib/tasks-filter.ts     | 39 +++++++-
 packages/app-core/src/store.test.ts           | 23 +++++
 packages/app-core/src/store.ts                | 17 ++++
 packages/bridge-contract/src/app-config.ts    |  1 +
 packages/shared-domain/src/app-config.ts      |  1 +
 12 files changed, 243 insertions(+), 24 deletions(-)

diff --git a/apps/desktop/src/main/app-config.test.ts b/apps/desktop/src/main/app-config.test.ts
index db54a75a3..d77de0fb8 100644
--- a/apps/desktop/src/main/app-config.test.ts
+++ b/apps/desktop/src/main/app-config.test.ts
@@ -132,6 +132,7 @@ describe('TOML serialization', () => {
       savedTaskFilters: { 'Project alpha': '@project:alpha', Blocked: '@status:blocked' },
       kanbanGroupBy: 'folder',
       kanbanCardSort: 'due',
+      tasksListOrder: 'priority',
       kanbanFolderRoot: 'Projects',
       externalApplicationSchemes: ['zotero', 'obsidian'],
       ignoredKeys: ['KanaMode', 'F24']
@@ -165,6 +166,8 @@ describe('TOML serialization', () => {
     expect(round.kanbanGroupBy).toBe('folder')
     expect(text).toContain('kanban_card_sort = "due"')
     expect(round.kanbanCardSort).toBe('due')
+    expect(text).toContain('tasks_list_order = "priority"')
+    expect(round.tasksListOrder).toBe('priority')
     expect(round.kanbanFolderRoot).toBe('Projects')
     expect(text).toContain('ignored_keys = ["KanaMode", "F24"]')
     expect(round.externalApplicationSchemes).toEqual(['zotero', 'obsidian'])
diff --git a/apps/desktop/src/main/app-config.ts b/apps/desktop/src/main/app-config.ts
index 6e8753766..46d99b400 100644
--- a/apps/desktop/src/main/app-config.ts
+++ b/apps/desktop/src/main/app-config.ts
@@ -415,6 +415,11 @@ const SCALAR_FIELDS: Partial<Record<PortablePrefKey, ScalarFieldMap>> = {
     tomlKey: 'kanban_card_sort',
     comment: 'manual | due: cards in a Kanban column keep the order you drag them into, or follow their due dates'
   },
+  tasksListOrder: {
+    section: 'view',
+    tomlKey: 'tasks_list_order',
+    comment: 'note | priority: each Tasks list group keeps its notes\' line order, or puts high priority first'
+  },
   kanbanFolderRoot: {
     section: 'view',
     tomlKey: 'kanban_folder_root',
diff --git a/packages/app-core/src/components/SettingsModal.tsx b/packages/app-core/src/components/SettingsModal.tsx
index d85cc22ce..7870d6d23 100644
--- a/packages/app-core/src/components/SettingsModal.tsx
+++ b/packages/app-core/src/components/SettingsModal.tsx
@@ -708,6 +708,8 @@ export function SettingsModal(): JSX.Element {
   const showArchivedTasks = useStore((s) => s.showArchivedTasks);
   const kanbanCardSort = useStore((s) => s.kanbanCardSort);
   const setKanbanCardSort = useStore((s) => s.setKanbanCardSort);
+  const tasksListOrder = useStore((s) => s.tasksListOrder);
+  const setTasksListOrder = useStore((s) => s.setTasksListOrder);
   const setShowArchivedTasks = useStore((s) => s.setShowArchivedTasks);
   const mathRenderer = useStore((s) => s.mathRenderer);
   const mathFontScale = useStore((s) => s.mathFontScale);
@@ -3470,6 +3472,21 @@ export function SettingsModal(): JSX.Element {
             "directory",
           ],
         },
+        {
+          id: "tasks-list-order",
+          title: "Tasks list order",
+          description:
+            "Order the tasks in each group of the Tasks list by their notes' line order or by priority.",
+          keywords: [
+            "tasks",
+            "list",
+            "sort",
+            "order",
+            "priority",
+            "high",
+            "note",
+          ],
+        },
         {
           id: "kanban-card-sort",
           title: "Kanban card order",
@@ -3565,6 +3582,22 @@ export function SettingsModal(): JSX.Element {
               onChange={(next) => setKanbanCardSort(next)}
             />
           </Section>
+          <Section
+            title="List order"
+            description="How the tasks inside each group of the Tasks list are ordered."
+          >
+            <SegmentedRow
+              label="Tasks list order"
+              description="Note order follows each note's line order, which Shift+J/K and dragging rearrange. Priority puts high priority first, then medium, low, and none, with ties by due date; reordering works in Note order. In the list: the Order menu, or s in Vim mode."
+              value={tasksListOrder}
+              settingId="tasks-list-order"
+              options={[
+                { value: "note", label: "Note order" },
+                { value: "priority", label: "Priority" },
+              ]}
+              onChange={(next) => setTasksListOrder(next)}
+            />
+          </Section>
           <Section
             title="Archived notes"
             description="What happens to a note's tasks when the note moves to the Archive."
diff --git a/packages/app-core/src/components/TasksView.tsx b/packages/app-core/src/components/TasksView.tsx
index 58f59815a..0b1a01548 100644
--- a/packages/app-core/src/components/TasksView.tsx
+++ b/packages/app-core/src/components/TasksView.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { isTasksViewActive, useStore, type KanbanCardSort, type TasksViewMode } from '../store'
+import { isTasksViewActive, useStore, type KanbanCardSort, type TasksListOrder, type TasksViewMode } from '../store'
 import { filterTasksForDisplay, inferDailyTaskDueDates, type VaultTask } from '@shared/tasks'
 import { buildDailyNoteDateByPath } from '../lib/vault-layout'
 import { computeTasksRender, filterTasks, isOverdue } from '../lib/tasks-filter'
@@ -91,6 +91,8 @@ export function TasksView(): JSX.Element {
   const filteredTasks = useMemo(() => filterTasks(tasks, filter), [tasks, filter])
   const keymapOverrides = useStore((s) => s.keymapOverrides)
   const vimMode = useStore((s) => s.vimMode)
+  const listOrder = useStore((s) => s.tasksListOrder)
+  const setTasksListOrder = useStore((s) => s.setTasksListOrder)
   const viewMode = useStore((s) => s.tasksViewMode)
   const setViewMode = useStore((s) => s.setTasksViewMode)
   // Only the Tasks panel in the *active* pane should listen for j/k/etc.
@@ -139,14 +141,14 @@ export function TasksView(): JSX.Element {
 
   const render = useMemo(() => {
     const linger = lingerRef.current
-    if (linger.size === 0) return computeTasksRender(tasks, filter, today, collapsed)
+    if (linger.size === 0) return computeTasksRender(tasks, filter, today, collapsed, listOrder)
     // Group lingering tasks by their PRE-toggle checked state so a just-checked
     // task stays in its current group instead of jumping straight to Done.
     const source = tasks.map((t) => {
       const l = linger.get(t.id)
       return l ? { ...t, checked: l.groupChecked } : t
     })
-    const r = computeTasksRender(source, filter, today, collapsed)
+    const r = computeTasksRender(source, filter, today, collapsed, listOrder)
     // Render the real task so the checkbox reflects the actual (new) state while
     // the row lingers in place.
     const byId = new Map(tasks.map((t) => [t.id, t]))
@@ -155,7 +157,7 @@ export function TasksView(): JSX.Element {
     )
     return { ...r, rows }
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [tasks, filter, today, collapsed, lingerVersion])
+  }, [tasks, filter, today, collapsed, lingerVersion, listOrder])
 
   // Index-into-rows map for just the 'task' rows (what the cursor navigates).
   const taskRowIndices = useMemo(() => {
@@ -375,9 +377,22 @@ export function TasksView(): JSX.Element {
   // the same note — this rewrites the note's markdown line order, the single
   // source of truth. No-op at a group edge or a note boundary (can't move a
   // task line into a different file).
+  // Reordering moves lines in the note, which only means something while the
+  // list shows the notes' line order; by priority it would seem to do nothing.
+  const reorderBlockedByPriority = useCallback((): boolean => {
+    if (listOrder !== 'priority') return false
+    toast(
+      vimMode
+        ? 'Reordering works in Note order. Press s to switch.'
+        : 'Reordering works in Note order. Switch Order to Note order.'
+    )
+    return true
+  }, [listOrder, vimMode, toast])
+
   const moveSelectedTask = useCallback(
     (delta: -1 | 1) => {
       if (viewMode !== 'list' || !currentTask) return
+      if (reorderBlockedByPriority()) return
       const row = render.rows[currentRowIdx]
       if (!row || row.kind !== 'task') return
       const list = render.groups[row.group]
@@ -387,7 +402,7 @@ export function TasksView(): JSX.Element {
       followTaskRef.current = taskFollowKey(currentTask)
       void reorderTaskInNote(currentTask, neighbor, delta < 0 ? 'before' : 'after')
     },
-    [viewMode, currentTask, currentRowIdx, render.rows, render.groups, reorderTaskInNote]
+    [viewMode, currentTask, currentRowIdx, render.rows, render.groups, reorderTaskInNote, reorderBlockedByPriority]
   )
 
   // Drag-to-reorder: only within the same note (a task line can't move between
@@ -395,7 +410,7 @@ export function TasksView(): JSX.Element {
   const reorderTaskByDrag = useCallback(
     (draggedId: string, targetId: string, position: 'before' | 'after') => {
       if (draggedId === targetId) return
-      const keys: GroupKey[] = ['today', 'upcoming', 'waiting', 'done']
+      const keys: GroupKey[] = ['today', 'upcoming', 'undated', 'waiting', 'done']
       for (const group of keys) {
         const list = render.groups[group]
         const dragged = list.find((t) => t.id === draggedId)
@@ -455,11 +470,25 @@ export function TasksView(): JSX.Element {
       }
       // `:order due` sorts every Kanban column by due date, `:order manual`
       // brings back the dragged arrangement, and bare `:order` switches
-      // between the two, like `s` on the board. (#889)
+      // between the two, like `s` on the board. (#889) `:order priority` and
+      // `:order note` set the list's order instead, and bare `:order` in the
+      // list switches that one, like `s` there. (#989)
       if (head === 'order') {
         const wanted = arg.toLowerCase()
-        if (wanted && wanted !== 'due' && wanted !== 'manual') {
-          toast('Usage: :order due | manual')
+        if (wanted && !['due', 'manual', 'priority', 'note'].includes(wanted)) {
+          toast('Usage: :order due | manual | priority | note')
+          return
+        }
+        if (wanted === 'priority' || wanted === 'note' || (!wanted && viewMode === 'list')) {
+          const store = useStore.getState()
+          const next: TasksListOrder = wanted
+            ? (wanted as TasksListOrder)
+            : store.tasksListOrder === 'priority'
+              ? 'note'
+              : 'priority'
+          store.setTasksListOrder(next)
+          setViewMode('list')
+          toast(next === 'priority' ? 'Tasks ordered by priority' : 'Tasks in their notes’ order')
           return
         }
         const store = useStore.getState()
@@ -564,7 +593,8 @@ export function TasksView(): JSX.Element {
       saveCurrentFilter,
       deleteSavedTaskFilter,
       savedFilters,
-      toast
+      toast,
+      viewMode
     ]
   )
 
@@ -678,6 +708,15 @@ export function TasksView(): JSX.Element {
       // List-mode-only navigation. Calendar and Kanban have their own.
       if (viewMode !== 'list') return
 
+      // The list's Order (#989), like `s` for the board's card order.
+      if (vimMode && key === 's') {
+        consume()
+        const next: TasksListOrder = listOrder === 'priority' ? 'note' : 'priority'
+        setTasksListOrder(next)
+        toast(next === 'priority' ? 'Tasks ordered by priority' : 'Tasks in their notes’ order')
+        return
+      }
+
       if (seq('nav.moveDown') || key === 'ArrowDown') {
         consume()
         moveCursor(1)
@@ -778,7 +817,10 @@ export function TasksView(): JSX.Element {
     viewMode,
     setViewMode,
     newTaskFile,
-    pickSavedFilter
+    pickSavedFilter,
+    listOrder,
+    setTasksListOrder,
+    toast
   ])
 
   return (
@@ -929,6 +971,26 @@ export function TasksView(): JSX.Element {
         </div>
       )}
 
+      {viewMode === 'list' && (
+        <div className="flex items-center justify-end gap-2 border-b border-paper-300/45 px-4 py-1 text-xs text-current/60">
+          <span>Order</span>
+          <select
+            data-tasks-list-order
+            value={listOrder}
+            onChange={(e) => setTasksListOrder(e.target.value as TasksListOrder)}
+            title={
+              listOrder === 'priority'
+                ? `Each group puts high priority first, then medium, low, and none; ties follow the due date. Note order brings back the notes' line order${vimMode ? ' (s)' : ''}.`
+                : `Each group follows its notes' line order, which J/K rearrange. Priority puts high priority first${vimMode ? ' (s)' : ''}.`
+            }
+            className="rounded-md border border-paper-300/60 bg-paper-200/60 px-2 py-0.5 text-xs text-current/85 outline-none focus:border-paper-400/70"
+          >
+            <option value="note">Note order</option>
+            <option value="priority">Priority</option>
+          </select>
+        </div>
+      )}
+
       {viewMode === 'list' && (
         <div className="min-h-0 flex-1 overflow-y-auto px-2 py-2">
           {render.rows.length === 0 && !loading && (
@@ -973,7 +1035,7 @@ export function TasksView(): JSX.Element {
                   const ti = taskRowIndices.indexOf(idx)
                   if (ti >= 0) setCursorIndex(ti)
                 }}
-                onReorder={reorderTaskByDrag}
+                onReorder={listOrder === 'note' ? reorderTaskByDrag : undefined}
                 onContextMenu={openTaskMenu}
                 toggleKeyLabel={toggleKeyLabel}
                 vimMode={vimMode}
@@ -1048,8 +1110,8 @@ 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 · @ due date · F saved filters · right-click actions · :q close'
-              : '↑/↓ move · Shift+J/K reorder · Enter open · right-click actions'
+              ? `j/k move · ${listOrder === 'note' ? 'J/K reorder · ' : ''}Enter/o open · x toggle · i start · c cancel · @ due date · s order · F saved filters · right-click actions · :q close`
+              : `↑/↓ move · ${listOrder === 'note' ? '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 · @ due date · F saved filters · drag to move · right-click actions · :q'
diff --git a/packages/app-core/src/lib/commands.ts b/packages/app-core/src/lib/commands.ts
index e7a7ccdd5..a00ff1619 100644
--- a/packages/app-core/src/lib/commands.ts
+++ b/packages/app-core/src/lib/commands.ts
@@ -1481,6 +1481,19 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma
     run: () => getState().setKanbanCardSort(getState().kanbanCardSort === 'due' ? 'manual' : 'due')
   })
 
+  // The Tasks list's order (#989), from any note: the next list opened uses it.
+  cmds.push({
+    id: 'view.tasks-list-order',
+    title:
+      getState().tasksListOrder === 'priority'
+        ? 'Tasks: Order List by Note Order'
+        : 'Tasks: Order List by Priority',
+    category: 'View',
+    keywords: 'tasks list sort priority high order note line',
+    run: () =>
+      getState().setTasksListOrder(getState().tasksListOrder === 'priority' ? 'note' : 'priority')
+  })
+
   // 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.
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 3d8ace546..1773229c4 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -282,7 +282,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Tasks, tags, archive, and trash are vault-wide views',
     body:
-      'Tasks scans every note for checkboxes and groups the open ones by when they are due: Today (due today or overdue), Upcoming, and No due date, then Waiting, Forwarded, Done, and Cancelled. A task written in a daily note counts as due on that note’s date while “Tasks are due on the note’s date” is on (Settings → Daily notes). Tags lets you browse notes that carry all of the selected tags (toggle Match to Any for a union), Archive gives you a dedicated list of cold-storage notes, and Trash gives you a recovery surface for deleted notes without turning the left rail into a second browser. Selected tags accumulate so you can narrow across several at once; clear them with the Selected strip’s “Clear all”, the `c` key, or a right-click on any tag chip (which also offers “Unselect others” to keep just that one). A tag chip’s context menu also carries “Rename Tag…” and “Delete Tag…”, which rewrite or remove that hashtag across the whole vault. Tags work in any script (`#тест` and `#标签` are tags), while headings (`# x`) and hex colors (`#1971c2`) are not.'
+      'Tasks scans every note for checkboxes and groups the open ones by when they are due: Today (due today or overdue), Upcoming, and No due date, then Waiting, Forwarded, Done, and Cancelled. A task written in a daily note counts as due on that note’s date while “Tasks are due on the note’s date” is on (Settings → Daily notes). Inside each group the list keeps the notes’ line order, or puts high priority first when its Order menu, above the list, says Priority (`s` in Vim mode). Tags lets you browse notes that carry all of the selected tags (toggle Match to Any for a union), Archive gives you a dedicated list of cold-storage notes, and Trash gives you a recovery surface for deleted notes without turning the left rail into a second browser. Selected tags accumulate so you can narrow across several at once; clear them with the Selected strip’s “Clear all”, the `c` key, or a right-click on any tag chip (which also offers “Unselect others” to keep just that one). A tag chip’s context menu also carries “Rename Tag…” and “Delete Tag…”, which rewrite or remove that hashtag across the whole vault. Tags work in any script (`#тест` and `#标签` are tags), while headings (`# x`) and hex colors (`#1971c2`) are not.'
   },
   {
     title: 'Archiving a note retires its tasks',
@@ -704,7 +704,8 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'i', action: 'Mark task in progress', detail: 'Tasks list only: mark the selected task as started (`- [/]`), or set it back to open. In-progress tasks keep their group and their day on the calendar, so the row keeps its place.' },
       { keys: 'c', action: 'Cancel task', detail: 'Tasks list only: mark the selected task as intentionally abandoned (`- [-]`), or un-cancel it. Cancelled tasks live under a “Cancelled” group, out of Today and Done.' },
       { keys: '@', action: 'Choose due date', detail: 'Tasks list, board, and calendar: give the selected task any due date from the month calendar that typing `@date` opens in a note, the same as Choose a date… in its right-click menu. It starts on the task’s due date (today without one); arrows move, Enter sets the day, or type a date.' },
-      { keys: 'K / J', action: 'Move task up / down', detail: 'Tasks list only: reorder the selected task within its group. Works with Vim mode on or off.' },
+      { keys: 'K / J', action: 'Move task up / down', detail: 'Tasks list only: reorder the selected task within its group. Works with Vim mode on or off, in Note order (see `s`).' },
+      { keys: 's', action: 'Order the list', detail: 'Tasks list only: switch the order inside each group between the notes’ line order and priority (high, then medium, low, and none, ties by due date). Same as the Order menu above the list, `:order priority` / `:order note`, and `tasks_list_order` under `[view]` in config.toml.' },
       { 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.' },
@@ -809,9 +810,9 @@ export const HELP_VIM_COMMANDS: HelpExCommand[] = [
     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: ':order due | manual',
-    summary: 'Order Kanban cards by due date or by hand',
-    detail: 'In the Tasks view, `:order due` sorts the cards in every Kanban column by due date, earliest first and cards without one last; `:order manual` brings back the order you dragged them into, which ordering by date never overwrites. Bare `:order` switches between the two, like `s` on the board in Vim mode. Same as `kanban_card_sort` under `[view]` in config.toml.'
+    command: ':order due | manual | priority | note',
+    summary: 'Order Kanban cards by due date or by hand, or the list by priority',
+    detail: 'In the Tasks view, `:order due` sorts the cards in every Kanban column by due date, earliest first and cards without one last; `:order manual` brings back the order you dragged them into, which ordering by date never overwrites. On the board or the calendar, bare `:order` switches between the two, like `s` on the board in Vim mode. Same as `kanban_card_sort` under `[view]` in config.toml. In the list, `:order priority` puts high priority first inside each group and `:order note` brings back the notes’ line order; bare `:order` there switches between the two, like `s`. Same as `tasks_list_order` under `[view]`.'
   },
   {
     command: ':delfilter <name>',
@@ -1225,6 +1226,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
     items: [
       { label: 'Show tasks from archived notes', detail: 'Off by default: archiving a note retires its tasks from the Tasks list, calendar, and Kanban. Turn this on to keep them visible everywhere, Archive column included. The raw key is `show_archived_tasks` in `config.toml`.' },
       { label: 'Kanban statuses', detail: 'Define the ordered columns of the custom-status Kanban board here; `kanban_statuses` under `[view]` in `config.toml` is the file-level equivalent.' },
+      { label: 'Tasks list order', detail: 'Note order keeps each group of the Tasks list in its notes’ line order, which Shift+J/K and dragging rearrange; Priority puts high priority first, then medium, low, and none, ties by due date. The list’s Order menu sets the same thing, and the raw key is `tasks_list_order` (`note` or `priority`) under `[view]` in `config.toml`.' },
       { label: 'Kanban card order', detail: 'Manual keeps the cards in the order you drag them into; Due date sorts every Kanban column by due date, cards without one last, and keeps your manual order for when you switch back. The board\'s Order menu sets the same thing, and the raw key is `kanban_card_sort` (`manual` or `due`) under `[view]` in `config.toml`.' }
     ]
   },
diff --git a/packages/app-core/src/lib/tasks-filter.test.ts b/packages/app-core/src/lib/tasks-filter.test.ts
index e7438af0b..37f566248 100644
--- a/packages/app-core/src/lib/tasks-filter.test.ts
+++ b/packages/app-core/src/lib/tasks-filter.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import type { VaultTask, VaultTaskGroups } from '@shared/tasks'
-import { applyFileOrder, filterTasks } from './tasks-filter'
+import { applyFileOrder, applyPriorityOrder, computeTasksRender, filterTasks } from './tasks-filter'
 
 function task(sourcePath: string, taskIndex: number, overrides?: Partial<VaultTask>): VaultTask {
   return {
@@ -90,3 +90,31 @@ describe('applyFileOrder', () => {
     expect(input.map((t) => t.taskIndex)).toEqual([1, 0])
   })
 })
+
+describe('the list by priority (#989)', () => {
+  const today = new Date(2026, 9, 23)
+  const open = { today: false, upcoming: false, undated: false, waiting: false, forwarded: false, done: false, cancelled: false }
+
+  it('puts high before medium before low before none inside each group, ties by due date then note order', () => {
+    const tasks = [
+      task('a.md', 0, { content: 'bank', priority: 'med', due: '2026-10-23' }),
+      task('a.md', 1, { content: 'passport', priority: 'high', due: '2026-10-20' }),
+      task('b.md', 0, { content: 'plants', due: '2026-10-23' }),
+      task('b.md', 1, { content: 'invoice', priority: 'low', due: '2026-10-23' }),
+      task('c.md', 0, { content: 'contract', priority: 'high', due: '2026-10-23' }),
+      task('c.md', 1, { content: 'rent', priority: 'high', due: '2026-11-01' }),
+      task('c.md', 2, { content: 'tickets', priority: 'low', due: '2026-11-04' })
+    ]
+    const byPriority = computeTasksRender(tasks, '', today, open, 'priority').groups
+    expect(byPriority.today.map((t) => t.content)).toEqual(['passport', 'contract', 'bank', 'invoice', 'plants'])
+    expect(byPriority.upcoming.map((t) => t.content)).toEqual(['rent', 'tickets'])
+    const byNote = computeTasksRender(tasks, '', today, open).groups
+    expect(byNote.today.map((t) => t.content)).toEqual(['bank', 'passport', 'plants', 'invoice', 'contract'])
+  })
+
+  it('keeps note order for the closed groups', () => {
+    const done = [task('b.md', 0, { checked: true, priority: 'low' }), task('a.md', 0, { checked: true, priority: 'high' })]
+    const g = applyPriorityOrder({ ...groups([]), done })
+    expect(g.done.map((t) => t.sourcePath)).toEqual(['a.md', 'b.md'])
+  })
+})
diff --git a/packages/app-core/src/lib/tasks-filter.ts b/packages/app-core/src/lib/tasks-filter.ts
index 37f601b23..69e7eb6ac 100644
--- a/packages/app-core/src/lib/tasks-filter.ts
+++ b/packages/app-core/src/lib/tasks-filter.ts
@@ -106,9 +106,38 @@ export function applyFileOrder(groups: VaultTaskGroups): VaultTaskGroups {
   }
 }
 
-/** One-stop computation used by TasksView — takes raw tasks + filter + today
+const PRIORITY_RANK: Record<NonNullable<VaultTask['priority']>, number> = { high: 0, med: 1, low: 2 }
+
+/** High, then medium, then low, then none; ties by due date (none last), then
+ *  note order, so tasks of one priority keep a stable, readable order. */
+function sortByPriority(tasks: VaultTask[]): VaultTask[] {
+  const rank = (task: VaultTask) => (task.priority ? PRIORITY_RANK[task.priority] : 3)
+  return sortByFileOrder(tasks).sort((a, b) => {
+    if (rank(a) !== rank(b)) return rank(a) - rank(b)
+    const ad = a.due ?? '9999-99-99'
+    const bd = b.due ?? '9999-99-99'
+    return ad === bd ? 0 : ad < bd ? -1 : 1
+  })
+}
+
+/** Order by priority, still grouped by date (#989). Only the live groups
+ *  re-sort; forwarded, done and cancelled keep note order, since priority no
+ *  longer says what to do next there. */
+export function applyPriorityOrder(groups: VaultTaskGroups): VaultTaskGroups {
+  const byNote = applyFileOrder(groups)
+  return {
+    ...byNote,
+    today: sortByPriority(groups.today),
+    upcoming: sortByPriority(groups.upcoming),
+    undated: sortByPriority(groups.undated),
+    waiting: sortByPriority(groups.waiting)
+  }
+}
+
+/** One-stop computation used by TasksView: takes raw tasks + filter + today
  *  and returns everything the view needs. Within each group, tasks follow the
- *  note's line order so editor / list reordering is reflected. */
+ *  note's line order so editor / list reordering is reflected, or priority
+ *  when the list's Order says so (#989). */
 export function computeTasksRender(
   tasks: VaultTask[],
   filter: string,
@@ -121,10 +150,12 @@ export function computeTasksRender(
     forwarded: boolean
     done: boolean
     cancelled: boolean
-  }
+  },
+  order: 'note' | 'priority' = 'note'
 ): TasksRender {
   const filtered = filterTasks(tasks, filter)
-  const groups = applyFileOrder(groupTasks(filtered, today))
+  const grouped = groupTasks(filtered, today)
+  const groups = order === 'priority' ? applyPriorityOrder(grouped) : applyFileOrder(grouped)
   const rows = flattenRows(groups, collapsed)
   return { rows, groups, filtered }
 }
diff --git a/packages/app-core/src/store.test.ts b/packages/app-core/src/store.test.ts
index b0524879b..d11a06226 100644
--- a/packages/app-core/src/store.test.ts
+++ b/packages/app-core/src/store.test.ts
@@ -1853,6 +1853,29 @@ describe('vimWrappedLineMotions (#638)', () => {
   })
 })
 
+describe('tasksListOrder (#989)', () => {
+  it('defaults to note order and round-trips priority order', async () => {
+    installZen()
+    const { useStore } = await loadStore()
+    expect(useStore.getState().tasksListOrder).toBe('note')
+
+    useStore.getState().setTasksListOrder('priority')
+    const saved = JSON.parse(localStorage.getItem('zen:prefs:v2') ?? '{}')
+    expect(saved.tasksListOrder).toBe('priority')
+
+    vi.resetModules()
+    const reloaded = await import('./store')
+    expect(reloaded.useStore.getState().tasksListOrder).toBe('priority')
+  })
+
+  it('normalizes an unknown stored value to note order', async () => {
+    installZen()
+    localStorage.setItem('zen:prefs:v2', JSON.stringify({ tasksListOrder: 'due' }))
+    const { useStore } = await loadStore()
+    expect(useStore.getState().tasksListOrder).toBe('note')
+  })
+})
+
 describe('kanbanCardSort (#889)', () => {
   it('defaults to the manual order and round-trips due-date ordering', async () => {
     installZen()
diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts
index 5803e5b1a..bd39a6b3f 100644
--- a/packages/app-core/src/store.ts
+++ b/packages/app-core/src/store.ts
@@ -763,6 +763,8 @@ interface Prefs {
    *  they were dragged into (due date until then), `due` always sorts them by
    *  due date and leaves that arrangement untouched for later. (#889) */
   kanbanCardSort: KanbanCardSort
+  /** Tasks list groups in their notes' line order or by priority. (#989) */
+  tasksListOrder: TasksListOrder
   /** Display-only Kanban column title overrides. Keyed by `${groupBy}:${columnId}`. */
   kanbanColumnTitles: Record<string, string>
   /** Manual Kanban column arrangement per board. Keyed by groupBy → ordered
@@ -789,6 +791,9 @@ interface Prefs {
 export type TasksViewMode = 'list' | 'calendar' | 'kanban'
 export type KanbanGroupBy = 'status' | 'priority' | 'folder' | `field:${string}`
 export type KanbanCardSort = 'manual' | 'due'
+/** `note` keeps each Tasks list group in its notes' line order (what J/K
+ *  rearrange); `priority` puts high before medium before low. (#989) */
+export type TasksListOrder = 'note' | 'priority'
 /** How the Tags view combines multiple selected tags: `all` = intersection
  *  (AND, narrows), `any` = union (OR, widens). */
 export type TagMatchMode = 'all' | 'any'
@@ -1193,6 +1198,7 @@ export const DEFAULT_PREFS: Prefs = {
   showArchivedTasks: false,
   kanbanGroupBy: 'status',
   kanbanCardSort: 'manual',
+  tasksListOrder: 'note',
   kanbanColumnTitles: {},
   kanbanColumnOrder: {},
   kanbanCardOrder: {},
@@ -1547,6 +1553,7 @@ function normalizePrefs(p: Partial<Prefs>): Prefs {
         : DEFAULT_PREFS.showArchivedTasks,
     kanbanGroupBy: normalizeKanbanGroupBy(p.kanbanGroupBy),
     kanbanCardSort: p.kanbanCardSort === 'due' ? 'due' : 'manual',
+    tasksListOrder: p.tasksListOrder === 'priority' ? 'priority' : 'note',
     kanbanColumnTitles: normalizeKanbanColumnTitles(p.kanbanColumnTitles),
     kanbanColumnOrder: normalizeKanbanColumnOrder(p.kanbanColumnOrder),
     kanbanCardOrder: normalizeKanbanCardOrder(p.kanbanCardOrder),
@@ -2479,6 +2486,7 @@ function collectPrefs(s: {
   showArchivedTasks: boolean
   kanbanGroupBy: KanbanGroupBy
   kanbanCardSort: KanbanCardSort
+  tasksListOrder: TasksListOrder
   kanbanColumnTitles: Record<string, string>
   kanbanColumnOrder: Record<string, string[]>
   kanbanCardOrder: Record<string, string[]>
@@ -2590,6 +2598,7 @@ function collectPrefs(s: {
     showArchivedTasks: s.showArchivedTasks,
     kanbanGroupBy: s.kanbanGroupBy,
     kanbanCardSort: s.kanbanCardSort,
+    tasksListOrder: s.tasksListOrder,
     kanbanColumnTitles: s.kanbanColumnTitles,
     kanbanColumnOrder: s.kanbanColumnOrder,
     kanbanCardOrder: s.kanbanCardOrder,
@@ -3238,6 +3247,8 @@ interface Store {
   kanbanGroupBy: KanbanGroupBy
   /** Cards in each Kanban column by hand-placed order or by due date. (#889) */
   kanbanCardSort: KanbanCardSort
+  /** Tasks list groups in note order or by priority. (#989) */
+  tasksListOrder: TasksListOrder
   /** Display-only column title overrides for the Tasks Kanban view. */
   kanbanColumnTitles: Record<string, string>
   /** Manual column arrangement per board (groupBy → ordered column ids). */
@@ -3496,6 +3507,7 @@ interface Store {
   confirmArchiveNotes: (paths: string[]) => Promise<boolean>
   setKanbanGroupBy: (group: KanbanGroupBy) => void
   setKanbanCardSort: (sort: KanbanCardSort) => void
+  setTasksListOrder: (order: TasksListOrder) => void
   setKanbanColumnTitle: (
     group: KanbanGroupBy,
     columnId: string,
@@ -5972,6 +5984,7 @@ export const useStore = create<Store>((set, get) => {
   showArchivedTasks: loadPrefs().showArchivedTasks,
   kanbanGroupBy: loadPrefs().kanbanGroupBy,
   kanbanCardSort: loadPrefs().kanbanCardSort,
+  tasksListOrder: loadPrefs().tasksListOrder,
   kanbanColumnTitles: loadPrefs().kanbanColumnTitles,
   kanbanColumnOrder: loadPrefs().kanbanColumnOrder,
   kanbanCardOrder: loadPrefs().kanbanCardOrder,
@@ -7453,6 +7466,10 @@ export const useStore = create<Store>((set, get) => {
     set({ kanbanCardSort: sort })
     savePrefs(collectPrefs(get()))
   },
+  setTasksListOrder: (order) => {
+    set({ tasksListOrder: order })
+    savePrefs(collectPrefs(get()))
+  },
   setKanbanColumnTitle: (group, columnId, title) => {
     const key = `${group}:${columnId}`
     const normalized = typeof title === 'string' ? normalizeKanbanColumnTitle(title) : null
diff --git a/packages/bridge-contract/src/app-config.ts b/packages/bridge-contract/src/app-config.ts
index 4a8936a4b..ac7120c67 100644
--- a/packages/bridge-contract/src/app-config.ts
+++ b/packages/bridge-contract/src/app-config.ts
@@ -99,6 +99,7 @@ export const PORTABLE_PREF_KEYS = [
   'showArchivedTasks',
   'kanbanGroupBy',
   'kanbanCardSort',
+  'tasksListOrder',
   'kanbanFolderRoot',
   'kanbanColumnTitles',
   'kanbanStatuses',
diff --git a/packages/shared-domain/src/app-config.ts b/packages/shared-domain/src/app-config.ts
index bce4fa4c9..3e8a9abed 100644
--- a/packages/shared-domain/src/app-config.ts
+++ b/packages/shared-domain/src/app-config.ts
@@ -165,6 +165,7 @@ export const PORTABLE_DEFAULTS: Record<PortablePrefKey, unknown> = {
   showArchivedTasks: false,
   kanbanGroupBy: 'status',
   kanbanCardSort: 'manual',
+  tasksListOrder: 'note',
   kanbanFolderRoot: '',
   kanbanColumnTitles: {},
   kanbanStatuses: [],

From efe5592f51357b417a3f0ea0568ef8c2345412fb Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 15:36:01 -0500
Subject: [PATCH 07/10] Docs(whats-new): the 2.76.0 highlights
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

What's New opens on the first launch after the update with four highlights. First, Choose a date… in every task menu opens the month calendar, and @ opens it on the selected task in Vim mode (#991). Second, a task without a due date waits under No due date instead of in Today, with a matching Status board column whose drop clears the date (#990). Third, the Tasks list's Order menu puts high priority first inside each date group (#989). Fourth, Cloud conflicts settle without removing a kept note, and a file in the way moves to the next free name.
---
 packages/app-core/src/lib/whats-new.ts | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/packages/app-core/src/lib/whats-new.ts b/packages/app-core/src/lib/whats-new.ts
index e91578583..7ca057ac7 100644
--- a/packages/app-core/src/lib/whats-new.ts
+++ b/packages/app-core/src/lib/whats-new.ts
@@ -39,6 +39,27 @@ export const CLOUD_ANNOUNCEMENT = {
 } as const
 
 export const WHATS_NEW: readonly WhatsNewEntry[] = [
+  {
+    version: '2.76.0',
+    highlights: [
+      {
+        title: 'Any due date, two clicks away',
+        body: 'Right-click a task in the Tasks list, on the board or in the calendar and pick Choose a date… for a month calendar: a click on a day sets it. In Vim mode, @ opens it on the selected task.'
+      },
+      {
+        title: 'No due date has its own place',
+        body: 'A task without a due date now waits under No due date, after Upcoming, instead of in Today. The Status board has the same column, and dropping a card there clears its date.'
+      },
+      {
+        title: 'Tasks by priority',
+        body: 'The Tasks list’s new Order menu puts high priority first inside each group, still grouped by date (s in Vim mode, or :order priority). Note order brings back your notes’ line order.'
+      },
+      {
+        title: 'Cloud conflicts settle cleanly',
+        body: 'Choosing the other device’s version no longer removes a note this device kept, and when a file already holds its place, that file moves beside it under the next free name.'
+      }
+    ]
+  },
   {
     version: '2.75.0',
     highlights: [

From 36b8edbf53861241bb70249c1b57a3ea94c224f1 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 15:41:24 -0500
Subject: [PATCH 08/10] Release(cli): bundle the verified 0.11.0 terminal
 release

The bundled CLI is the floor a desktop build guarantees, and 0.11.0 is the
newest release (ZenNotes/tui#16). It is the terminal side of two Tasks
changes in this release, so zn and the app put a task in the same place:
a task without a due date waits under No due date in the list and on the
Status board (#990), and the list orders each date group by priority with
`O` or `:order priority`, sharing `tasks_list_order` with the app's Order
menu (#989). The pin is the release's terminal-release.json copied byte
for byte after it verified against packaging/release-signing/zn-release-1.pub
in ZenNotes/tui (source commit 88105711, integration protocol 1, all four
archives it names matching checksums.txt). Staged through
`npm run terminal:stage`; the native darwin-arm64 binary reports zn v0.11.0.
The in-app manual's CLI card says 0.11.0 and what it changes.
---
 apps/desktop/terminal-release.json | 20 ++++++++++----------
 packages/app-core/src/lib/help.ts  |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/apps/desktop/terminal-release.json b/apps/desktop/terminal-release.json
index e26e16417..2787ec893 100644
--- a/apps/desktop/terminal-release.json
+++ b/apps/desktop/terminal-release.json
@@ -3,24 +3,24 @@
   "release": {
     "repository": "ZenNotes/tui",
     "protocol": 1,
-    "version": "0.10.0",
-    "commit": "ced7926715549e85349e545f780a9e4bdca1585f",
+    "version": "0.11.0",
+    "commit": "881057116fa131212bf55c2d26f5eae42ef8d72d",
     "artifacts": {
       "darwin-arm64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_darwin_arm64.tar.gz",
-        "sha256": "0ab6f5596079cadb1329161dd9a6716f253355465a4ec8e527838fbb8ec97ee6"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.11.0/zn_0.11.0_darwin_arm64.tar.gz",
+        "sha256": "4b3548577ece83dc311bb67d72d4389a0a48a24c3bd56b9ba28aaa705303d33f"
       },
       "darwin-x64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_darwin_amd64.tar.gz",
-        "sha256": "dcbe9cfe7b116b1667e282dc81fcf13e8340b41d7f9575e0919481bd75908376"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.11.0/zn_0.11.0_darwin_amd64.tar.gz",
+        "sha256": "9dd6b9e19c3448ff947c7dd20eec511a6ffb4975616f0a78014c0e6b33047ddb"
       },
       "linux-arm64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_linux_arm64.tar.gz",
-        "sha256": "b7bd5f8a1b22988240d612879b3194a07212ba8d7a51112df822ba935680d3b0"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.11.0/zn_0.11.0_linux_arm64.tar.gz",
+        "sha256": "132eb7755693cea9911783c2097b6a18964e18658a95d99d93353bc1e56ee6e8"
       },
       "linux-x64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_linux_amd64.tar.gz",
-        "sha256": "d7aeca19b82c29b994cc0c2bcf6d3eff2767f3dea0842170462d21b6eda394f1"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.11.0/zn_0.11.0_linux_amd64.tar.gz",
+        "sha256": "44fd68b60dd82946a210dc715bea4d8d28363870ef7fcc335522e0a3e586d2bd"
       }
     }
   }
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 1773229c4..3c6bf5836 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -1274,9 +1274,9 @@ export const HELP_CLI: HelpCard[] = [
       'Builds with the Go terminal tool include `zn tui`. An existing desktop-managed CLI keeps itself up to date (see Updates arrive without a ZenNotes update); keep using the same `zn` commands. Settings shows the installed terminal version and offers Repair if an upgrade needs attention. Desktop-installed commands keep following the desktop vault, while the TUI remembers its own selection. Explicit `--vault` and `--server` flags still win. Set `ZENNOTES_WORKSPACE_SOURCE=terminal` to use the terminal default for a command, or `ZENNOTES_CLI_ENGINE=legacy` to run the previous CLI during the transition. Homebrew and manual installations stay managed by their own installer. A shortcut left behind by a moved Mac app or an old AppImage can be repaired from Settings: review the old target, replacement and backup path before choosing Repair shortcut. Note saves preserve creation dates in small files under `.zennotes/note-metadata` without changing Markdown; keep the `.zennotes` folder with vault backups. Explicit legacy rollback needs the original app resources to remain available.'
   },
   {
-    title: 'CLI 0.10.0 in desktop 2.74.0',
+    title: 'CLI 0.11.0 in desktop 2.76.0',
     body:
-      'On macOS and Linux, desktop 2.74.0 bundles CLI 0.10.0. Run `zn` in an interactive terminal or `zn tui` to open the editor. It includes editable settings, restored splits and sessions, comments, attachments, templates, bulk actions, and cross-note yank and paste. Use `:version` in the TUI for a persistent report and press `c` or `y` to copy it. `zn status`, `zn doctor`, `zn config`, and `zn completion` help with setup and scripts; `zn server` manages native local servers, also available through `:servers`. Since 0.6.1, `zn vault list` marks each entry `app` (saved by this desktop app) or `terminal` (saved by zn itself) and says which of them `zn use`, `zn disconnect` and `zn vault remove` act on; every command starts without waiting on terminals that do not answer a background-color query; and the help output lines up. 0.6.2 is the first release with a signed manifest, which is how this app keeps its managed zn current, 0.6.3 reads a line over a lone `-` as a paragraph, as the app does (#898), and 0.7.0’s `zn mcp` records an assistant’s edits for review in this app and no longer lets an assistant write into `.zennotes`. 0.7.1 leaves cancelled tasks out of the open ones in `zn task list` and in `zn mcp`’s `list_tasks` (#929), and when a server needs a token, its message points to Settings → MCP → Server token. 0.7.2 reads tasks in numbered lists and quotes the way the app does, in `zn task` and in `zn mcp`, and 0.8.0 adds `zn task watch`, which prints each task status change as it happens, and gives each task’s status in `zn task list --json` and in `list_tasks`. 0.8.1 keeps a finished task note in its Custom status column and gives `zn mcp` this app’s assistant instructions again, and 0.9.0 follows the vault’s Task folders in `zn task list`, `zn task watch` and `zn mcp`, and the TUI’s Settings saves both Tasks folder lists where every app reads them. 0.9.1 keeps a wikilink of more than one word from widening the TUI preview’s row and scrolling the whole screen. 0.9.2 lets a second `$` on a wrapped line reach the end of the line and makes three backticks a code fence, and 0.10.0 adds `zn base pages`, which gives every database record its record page so each can be linked. Run `zn update --check` to see the latest CLI release; for a desktop-managed CLI, ZenNotes installs it. The full command reference is at https://zennotes.org/tui/docs.'
+      'On macOS and Linux, desktop 2.76.0 bundles CLI 0.11.0. Run `zn` in an interactive terminal or `zn tui` to open the editor. It includes editable settings, restored splits and sessions, comments, attachments, templates, bulk actions, and cross-note yank and paste. Use `:version` in the TUI for a persistent report and press `c` or `y` to copy it. `zn status`, `zn doctor`, `zn config`, and `zn completion` help with setup and scripts; `zn server` manages native local servers, also available through `:servers`. Since 0.6.1, `zn vault list` marks each entry `app` (saved by this desktop app) or `terminal` (saved by zn itself) and says which of them `zn use`, `zn disconnect` and `zn vault remove` act on; every command starts without waiting on terminals that do not answer a background-color query; and the help output lines up. 0.6.2 is the first release with a signed manifest, which is how this app keeps its managed zn current, 0.6.3 reads a line over a lone `-` as a paragraph, as the app does (#898), and 0.7.0’s `zn mcp` records an assistant’s edits for review in this app and no longer lets an assistant write into `.zennotes`. 0.7.1 leaves cancelled tasks out of the open ones in `zn task list` and in `zn mcp`’s `list_tasks` (#929), and when a server needs a token, its message points to Settings → MCP → Server token. 0.7.2 reads tasks in numbered lists and quotes the way the app does, in `zn task` and in `zn mcp`, and 0.8.0 adds `zn task watch`, which prints each task status change as it happens, and gives each task’s status in `zn task list --json` and in `list_tasks`. 0.8.1 keeps a finished task note in its Custom status column and gives `zn mcp` this app’s assistant instructions again, and 0.9.0 follows the vault’s Task folders in `zn task list`, `zn task watch` and `zn mcp`, and the TUI’s Settings saves both Tasks folder lists where every app reads them. 0.9.1 keeps a wikilink of more than one word from widening the TUI preview’s row and scrolling the whole screen. 0.9.2 lets a second `$` on a wrapped line reach the end of the line and makes three backticks a code fence, 0.10.0 adds `zn base pages`, which gives every database record its record page so each can be linked, and 0.11.0 gives a task without a due date its own No due date group and Status board column, as this app does (#990), and orders the task list by priority with `O` or `:order priority` (#989). Run `zn update --check` to see the latest CLI release; for a desktop-managed CLI, ZenNotes installs it. The full command reference is at https://zennotes.org/tui/docs.'
   },
   {
     title: 'Updates arrive without a ZenNotes update',

From 49304a021398040860c0f77be295bffee163a552 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 15:48:51 -0500
Subject: [PATCH 09/10] Release: align desktop and shared packages at 2.76.0

---
 apps/desktop/package.json             |  2 +-
 apps/quicklook/package.json           |  2 +-
 apps/share-viewer/package.json        |  2 +-
 apps/web/package.json                 |  2 +-
 package-lock.json                     | 20 ++++++++++----------
 package.json                          |  2 +-
 packages/app-core/package.json        |  2 +-
 packages/bridge-contract/package.json |  2 +-
 packages/shared-domain/package.json   |  2 +-
 packages/shared-ui/package.json       |  2 +-
 10 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index f51e9d96e..560dc0ff4 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/desktop",
   "productName": "ZenNotes",
-  "version": "2.75.0",
+  "version": "2.76.0",
   "description": "ZenNotes desktop shell",
   "private": true,
   "main": "./out/main/index.js",
diff --git a/apps/quicklook/package.json b/apps/quicklook/package.json
index 8cd59b9bc..24ae2d8ec 100644
--- a/apps/quicklook/package.json
+++ b/apps/quicklook/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/quicklook",
   "private": true,
-  "version": "2.75.0",
+  "version": "2.76.0",
   "type": "module",
   "description": "The macOS Quick Look preview for Markdown files: the page it renders and the Swift extension that serves it",
   "homepage": "https://zennotes.org",
diff --git a/apps/share-viewer/package.json b/apps/share-viewer/package.json
index caf0f9053..942973056 100644
--- a/apps/share-viewer/package.json
+++ b/apps/share-viewer/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/share-viewer",
   "private": true,
-  "version": "2.75.0",
+  "version": "2.76.0",
   "type": "module",
   "description": "Read-only renderer for publicly shared ZenNotes, embedded by the zennotes.org website",
   "homepage": "https://zennotes.org",
diff --git a/apps/web/package.json b/apps/web/package.json
index f825378cd..9ee0f6b87 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/web",
   "private": true,
-  "version": "2.75.0",
+  "version": "2.76.0",
   "type": "module",
   "description": "ZenNotes web client for self-hosted and hosted deployments",
   "homepage": "https://zennotes.org",
diff --git a/package-lock.json b/package-lock.json
index e9d4604c8..e69c4b580 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "zennotes-monorepo",
-  "version": "2.75.0",
+  "version": "2.76.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "zennotes-monorepo",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "hasInstallScript": true,
       "workspaces": [
         "apps/*",
@@ -23,7 +23,7 @@
     },
     "apps/desktop": {
       "name": "@zennotes/desktop",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "license": "MIT",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
@@ -915,7 +915,7 @@
     },
     "apps/quicklook": {
       "name": "@zennotes/quicklook",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -989,7 +989,7 @@
     },
     "apps/share-viewer": {
       "name": "@zennotes/share-viewer",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -1061,7 +1061,7 @@
     },
     "apps/web": {
       "name": "@zennotes/web",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -16409,7 +16409,7 @@
     },
     "packages/app-core": {
       "name": "@zennotes/app-core",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -16498,14 +16498,14 @@
     },
     "packages/bridge-contract": {
       "name": "@zennotes/bridge-contract",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "devDependencies": {
         "typescript": "^5.7.2"
       }
     },
     "packages/shared-domain": {
       "name": "@zennotes/shared-domain",
-      "version": "2.75.0",
+      "version": "2.76.0",
       "dependencies": {
         "@scure/bip39": "2.4.0",
         "@zennotes/bridge-contract": "*",
@@ -16519,7 +16519,7 @@
     },
     "packages/shared-ui": {
       "name": "@zennotes/shared-ui",
-      "version": "2.75.0"
+      "version": "2.76.0"
     }
   }
 }
diff --git a/package.json b/package.json
index fd54730e3..2fd6ffa75 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "zennotes-monorepo",
   "private": true,
-  "version": "2.75.0",
+  "version": "2.76.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 a442be6f5..2f2aa29b7 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.75.0",
+  "version": "2.76.0",
   "type": "module",
   "exports": {
     "./main": "./src/main.tsx",
diff --git a/packages/bridge-contract/package.json b/packages/bridge-contract/package.json
index 40eb546a3..a08bf33cb 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.75.0",
+  "version": "2.76.0",
   "type": "module",
   "exports": {
     "./bridge": "./src/bridge.ts",
diff --git a/packages/shared-domain/package.json b/packages/shared-domain/package.json
index b450583df..e523638a3 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.75.0",
+  "version": "2.76.0",
   "type": "module",
   "exports": {
     "./*": "./src/*.ts"
diff --git a/packages/shared-ui/package.json b/packages/shared-ui/package.json
index afa056900..e907f5294 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.75.0",
+  "version": "2.76.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

From 616282187604fdef849a7faba52c2a2e7b5df94e Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Fri, 23 Oct 2026 15:57:36 -0500
Subject: [PATCH 10/10] Deps: zod 4.6.6 for the advisory that fails npm audit

CI's production dependency audit (`npm audit --omit=dev --audit-level=high`)
fails on zod 4.3.6 since GHSA-mrhx-c7xc-m3w5 (high): validating an
oversized constrained collection can exhaust memory. zod reaches the app
only through @modelcontextprotocol/sdk, which the bundled MCP server uses to
validate tool arguments, and the SDK accepts `^3.25 || ^4.0`.

4.6.6 is the first fixed release. Only the hoisted zod entry moves in the
lockfile (zod has no dependencies of its own); package.json files are
unchanged. The audit now reports no high advisories, and the desktop's MCP
and CLI suites pass on it. What the audit still lists is below that gate:
moderate fast-uri, hono, ip-address and smol-toml, and low katex.
---
 package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e69c4b580..626d971da 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16351,9 +16351,9 @@
       }
     },
     "node_modules/zod": {
-      "version": "4.3.6",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
-      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+      "version": "4.6.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.6.tgz",
+      "integrity": "sha512-4UmzQUF5fxvfcYHlbjBmejU+w+hbDnWFx4aS8kBx7nPBHcO2SqPbpAG8snbdg+Xse4pRefR98hgjFgIMCI/UhA==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"