From c95025988cff6714e53117b67ae62b72e6aba52c Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Tue, 20 Oct 2026 12:25:07 -0500
Subject: [PATCH 01/20] Fix(editor): eight more decorations redraw when a cut
 parse finishes

Follow-up to 10597fe9. Eight more live-preview and editor plugins read
the syntax tree but rebuilt only on an edit, a scroll and, for some, a
selection change: the code block font and language label, hashtags, live
template tokens, heading arrows, highlights, list indent and wikilinks.
CodeMirror parses under a time budget and finishes a cut parse in a later
update that changes nothing else, so whatever they drew from the partial
tree stayed until the next edit, scroll or cursor move. In the built app,
opening a 6 MB note and pressing G at once drew the last screen before
the parse reached it, and it stayed that way after the parse finished
about 0.9 s later: code in the body font with no language label, list
lines with no hanging indent, heading arrows on `# comment` lines in a
fence, and hashtag pills, live tokens, highlights and wikilinks inside
code.

Each plugin now also rebuilds when syntaxTree(update.startState) differs
from syntaxTree(update.state), as cm-live-preview and cm-wysiwyg-blocks
do. Each gets a test that changes only the tree (the markdown language
swapped in through a compartment) and expects its decorations: all eight
fail without this change and pass with it.

Cost: the seven rebuilds bound to the viewport take under 0.5 ms each.
The heading arrows' rebuild scans to the end of each visible heading's
section, about 37 ms at the top of a 3 MB note, which every cursor move
and keystroke there already pays; the guard adds one more per finished
cut parse (the first parse-only update after opening that note went from
about 73 ms to 112 ms). perf:desktop-runtime on 5,000 notes is unchanged:
note open 34.8 vs 36.6 ms, switch p50 24.4 vs 24.5 ms.

Not in this change: calloutFolding() draws nothing; it folds `> [!type]-`
callouts once per opened note from ensureSyntaxTree with a 200 ms budget,
so a collapsed callout past what that parses (about 2 MB on an M-series
Mac) opens expanded. Folding again on a tree change would close callouts
the reader opened, so it needs a fix of its own.

app-core 3,337 tests, typecheck clean.
---
 .../src/lib/cm-code-block-flair.test.ts       | 31 ++++++++++++++++
 .../app-core/src/lib/cm-code-block-flair.ts   |  8 +++-
 .../src/lib/cm-code-block-font.test.ts        | 33 +++++++++++++++++
 .../app-core/src/lib/cm-code-block-font.ts    |  8 +++-
 packages/app-core/src/lib/cm-hashtags.test.ts | 25 ++++++++++++-
 packages/app-core/src/lib/cm-hashtags.ts      |  8 +++-
 .../app-core/src/lib/cm-heading-fold.test.ts  | 29 ++++++++++++++-
 packages/app-core/src/lib/cm-heading-fold.ts  |  3 ++
 .../app-core/src/lib/cm-highlight.test.ts     | 37 ++++++++++++++++++-
 packages/app-core/src/lib/cm-highlight.ts     |  5 ++-
 .../src/lib/cm-live-template-tokens.test.ts   | 28 +++++++++++++-
 .../src/lib/cm-live-template-tokens.ts        | 10 ++++-
 .../src/lib/cm-markdown-list-indent.test.ts   | 32 +++++++++++++++-
 .../src/lib/cm-markdown-list-indent.ts        |  5 ++-
 .../src/lib/cm-wikilink-render.test.ts        | 30 ++++++++++++++-
 .../app-core/src/lib/cm-wikilink-render.ts    | 10 ++++-
 16 files changed, 287 insertions(+), 15 deletions(-)
 create mode 100644 packages/app-core/src/lib/cm-code-block-flair.test.ts
 create mode 100644 packages/app-core/src/lib/cm-code-block-font.test.ts

diff --git a/packages/app-core/src/lib/cm-code-block-flair.test.ts b/packages/app-core/src/lib/cm-code-block-flair.test.ts
new file mode 100644
index 000000000..bcb361924
--- /dev/null
+++ b/packages/app-core/src/lib/cm-code-block-flair.test.ts
@@ -0,0 +1,31 @@
+// @vitest-environment jsdom
+
+import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
+import { forceParsing } from '@codemirror/language'
+import { Compartment, EditorState } from '@codemirror/state'
+import { EditorView } from '@codemirror/view'
+import { describe, expect, it } from 'vitest'
+import { codeBlockFlairPlugin } from './cm-code-block-flair'
+
+describe('codeBlockFlairPlugin', () => {
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = 'Intro\n\n```js\nconst a = 1\n```\n\nEnd.'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), codeBlockFlairPlugin] })
+    })
+    expect(view.dom.querySelector('.cm-code-flair')).toBeNull()
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    const flairs = Array.from(view.dom.querySelectorAll('.cm-code-flair'))
+    expect(flairs.map((flair) => flair.textContent)).toEqual(['js'])
+    view.destroy()
+    parent.remove()
+  })
+})
diff --git a/packages/app-core/src/lib/cm-code-block-flair.ts b/packages/app-core/src/lib/cm-code-block-flair.ts
index ed63027e2..925f68a4c 100644
--- a/packages/app-core/src/lib/cm-code-block-flair.ts
+++ b/packages/app-core/src/lib/cm-code-block-flair.ts
@@ -140,7 +140,13 @@ export const codeBlockFlairPlugin = ViewPlugin.fromClass(
     }
 
     update(update: ViewUpdate): void {
-      if (update.docChanged || update.viewportChanged) {
+      if (
+        update.docChanged ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }
diff --git a/packages/app-core/src/lib/cm-code-block-font.test.ts b/packages/app-core/src/lib/cm-code-block-font.test.ts
new file mode 100644
index 000000000..2ee6c8371
--- /dev/null
+++ b/packages/app-core/src/lib/cm-code-block-font.test.ts
@@ -0,0 +1,33 @@
+// @vitest-environment jsdom
+
+import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
+import { forceParsing } from '@codemirror/language'
+import { Compartment, EditorState } from '@codemirror/state'
+import { EditorView } from '@codemirror/view'
+import { describe, expect, it } from 'vitest'
+import { codeBlockFontPlugin } from './cm-code-block-font'
+
+describe('codeBlockFontPlugin', () => {
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = 'Intro\n\n```js\nconst a = 1\n```\n\nEnd.'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), codeBlockFontPlugin] })
+    })
+    expect(view.dom.querySelector('.cm-code-block-line')).toBeNull()
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    const lines = Array.from(view.dom.querySelectorAll('.cm-code-block-line'))
+    expect(lines.map((line) => line.textContent)).toEqual(['```js', 'const a = 1', '```'])
+    expect(view.dom.querySelector('.cm-code-block-begin')?.textContent).toBe('```js')
+    expect(view.dom.querySelector('.cm-code-block-end')?.textContent).toBe('```')
+    view.destroy()
+    parent.remove()
+  })
+})
diff --git a/packages/app-core/src/lib/cm-code-block-font.ts b/packages/app-core/src/lib/cm-code-block-font.ts
index a5657114a..023bd0c24 100644
--- a/packages/app-core/src/lib/cm-code-block-font.ts
+++ b/packages/app-core/src/lib/cm-code-block-font.ts
@@ -78,7 +78,13 @@ export const codeBlockFontPlugin = ViewPlugin.fromClass(
     }
 
     update(update: ViewUpdate): void {
-      if (update.docChanged || update.viewportChanged) {
+      if (
+        update.docChanged ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }
diff --git a/packages/app-core/src/lib/cm-hashtags.test.ts b/packages/app-core/src/lib/cm-hashtags.test.ts
index 2e3e1ae0a..fe3e30537 100644
--- a/packages/app-core/src/lib/cm-hashtags.test.ts
+++ b/packages/app-core/src/lib/cm-hashtags.test.ts
@@ -2,7 +2,7 @@
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { forceParsing } from '@codemirror/language'
-import { EditorState } from '@codemirror/state'
+import { Compartment, EditorState } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { describe, expect, it } from 'vitest'
 import { hashtagExtension } from './cm-hashtags'
@@ -45,4 +45,27 @@ describe('hashtagPlugin', () => {
     expect(tags).toEqual(['#real'])
     view.destroy()
   })
+
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '```c\n#include <stdio.h>\n```\n\n#real'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), hashtagExtension] })
+    })
+    const tags = (): Array<string | null> =>
+      Array.from(view.dom.querySelectorAll('.cm-hashtag')).map((e) => e.textContent)
+    // No tree yet, so nothing says the fence is code.
+    expect(tags()).toEqual(['#include', '#real'])
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(tags()).toEqual(['#real'])
+    view.destroy()
+    parent.remove()
+  })
 })
diff --git a/packages/app-core/src/lib/cm-hashtags.ts b/packages/app-core/src/lib/cm-hashtags.ts
index dc8f5bb2d..7cf8cc616 100644
--- a/packages/app-core/src/lib/cm-hashtags.ts
+++ b/packages/app-core/src/lib/cm-hashtags.ts
@@ -79,7 +79,13 @@ const hashtagPlugin = ViewPlugin.fromClass(
       this.decorations = buildDecorations(view)
     }
     update(update: ViewUpdate): void {
-      if (update.docChanged || update.viewportChanged) {
+      if (
+        update.docChanged ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }
diff --git a/packages/app-core/src/lib/cm-heading-fold.test.ts b/packages/app-core/src/lib/cm-heading-fold.test.ts
index 1427cdfb9..34ee925ac 100644
--- a/packages/app-core/src/lib/cm-heading-fold.test.ts
+++ b/packages/app-core/src/lib/cm-heading-fold.test.ts
@@ -1,8 +1,8 @@
 // @vitest-environment jsdom
 
 import { describe, it, expect } from 'vitest'
-import { EditorState } from '@codemirror/state'
-import { foldedRanges, foldService, unfoldEffect } from '@codemirror/language'
+import { Compartment, EditorState } from '@codemirror/state'
+import { foldedRanges, foldService, forceParsing, unfoldEffect } from '@codemirror/language'
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { EditorView } from '@codemirror/view'
 import { foldAllOutline, foldAtCursor, headingFolding, unfoldAtCursor } from './cm-heading-fold'
@@ -106,6 +106,31 @@ describe('heading folding', () => {
     view.destroy()
     parent.remove()
   })
+
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '```bash\n# a comment\n```\n\n# Real\n\nbody'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), headingFolding()] })
+    })
+    const headingLines = (): Array<string | null> =>
+      Array.from(parent.querySelectorAll('.cm-heading-line')).map((line) => line.textContent)
+    // No tree yet, so nothing says the fence is code.
+    expect(headingLines()).toHaveLength(2)
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(headingLines()).toHaveLength(1)
+    expect(headingLines()[0]).toContain('# Real')
+
+    view.destroy()
+    parent.remove()
+  })
 })
 
 describe('list item folding (#848)', () => {
diff --git a/packages/app-core/src/lib/cm-heading-fold.ts b/packages/app-core/src/lib/cm-heading-fold.ts
index 2d1d5c7f7..e5898fd46 100644
--- a/packages/app-core/src/lib/cm-heading-fold.ts
+++ b/packages/app-core/src/lib/cm-heading-fold.ts
@@ -426,6 +426,9 @@ function headingArrowPlugin(showLevelLabels: boolean): Extension {
           update.docChanged ||
           update.viewportChanged ||
           update.selectionSet ||
+          // A parse cut short by its time budget finishes in a later update
+          // that changes nothing else.
+          syntaxTree(update.startState) !== syntaxTree(update.state) ||
           update.transactions.some((tr) =>
             tr.effects.some((e) => e.is(foldEffect) || e.is(unfoldEffect))
           )
diff --git a/packages/app-core/src/lib/cm-highlight.test.ts b/packages/app-core/src/lib/cm-highlight.test.ts
index 8657e87f8..4717ab57a 100644
--- a/packages/app-core/src/lib/cm-highlight.test.ts
+++ b/packages/app-core/src/lib/cm-highlight.test.ts
@@ -1,9 +1,17 @@
 // @vitest-environment jsdom
 
-import { EditorSelection, EditorState } from '@codemirror/state'
+import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
+import { forceParsing } from '@codemirror/language'
+import { Compartment, EditorSelection, EditorState } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { afterEach, describe, expect, it } from 'vitest'
-import { applyHighlight, HIGHLIGHT_COLORS, unwrapHighlight, wrapHighlight } from './cm-highlight'
+import {
+  applyHighlight,
+  HIGHLIGHT_COLORS,
+  highlightExtension,
+  unwrapHighlight,
+  wrapHighlight
+} from './cm-highlight'
 
 const views: EditorView[] = []
 function mount(doc: string, from: number, to: number): EditorView {
@@ -84,3 +92,28 @@ describe('applyHighlight (#416)', () => {
     expect(view.state.doc.toString()).toBe('the word here')
   })
 })
+
+describe('highlightExtension', () => {
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '```\n==code==\n```\n\nSome ==real== text'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), highlightExtension] })
+    })
+    views.push(view)
+    const tinted = (): Array<string | null> =>
+      Array.from(view.dom.querySelectorAll('.cm-hl')).map((e) => e.textContent)
+    // No tree yet, so nothing says the fence is code.
+    expect(tinted()).toEqual(['code', 'real'])
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(tinted()).toEqual(['real'])
+    expect(view.dom.textContent).toContain('==code==')
+  })
+})
diff --git a/packages/app-core/src/lib/cm-highlight.ts b/packages/app-core/src/lib/cm-highlight.ts
index f91431b10..50ba12795 100644
--- a/packages/app-core/src/lib/cm-highlight.ts
+++ b/packages/app-core/src/lib/cm-highlight.ts
@@ -246,7 +246,10 @@ const highlightPlugin = ViewPlugin.fromClass(
         update.docChanged ||
         update.selectionSet ||
         update.viewportChanged ||
-        update.focusChanged
+        update.focusChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
       ) {
         const built = buildDecorations(update.view)
         this.decorations = built.all
diff --git a/packages/app-core/src/lib/cm-live-template-tokens.test.ts b/packages/app-core/src/lib/cm-live-template-tokens.test.ts
index 9de5a2420..753e46899 100644
--- a/packages/app-core/src/lib/cm-live-template-tokens.test.ts
+++ b/packages/app-core/src/lib/cm-live-template-tokens.test.ts
@@ -2,7 +2,7 @@
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { forceParsing } from '@codemirror/language'
-import { EditorState } from '@codemirror/state'
+import { Compartment, EditorState } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { liveTemplateTokenExtension } from './cm-live-template-tokens'
@@ -81,4 +81,30 @@ describe('liveTemplateTokenExtension (#784)', () => {
     for (const fn of listeners) fn(storeState, prev)
     expect(view.dom.querySelector('.cm-live-token')?.textContent).toBe('2026-08-25')
   })
+
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    storeState.notes = [{ path: 'inbox/Evergreen.md', updatedAt: savedAt }]
+    const language = new Compartment()
+    const doc = '```\n{{modified_date}}\n```\n\nUpdated: {{modified_date}}'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({
+        doc,
+        selection: { anchor: 0 },
+        extensions: [language.of([]), liveTemplateTokenExtension]
+      })
+    })
+    views.push(view)
+    // No tree yet, so nothing says the fence is code.
+    expect(view.dom.querySelectorAll('.cm-live-token')).toHaveLength(2)
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(view.dom.querySelectorAll('.cm-live-token')).toHaveLength(1)
+    expect(view.dom.textContent).toContain('```{{modified_date}}```')
+  })
 })
diff --git a/packages/app-core/src/lib/cm-live-template-tokens.ts b/packages/app-core/src/lib/cm-live-template-tokens.ts
index c03fd1c2b..e0aafcbbe 100644
--- a/packages/app-core/src/lib/cm-live-template-tokens.ts
+++ b/packages/app-core/src/lib/cm-live-template-tokens.ts
@@ -122,7 +122,15 @@ const liveTemplateTokenPlugin = ViewPlugin.fromClass(
       const refreshed = update.transactions.some((tr) =>
         tr.effects.some((effect) => effect.is(refreshLiveTokensEffect))
       )
-      if (refreshed || update.docChanged || update.selectionSet || update.viewportChanged) {
+      if (
+        refreshed ||
+        update.docChanged ||
+        update.selectionSet ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }
diff --git a/packages/app-core/src/lib/cm-markdown-list-indent.test.ts b/packages/app-core/src/lib/cm-markdown-list-indent.test.ts
index a54cbcf02..5c44a9ca6 100644
--- a/packages/app-core/src/lib/cm-markdown-list-indent.test.ts
+++ b/packages/app-core/src/lib/cm-markdown-list-indent.test.ts
@@ -1,9 +1,16 @@
+// @vitest-environment jsdom
+
+import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
+import { forceParsing } from '@codemirror/language'
+import { Compartment, EditorState } from '@codemirror/state'
+import { EditorView } from '@codemirror/view'
 import { describe, expect, it } from 'vitest'
 import {
   listGuideStyle,
   listIndentPadCh,
   listPrefixCells,
-  markdownListHangingIndentCh
+  markdownListHangingIndentCh,
+  markdownListIndentPlugin
 } from './cm-markdown-list-indent'
 
 describe('markdownListHangingIndentCh', () => {
@@ -98,3 +105,26 @@ describe('listPrefixCells (#952)', () => {
     expect(listPrefixCells('>   - nested', 4)).toBeNull()
   })
 })
+
+describe('markdownListIndentPlugin', () => {
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '- one\n  - two\n\nplain'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), markdownListIndentPlugin] })
+    })
+    expect(view.dom.querySelector('.cm-markdown-list-line')).toBeNull()
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    const lines = Array.from(view.dom.querySelectorAll('.cm-markdown-list-line'))
+    expect(lines.map((line) => line.textContent)).toEqual(['- one', '  - two'])
+    view.destroy()
+    parent.remove()
+  })
+})
diff --git a/packages/app-core/src/lib/cm-markdown-list-indent.ts b/packages/app-core/src/lib/cm-markdown-list-indent.ts
index a7c5e49d4..535234d78 100644
--- a/packages/app-core/src/lib/cm-markdown-list-indent.ts
+++ b/packages/app-core/src/lib/cm-markdown-list-indent.ts
@@ -222,7 +222,10 @@ export const markdownListIndentPlugin = ViewPlugin.fromClass(
       if (
         update.docChanged ||
         update.viewportChanged ||
-        update.state.facet(listIndentConfig) !== update.startState.facet(listIndentConfig)
+        update.state.facet(listIndentConfig) !== update.startState.facet(listIndentConfig) ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
       ) {
         this.decorations = computeDecorations(update.view)
       }
diff --git a/packages/app-core/src/lib/cm-wikilink-render.test.ts b/packages/app-core/src/lib/cm-wikilink-render.test.ts
index c83637187..27117a665 100644
--- a/packages/app-core/src/lib/cm-wikilink-render.test.ts
+++ b/packages/app-core/src/lib/cm-wikilink-render.test.ts
@@ -2,7 +2,7 @@
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { forceParsing } from '@codemirror/language'
-import { EditorState } from '@codemirror/state'
+import { Compartment, EditorState } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { AssetMeta, NoteMeta } from '@shared/ipc'
@@ -85,6 +85,34 @@ describe('wikilinkRenderExtension', () => {
     expect(links.map((e) => e.textContent)).toEqual(['Foo'])
     view.destroy()
   })
+
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '```\n[[Foo]]\n```\n\nsee [[Bar]] end'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({
+        doc,
+        selection: { anchor: doc.length },
+        extensions: [language.of([]), wikilinkRenderExtension]
+      })
+    })
+    const links = (): Array<string | null> =>
+      Array.from(view.dom.querySelectorAll('.cm-wikilink')).map((e) => e.textContent)
+    // No tree yet, so nothing says the fence is code.
+    expect(links()).toEqual(['Foo', 'Bar'])
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(links()).toEqual(['Bar'])
+    expect(view.dom.textContent).toContain('[[Foo]]')
+    view.destroy()
+    parent.remove()
+  })
 })
 
 // #768: a wikilink at a note that does not exist yet is drawn apart from a live
diff --git a/packages/app-core/src/lib/cm-wikilink-render.ts b/packages/app-core/src/lib/cm-wikilink-render.ts
index 15ed75189..927dc2819 100644
--- a/packages/app-core/src/lib/cm-wikilink-render.ts
+++ b/packages/app-core/src/lib/cm-wikilink-render.ts
@@ -223,7 +223,15 @@ const wikilinkRenderPlugin = ViewPlugin.fromClass(
       const refreshed = update.transactions.some((tr) =>
         tr.effects.some((effect) => effect.is(refreshWikilinksEffect))
       )
-      if (refreshed || update.docChanged || update.selectionSet || update.viewportChanged) {
+      if (
+        refreshed ||
+        update.docChanged ||
+        update.selectionSet ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }

From abcb3ea0c9360e6489f3a5ac9aba4729ccdeab38 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Tue, 20 Oct 2026 12:47:58 -0500
Subject: [PATCH 02/20] Perf(editor): heading arrows no longer scan each
 visible section

The heading arrows rebuild on every cursor move, keystroke and finished
cut parse, and for each visible heading they found its whole section (a
line-by-line scan to the next heading of the same or a higher level, with
a syntax tree lookup for every `#` line) just to learn two things: whether
the heading folds at all and whether its fold is closed. For the H1 at the
top of a long note that scan is the whole note.

Whether a heading folds only depends on the next line: its section is
empty only on the last line or right above a heading of the same or a
higher level. Whether its fold is closed can only be true when a fold
starts at the end of its line, so the section end is now found in that
case alone. The decorations are the same: new tests pin the arrows, level
labels and folded states for headings with and without a body, every
level, a heading right above the same or a higher level, the last line,
`#` lines in code, folds that are not exactly a section and a trailing
newline, and they pass on the old code too. In the built app the plugin's
decorations matched in every compared state, before and after.

Cost of the plugin's update at the top of a 3 MB note (13,000 sections,
13,000 `# comment` lines in bash fences), built app over CDP, two runs per
build, medians:
- cursor move: 44.1 ms -> 0.0 ms (126 moves each)
- keystroke: 46.4 ms -> 0.0 ms (30 each)
- finished cut parse after opening: 43.1 ms -> 0.1 ms (6 each)
- with the top H1 folded, a move still finds that section: 49.7 vs 50.0 ms
- the whole cursor move (view.update), one more run each: 119.7 ms ->
  79.0 ms; most of what is left is computing the new state (58 to 65 ms)

app-core 3,341 tests, typecheck clean.
---
 .../app-core/src/lib/cm-heading-fold.test.ts  | 159 +++++++++++++++++-
 packages/app-core/src/lib/cm-heading-fold.ts  |  25 ++-
 2 files changed, 177 insertions(+), 7 deletions(-)

diff --git a/packages/app-core/src/lib/cm-heading-fold.test.ts b/packages/app-core/src/lib/cm-heading-fold.test.ts
index 34ee925ac..3f7791a18 100644
--- a/packages/app-core/src/lib/cm-heading-fold.test.ts
+++ b/packages/app-core/src/lib/cm-heading-fold.test.ts
@@ -2,7 +2,7 @@
 
 import { describe, it, expect } from 'vitest'
 import { Compartment, EditorState } from '@codemirror/state'
-import { foldedRanges, foldService, forceParsing, unfoldEffect } from '@codemirror/language'
+import { foldEffect, foldedRanges, foldService, forceParsing, unfoldEffect } from '@codemirror/language'
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { EditorView } from '@codemirror/view'
 import { foldAllOutline, foldAtCursor, headingFolding, unfoldAtCursor } from './cm-heading-fold'
@@ -272,3 +272,160 @@ describe('list item folding (#848)', () => {
     done()
   })
 })
+
+describe('heading arrows', () => {
+  const doc = [
+    '# Shapes', // 1
+    '', // 2
+    'Intro', // 3
+    '', // 4
+    '## Empty', // 5: a heading of the same level follows
+    '## Has body', // 6
+    '', // 7
+    'text', // 8
+    '', // 9
+    '### Deep', // 10
+    '#### Deeper', // 11
+    '##### Five', // 12
+    '###### Six', // 13
+    'six body', // 14
+    '## Same level next', // 15
+    '## Followed', // 16
+    '', // 17
+    '```bash', // 18
+    '# comment in fence', // 19
+    '## another in fence', // 20
+    '```', // 21
+    '', // 22
+    '    # indented code', // 23
+    '', // 24
+    '#nospace', // 25
+    '### Three then two', // 26: a higher level follows
+    '## Two', // 27
+    'x', // 28
+    '# Second H1', // 29
+    '## Last line heading' // 30
+  ].join('\n')
+
+  /** Lines each heading's fold hides, first to last. */
+  const sections: Record<number, [number, number]> = {
+    1: [2, 28],
+    6: [7, 14],
+    10: [11, 14],
+    11: [12, 14],
+    12: [13, 14],
+    13: [14, 14],
+    16: [17, 26],
+    27: [28, 28],
+    29: [30, 30]
+  }
+  const levels: Record<number, number> = { 1: 1, 6: 2, 10: 3, 11: 4, 12: 5, 13: 6, 16: 2, 27: 2, 29: 1 }
+
+  function mount(text: string): { view: EditorView; done: () => void } {
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({
+        doc: text,
+        extensions: [markdown({ base: markdownLanguage }), headingFolding({ showLevelLabels: true })]
+      })
+    })
+    return {
+      view,
+      done: () => {
+        view.destroy()
+        parent.remove()
+      }
+    }
+  }
+
+  /** `<line> <label> <arrow>` for every rendered line with any heading
+   *  decoration, once its line classes and the arrow's state attributes are
+   *  checked against the label and the arrow. */
+  function headingRows(view: EditorView): string[] {
+    const rows: string[] = []
+    for (const el of view.dom.querySelectorAll<HTMLElement>('.cm-line')) {
+      const arrow = el.querySelector<HTMLElement>('.cm-heading-fold-arrow')
+      const label = el.querySelector('.cm-heading-level-label')
+      const classes = [...el.classList].filter((name) => name.startsWith('cm-heading-line'))
+      if (!arrow && !label && classes.length === 0) continue
+      const folded = arrow?.classList.contains('is-folded') ?? false
+      expect(arrow?.classList.contains(folded ? 'is-folded' : 'is-open')).toBe(true)
+      expect(arrow?.getAttribute('aria-expanded')).toBe(String(!folded))
+      expect(arrow?.getAttribute('aria-label')).toBe(folded ? 'Expand heading' : 'Collapse heading')
+      expect(classes).toEqual([
+        'cm-heading-line',
+        `cm-heading-line-h${label?.textContent?.slice(1)}`,
+        ...(folded ? ['cm-heading-line-folded'] : [])
+      ])
+      rows.push(`${view.state.doc.lineAt(view.posAtDOM(el)).number} ${label?.textContent} ${arrow?.textContent}`)
+    }
+    return rows
+  }
+
+  const foldedLines = (view: EditorView): Array<[number, number]> => {
+    const out: Array<[number, number]> = []
+    foldedRanges(view.state).between(0, view.state.doc.length, (from, to) => {
+      out.push([view.state.doc.lineAt(from).number + 1, view.state.doc.lineAt(to).number])
+    })
+    return out
+  }
+
+  const arrowOn = (view: EditorView, line: number): HTMLElement => {
+    const arrow = [...view.dom.querySelectorAll<HTMLElement>('.cm-heading-fold-arrow')].find(
+      (el) => view.state.doc.lineAt(view.posAtDOM(el)).number === line
+    )
+    expect(arrow).toBeDefined()
+    return arrow!
+  }
+
+  const open = Object.keys(levels).map((line) => `${line} H${levels[Number(line)]} ▾`)
+
+  it('marks only headings with a section: not one right above the same or a higher level, the last line or code', () => {
+    const { view, done } = mount(doc)
+    expect(headingRows(view)).toEqual(open)
+    done()
+  })
+
+  it('marks a heading folded while its own section is folded, at every level', () => {
+    const { view, done } = mount(doc)
+    for (const [key, [first, last]] of Object.entries(sections)) {
+      const line = Number(key)
+      arrowOn(view, line).click()
+      expect(foldedLines(view)).toEqual([[first, last]])
+      expect(headingRows(view)).toEqual(
+        Object.keys(levels)
+          .map(Number)
+          .filter((other) => other < first || other > last)
+          .map((other) => `${other} H${levels[other]} ${other === line ? '▸' : '▾'}`)
+      )
+      arrowOn(view, line).click()
+      expect(foldedLines(view)).toEqual([])
+      expect(headingRows(view)).toEqual(open)
+    }
+    done()
+  })
+
+  it('keeps the arrow open for a fold that is not exactly its section', () => {
+    const { view, done } = mount(doc)
+    const line = (n: number) => view.state.doc.line(n)
+    // Starts where the section of line 6 starts but ends early.
+    view.dispatch({ effects: foldEffect.of({ from: line(6).to, to: line(8).to }) })
+    expect(headingRows(view)).toContain('6 H2 ▾')
+    view.dispatch({ effects: unfoldEffect.of({ from: line(6).to, to: line(8).to }) })
+    // Ends where the section of line 6 ends but starts later.
+    view.dispatch({ effects: foldEffect.of({ from: line(7).to, to: line(14).to }) })
+    expect(headingRows(view)).toContain('6 H2 ▾')
+    done()
+  })
+
+  it('gives a heading above a trailing newline a section, the empty last line', () => {
+    const { view, done } = mount('# Top\n\n## End\n')
+    expect(headingRows(view)).toEqual(['1 H1 ▾', '3 H2 ▾'])
+    arrowOn(view, 3).click()
+    expect(foldedLines(view)).toEqual([[4, 4]])
+    expect(headingRows(view)).toEqual(['1 H1 ▾', '3 H2 ▸'])
+    done()
+  })
+})
diff --git a/packages/app-core/src/lib/cm-heading-fold.ts b/packages/app-core/src/lib/cm-heading-fold.ts
index e5898fd46..557dcf1a7 100644
--- a/packages/app-core/src/lib/cm-heading-fold.ts
+++ b/packages/app-core/src/lib/cm-heading-fold.ts
@@ -165,6 +165,15 @@ function rangeForHeading(
   return { from, to }
 }
 
+/** Same answer as `rangeForHeading(...) !== null`, from the next line alone:
+ *  the section is empty only on the last line or right above a heading of
+ *  the same or a higher level. */
+function headingHasSection(state: EditorState, headingLine: number, level: number): boolean {
+  if (headingLine >= state.doc.lines) return false
+  const next = headingLevelAt(state, headingLine + 1)
+  return next === null || next > level
+}
+
 function exactFoldAtRange(
   state: EditorState,
   range: { from: number; to: number }
@@ -350,15 +359,19 @@ function buildDecorations(view: EditorView, showLevelLabels: boolean): Decoratio
     const last = state.doc.lineAt(Math.max(from, to - 1)).number
     for (let n = first; n <= last; n++) {
       const level = headingLevelAt(state, n)
-      if (level === null) continue
-      const range = rangeForHeading(state, n, level)
-      if (!range) continue
+      if (level === null || !headingHasSection(state, n, level)) continue
       const line = state.doc.line(n)
 
-      // Check whether this exact heading range is currently folded.
+      // Check whether this exact heading range is currently folded. The
+      // section end is a scan to the next heading of the same or a higher
+      // level, the whole note for a top H1, and this runs on every cursor
+      // move, so it is found only when a fold starts at the line's end.
       let isFolded = false
-      folded.between(range.from, range.to, (rf, rt) => {
-        if (rf === range.from && rt === range.to) {
+      let range: { from: number; to: number } | null | undefined
+      folded.between(line.to, line.to, (rf, rt) => {
+        if (rf !== line.to) return undefined
+        if (range === undefined) range = rangeForHeading(state, n, level)
+        if (range && rt === range.to) {
           isFolded = true
           return false
         }

From bf26b7ab23ee3c40eb80a4b6e41ab842675daa07 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Tue, 20 Oct 2026 13:42:18 -0500
Subject: [PATCH 03/20] Fix(callouts): collapsed callouts in long notes start
 folded too (#853)

A `> [!type]-` callout folds by default once per opened note. The plugin
did that in one pass when the note opened, from
ensureSyntaxTree(state, doc.length, 200) or else the tree as far as it
was parsed, and then marked the note done. CodeMirror parses a long note
only near the viewport (and 100 KB ahead of it), so a collapsed callout
past what 200 ms could parse never folded. On an M-series Mac a
collapsed callout at the end of a note folded at 0.5 and 1 MB and opened
expanded at 2, 3 and 5 MB; slower machines hit it on smaller notes.

The note now keeps where the callouts still wait to fold, mapped through
edits, and each time the tree grows it folds the collapsed callouts the
parser has produced since. A callout counts only once the parser has read
past it: the tree holds a node that starts after it, or nothing but blank
lines follows it. A parse that stops early closes whatever block is still
open where it stopped, so until then a long callout looks as if it ended
at its first paragraph. The tree's length cannot answer this, because
the note grammar's tree always spans the whole note
(cm-markdown-language.ts); a first version that read it passed with plain
markdown and failed in the app. A note swap (a whole-document replace
under noteEditingSync) starts over, as before, and the state still
outlives the live-preview reconfigures, so a theme switch or a later
parse does not close again what the reader opened.

Two rules for folds that now land after the note opened:
- A collapsed callout the reader typed or edited before the parser got
  there stays open. Typing a marker has never folded a callout (#853);
  typing a whole new `> [!note]-` in a part of a long note the parser has
  not reached is the same case and gets the same answer.
- A default fold never closes over the caret. CodeMirror already opens a
  fold the caret moves into; a fold that arrives after a jump (G, a
  search hit, a reopened tab's remembered caret) must not hide the line
  the reader is on.

Tests, on the note grammar and on plain markdown: a tree that reaches the
callout only in a later update (the language swapped in through a
compartment), a parse that stops inside a callout, collapsed callouts
that open and end the note, a callout typed before the parser got there,
and the caret. The new tests fail on the old code.

In the built app, a 3 MB note with a collapsed callout at the end, opened
and then jumped to its end: before, the callout became an open card about
0.55 s after the jump and stayed open; after, it went from raw text to
folded 0.59 to 0.73 s after the jump (three runs), stayed open once clicked
open through an edit and a reparse, a collapsed callout typed at the end
before the parse got there stayed open, and one holding the caret stayed
open. Long tasks after the jump: 118/152/199 ms before, 117/152/207 and
120/164/202 and 86/100/100/202 after.

app-core 3,345 tests on c9502598, typecheck clean.
---
 .../app-core/src/lib/cm-callout-fold.test.ts  | 115 +++++++++++-
 packages/app-core/src/lib/cm-callout-fold.ts  | 169 ++++++++++++++----
 2 files changed, 249 insertions(+), 35 deletions(-)

diff --git a/packages/app-core/src/lib/cm-callout-fold.test.ts b/packages/app-core/src/lib/cm-callout-fold.test.ts
index 64d4057d6..78d220f28 100644
--- a/packages/app-core/src/lib/cm-callout-fold.test.ts
+++ b/packages/app-core/src/lib/cm-callout-fold.test.ts
@@ -1,12 +1,13 @@
 // @vitest-environment jsdom
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
-import { forceParsing, foldedRanges } from '@codemirror/language'
-import { Compartment, EditorState } from '@codemirror/state'
+import { forceParsing, foldedRanges, syntaxTreeAvailable } from '@codemirror/language'
+import { Compartment, EditorState, type Extension } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { afterEach, describe, expect, it } from 'vitest'
-import { calloutFolding } from './cm-callout-fold'
+import { calloutFolding, toggleCalloutFold } from './cm-callout-fold'
 import { foldAllOutline, foldAtCursor, headingFolding } from './cm-heading-fold'
+import { noteMarkdown } from './cm-markdown-language'
 import { wysiwygBlocksPlugin } from './cm-wysiwyg-blocks'
 import { noteEditingSync } from './note-lifecycle-lock'
 
@@ -36,13 +37,16 @@ afterEach(() => {
   document.body.innerHTML = ''
 })
 
-function mount(doc = DOC, { caretLine = 14, livePreview = new Compartment() } = {}): EditorView {
+function mount(
+  doc = DOC,
+  { caretLine = 14, livePreview = new Compartment(), language = new Compartment(), parsed = true } = {}
+): EditorView {
   const parent = document.createElement('div')
   document.body.append(parent)
   const state = EditorState.create({
     doc,
     extensions: [
-      markdown({ base: markdownLanguage }),
+      language.of(parsed ? markdown({ base: markdownLanguage }) : []),
       headingFolding(),
       livePreview.of([wysiwygBlocksPlugin, calloutFolding()])
     ]
@@ -56,6 +60,27 @@ function mount(doc = DOC, { caretLine = 14, livePreview = new Compartment() } =
   return view
 }
 
+/** The editor's note grammar, whose tree always spans the whole note however
+ *  far the parse got, and plain markdown, whose tree ends where it stopped. */
+const GRAMMARS = [
+  ['the note grammar', noteMarkdown],
+  ['plain markdown', () => markdown({ base: markdownLanguage })]
+] as const
+
+/** Swap a markdown language in, so the tree changes and nothing else, as
+ *  when the parser reaches more of a long note; then parse up to `upto`. */
+function parseLater(
+  view: EditorView,
+  language: Compartment,
+  { upto = view.state.doc.length, grammar = noteMarkdown as () => Extension } = {}
+): void {
+  view.dispatch({ effects: language.reconfigure(grammar()) })
+  forceParsing(view, upto, 5000)
+}
+
+/** Paragraphs of filler, past where the first parse stops. */
+const FILLER = Array.from({ length: 400 }, (_, i) => `Filler paragraph ${i} keeps the note long.`).join('\n\n')
+
 /** Folded ranges as [first line, last line] pairs. */
 function folds(view: EditorView): [number, number][] {
   const out: [number, number][] = []
@@ -139,6 +164,86 @@ describe('foldable callouts in the editor (#853)', () => {
     expect(folds(view)).toEqual([[1, 2]])
   })
 
+  it.each(GRAMMARS)('folds a collapsed callout the parser reaches only after the note opened (%s)', async (_, grammar) => {
+    const doc = `${DOC}\n\n${FILLER}\n\n> [!note]- At the end\n> end body\n\nEnd.`
+    const language = new Compartment()
+    const view = mount(doc, { language, parsed: false })
+    await settle()
+    expect(folds(view)).toEqual([])
+    // The first parse covers the top of the note only.
+    parseLater(view, language, { upto: 500, grammar })
+    expect(syntaxTreeAvailable(view.state)).toBe(false)
+    await settle()
+    expect(folds(view)).toEqual([[3, 6]])
+    forceParsing(view, view.state.doc.length, 5000)
+    await settle()
+    const end = view.state.doc.lines - 3
+    expect(folds(view)).toEqual([
+      [3, 6],
+      [end, end + 1]
+    ])
+    // Opened by the reader, it stays open through later parses.
+    toggleCalloutFold(view, view.state.doc.line(end).from)
+    parseLater(view, language, { grammar })
+    await settle()
+    expect(folds(view)).toEqual([[3, 6]])
+  })
+
+  it.each(GRAMMARS)('waits for the end of a collapsed callout the parse stopped inside (%s)', async (_, grammar) => {
+    const doc = `${DOC}\n\n${FILLER}\n\n> [!warning]- Long\n> first part\n>\n> second part\n\nEnd.`
+    const language = new Compartment()
+    const view = mount(doc, { language, parsed: false })
+    await settle()
+    const title = view.state.doc.lines - 5
+    // Stopped inside it, the parse shows the callout ending at its first part.
+    parseLater(view, language, { upto: view.state.doc.line(title).from + 4, grammar })
+    expect(syntaxTreeAvailable(view.state)).toBe(false)
+    await settle()
+    expect(folds(view)).toEqual([[3, 6]])
+    forceParsing(view, view.state.doc.length, 5000)
+    await settle()
+    expect(folds(view)).toEqual([
+      [3, 6],
+      [title, title + 3]
+    ])
+  })
+
+  it.each(GRAMMARS)('folds collapsed callouts that open and end the note once a tree reaches them (%s)', async (_, grammar) => {
+    const doc = '> [!note]- First\n> first body\n\nMiddle.\n\n> [!note]- Last\n> last body\n'
+    const language = new Compartment()
+    const view = mount(doc, { language, parsed: false, caretLine: 4 })
+    await settle()
+    parseLater(view, language, { grammar })
+    await settle()
+    expect(folds(view)).toEqual([
+      [1, 2],
+      [6, 7]
+    ])
+  })
+
+  it('leaves open a collapsed callout typed where the parser had not reached', async () => {
+    const language = new Compartment()
+    const view = mount(DOC, { language, parsed: false })
+    await settle()
+    view.dispatch({
+      changes: { from: view.state.doc.length, insert: '\n\n> [!note]- Typed\n> typed body' },
+      selection: { anchor: 0 }
+    })
+    await settle()
+    parseLater(view, language)
+    await settle()
+    expect(folds(view)).toEqual([[3, 6]])
+  })
+
+  it('does not fold a collapsed callout over the caret', async () => {
+    const language = new Compartment()
+    const view = mount(`${DOC}\n\n> [!note]- Second\n> second body`, { language, parsed: false, caretLine: 4 })
+    await settle()
+    parseLater(view, language)
+    await settle()
+    expect(folds(view)).toEqual([[16, 17]])
+  })
+
   it('folds a callout from its title line with the fold keys, the whole body', async () => {
     const view = mount()
     await settle()
diff --git a/packages/app-core/src/lib/cm-callout-fold.ts b/packages/app-core/src/lib/cm-callout-fold.ts
index 253de367d..a03121b38 100644
--- a/packages/app-core/src/lib/cm-callout-fold.ts
+++ b/packages/app-core/src/lib/cm-callout-fold.ts
@@ -5,13 +5,17 @@
  * The fold range is the callout's whole blockquote below its title line, so
  * the chevron, the fold keys and Fold All close the same span and any of them
  * reopens what another closed. Collapsed callouts fold once each time a note
- * opens in the editor. That rides a state field which a note swap resets (a
+ * opens in the editor, each once the parser has read past its end: on a long
+ * note it reaches the rest only as the reader scrolls or jumps there. How far
+ * it has reached rides a state field which a note swap resets (a
  * whole-document replace under `noteEditingSync`) and which outlives the
  * live-preview compartment's reconfigures: a theme switch must not close
- * again what the reader opened.
+ * again what the reader opened. A callout the reader edited, or that holds
+ * the caret, is not folded.
  */
 import { ensureSyntaxTree, foldEffect, syntaxTree, unfoldEffect } from '@codemirror/language'
 import {
+  type ChangeDesc,
   type EditorState,
   type Extension,
   StateEffect,
@@ -82,19 +86,15 @@ export function enclosingFoldableCallout(state: EditorState, pos: number): Callo
   return null
 }
 
-/** Fold ranges of every callout with a marker, or only the collapsed ones.
- *  Pass a fully parsed tree (ensureSyntaxTree) to reach past the viewport. */
-export function foldableCalloutRanges(
-  state: EditorState,
-  tree: Tree = syntaxTree(state),
-  only?: CalloutFoldMarker
-): FoldRange[] {
+/** Fold ranges of every callout with a marker. Pass a fully parsed tree
+ *  (ensureSyntaxTree) to reach past the viewport. */
+export function foldableCalloutRanges(state: EditorState, tree: Tree = syntaxTree(state)): FoldRange[] {
   const ranges: FoldRange[] = []
   tree.iterate({
     enter: (ref) => {
       if (ref.name !== 'Blockquote') return undefined
       const callout = calloutOf(state, ref.node)
-      if (callout?.marker && callout.range && (!only || callout.marker === only)) {
+      if (callout?.marker && callout.range) {
         ranges.push(callout.range)
       }
       return undefined
@@ -152,7 +152,27 @@ export class CalloutFoldChevron extends WidgetType {
   }
 }
 
-const markCalloutDefaultsApplied = StateEffect.define<null>()
+interface Span {
+  from: number
+  to: number
+}
+
+/** The part of an opened note whose collapsed callouts have not been folded
+ *  yet, from `from` to the end. */
+interface PendingCallouts {
+  from: number
+  /** What changed in it since the note opened: a callout touching any of it
+   *  stays open, as typing a marker does not fold. */
+  edited: readonly Span[]
+  /** Whether the first pass, which parses ahead, has run. */
+  started: boolean
+}
+
+const calloutDefaultsReached = StateEffect.define<number>({
+  map: (pos, mapping) => mapping.mapPos(pos)
+})
+
+const unopened = (): PendingCallouts => ({ from: 0, edited: [], started: false })
 
 function replacesWholeDocument(tr: Transaction): boolean {
   let whole = false
@@ -162,19 +182,109 @@ function replacesWholeDocument(tr: Transaction): boolean {
   return whole
 }
 
-/** Whether this document's collapsed callouts have been folded yet. */
-const calloutDefaultsApplied = StateField.define<boolean>({
-  create: () => false,
-  update(applied, tr) {
-    if (tr.effects.some((effect) => effect.is(markCalloutDefaultsApplied))) return true
-    // Another note swapped in: its collapsed callouts start folded too.
-    if (applied && tr.docChanged && tr.annotation(noteEditingSync) && replacesWholeDocument(tr)) {
-      return false
+function mapPending(pending: PendingCallouts, changes: ChangeDesc): PendingCallouts {
+  const from = changes.mapPos(pending.from)
+  const edited = pending.edited.map((span) => ({
+    from: changes.mapPos(span.from, -1),
+    to: changes.mapPos(span.to, 1)
+  }))
+  changes.iterChangedRanges((_fromA, _toA, fromB, toB) => {
+    if (toB >= from) edited.push({ from: fromB, to: toB })
+  })
+  edited.sort((a, b) => a.from - b.from)
+  const merged: Span[] = []
+  for (const span of edited) {
+    const last = merged[merged.length - 1]
+    if (last && span.from <= last.to) last.to = Math.max(last.to, span.to)
+    else merged.push(span)
+  }
+  return { ...pending, from, edited: merged }
+}
+
+/** Null once the parser has reached the end of the note. */
+const pendingCallouts = StateField.define<PendingCallouts | null>({
+  create: unopened,
+  update(pending, tr) {
+    if (tr.docChanged) {
+      // Another note swapped in: its collapsed callouts start folded too.
+      if (tr.annotation(noteEditingSync) && replacesWholeDocument(tr)) pending = unopened()
+      else if (pending) pending = mapPending(pending, tr.changes)
+    }
+    for (const effect of tr.effects) {
+      if (!pending || !effect.is(calloutDefaultsReached)) continue
+      const from = Math.max(pending.from, effect.value)
+      pending =
+        from >= tr.state.doc.length
+          ? null
+          : { from, edited: pending.edited.filter((span) => span.to >= from), started: true }
     }
-    return applied
+    return pending
   }
 })
 
+/** Where the last node the parser has produced starts, -1 before it has
+ *  produced any. The tree's length does not say how far the parse got: the
+ *  note grammar's tree always spans the whole note (cm-markdown-language.ts). */
+function lastNodeStart(tree: Tree): number {
+  let node = tree.topNode.lastChild
+  if (!node) return -1
+  for (let child = node.lastChild; child; child = child.lastChild) node = child
+  return node.type.isTop ? -1 : node.from
+}
+
+/** Whether the parser has read past the block ending at `to`: it has produced
+ *  a node after it, or only blank lines follow it. Until then the block may go
+ *  on, and a parse that stopped early ends whatever is still open there. */
+function readPast(state: EditorState, to: number, lastStart: number): boolean {
+  if (lastStart > to) return true
+  const rest = state.doc.iterRange(to)
+  while (!rest.next().done) if (/\S/.test(rest.value)) return false
+  return true
+}
+
+/** Fold the collapsed callouts the parser has reached since the last pass. */
+function foldReachedCallouts(view: EditorView): void {
+  const { state } = view
+  const pending = state.field(pendingCallouts, false)
+  if (!pending) return
+  const tree = (!pending.started && ensureSyntaxTree(state, state.doc.length, 200)) || syntaxTree(state)
+  const lastStart = lastNodeStart(tree)
+  // A callout the parser has yet to produce starts on a later line.
+  const read = lastStart < 0 ? 0 : state.doc.lineAt(lastStart).to + 1
+  if (pending.started && read <= pending.from) return
+  const caret = state.selection.main.head
+  const folds: StateEffect<FoldRange>[] = []
+  let reached = read
+  let waiting = false
+  tree.iterate({
+    from: pending.from,
+    enter: (ref) => {
+      if (waiting) return false
+      if (ref.name !== 'Blockquote' || ref.from < pending.from) return undefined
+      const callout = calloutOf(state, ref.node)
+      if (callout?.marker !== '-') return undefined
+      // It and everything after it wait for the parser to read past its end.
+      if (!readPast(state, ref.to, lastStart)) {
+        reached = ref.from
+        waiting = true
+        return false
+      }
+      const { range } = callout
+      if (
+        range &&
+        !(caret > range.from && caret <= range.to) &&
+        !pending.edited.some((span) => span.from <= ref.to && span.to >= ref.from) &&
+        !foldedExactly(state, range)
+      ) {
+        folds.push(foldEffect.of(range))
+      }
+      return undefined
+    }
+  })
+  if (pending.started && folds.length === 0 && reached === pending.from) return
+  view.dispatch({ effects: [...folds, calloutDefaultsReached.of(reached)] })
+}
+
 const applyCalloutDefaults = ViewPlugin.fromClass(
   class {
     private scheduled = false
@@ -185,7 +295,12 @@ const applyCalloutDefaults = ViewPlugin.fromClass(
     }
 
     update(update: ViewUpdate): void {
-      this.check(update.view)
+      if (
+        syntaxTree(update.startState) !== syntaxTree(update.state) ||
+        update.startState.field(pendingCallouts, false) !== update.state.field(pendingCallouts, false)
+      ) {
+        this.check(update.view)
+      }
     }
 
     destroy(): void {
@@ -193,18 +308,12 @@ const applyCalloutDefaults = ViewPlugin.fromClass(
     }
 
     private check(view: EditorView): void {
-      if (this.scheduled || view.state.field(calloutDefaultsApplied, false) !== false) return
+      if (this.scheduled || !view.state.field(pendingCallouts, false)) return
       this.scheduled = true
       // Not from inside a view update: CodeMirror refuses a dispatch there.
       queueMicrotask(() => {
         this.scheduled = false
-        const { state } = view
-        if (this.destroyed || state.field(calloutDefaultsApplied, false) !== false) return
-        const tree = ensureSyntaxTree(state, state.doc.length, 200) ?? syntaxTree(state)
-        const folds = foldableCalloutRanges(state, tree, '-')
-          .filter((range) => !foldedExactly(state, range))
-          .map((range) => foldEffect.of(range))
-        view.dispatch({ effects: [...folds, markCalloutDefaultsApplied.of(null)] })
+        if (!this.destroyed) foldReachedCallouts(view)
       })
     }
   }
@@ -213,5 +322,5 @@ const applyCalloutDefaults = ViewPlugin.fromClass(
 /** Collapsed callouts start folded when a note opens. Live preview only, with
  *  the chevrons in `cm-wysiwyg-blocks.ts`; folding itself is `codeFolding()`. */
 export function calloutFolding(): Extension {
-  return [calloutDefaultsApplied, applyCalloutDefaults]
+  return [pendingCallouts, applyCalloutDefaults]
 }

From 1fdbe58182c06cf36ef1535c126ee34bd1a6cf36 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Tue, 20 Oct 2026 15:08:59 -0500
Subject: [PATCH 04/20] Fix(editor): a click below a short note keeps the
 keyboard in the editor (#970)

With Vim on, a click below the last line of a short note left the caret
showing but took every key away: a, A, i and I did nothing, and the
editor looked frozen until a click on the text itself.

The editor's scroller pads 20vh under the text and centers a capped text
column, so the space below a short note, the 16 px above it and the space
beside the column belong to `.cm-scroller`, not to the content.
CodeMirror listens for mousedown on the content only, so it never saw
those clicks, and the browser gave their focus to the scroller, which
CodeMirror makes focusable (tabindex -1) and where no key handler runs.

scrollerClickFocus (lib/cm-scroller-click-focus.ts) takes a left press
whose target is the scroller itself, prevents the default so the
scroller never takes the focus, puts the caret where CodeMirror's
posAtCoords puts it for that point (the document's end below the text,
its start above, the nearest column of that row beside it; Shift
extends the selection) and focuses the text. Vim keeps its mode, as it
does for a click on the text. Presses on the scrollbars, other buttons
and whatever the scroller holds (gutters, the content and its widgets)
are left alone. Every editor that shares the scroller's padding gets it:
note panes, the floating note window, the pinned reference pane, Quick
capture, the standalone file window and the template editor.

It does not start a drag selection from the padding; a press there only
places the caret.

In the built app over CDP, Vim on, a real mouse click at four spots
under a five-line note, each followed by A and typing: before, the three
outside the content (the padding at two heights and the left margin)
left the focus on `.cm-scroller` and the typing never arrived; after,
all four kept the focus in `.cm-content` and the typing landed on the
last line, in Normal mode with the block cursor. Vim off types there
too.

On Windows 11 (a VM), the shipped 2.73.0 zip against the same zip with
this branch's renderer, Vim on, a real click in the padding and then A
and a letter typed on the VM's keyboard: before, the focus stayed on
`.cm-scroller` and nothing was typed; after, the focus was in
`.cm-content` and the letter landed on the last line.

Tests: a click in the padding places the caret and focuses the text,
Shift-click extends, a press on a child, on either scrollbar or with
another button is ignored, and Vim stays in Normal mode. The three that
expect the new behavior fail without this change.

app-core 3,357 tests, typecheck clean.
---
 .../app-core/src/components/EditorPane.tsx    |  2 +
 .../src/components/ExternalFileApp.tsx        |  2 +
 .../src/components/FloatingNoteApp.tsx        |  2 +
 .../src/components/PinnedReferencePane.tsx    |  2 +
 .../src/components/QuickCaptureApp.tsx        |  2 +
 .../src/components/TemplateEditorModal.tsx    |  2 +
 .../src/lib/cm-scroller-click-focus.test.ts   | 93 +++++++++++++++++++
 .../src/lib/cm-scroller-click-focus.ts        | 45 +++++++++
 8 files changed, 150 insertions(+)
 create mode 100644 packages/app-core/src/lib/cm-scroller-click-focus.test.ts
 create mode 100644 packages/app-core/src/lib/cm-scroller-click-focus.ts

diff --git a/packages/app-core/src/components/EditorPane.tsx b/packages/app-core/src/components/EditorPane.tsx
index 3e8a72b65..4e9028a09 100644
--- a/packages/app-core/src/components/EditorPane.tsx
+++ b/packages/app-core/src/components/EditorPane.tsx
@@ -54,6 +54,7 @@ import {
 } from '@codemirror/commands'
 import { isImeComposing } from '../lib/ime'
 import { displayRowBoundaryKeymap } from '../lib/cm-display-row'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { noteMarkdown } from '../lib/cm-markdown-language'
 import { customCodeFenceHighlightExtension } from '../lib/cm-custom-code-languages'
 import { markdownLinkExtension } from '../lib/cm-markdown-links'
@@ -2078,6 +2079,7 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element {
             listIndentGuidesExt(s0.listIndentGuides)
           ]),
           highlightActiveLine(),
+          scrollerClickFocus,
           taskJumpHighlightField,
           yankHighlightExtension,
           vimVisualHighlightExtension,
diff --git a/packages/app-core/src/components/ExternalFileApp.tsx b/packages/app-core/src/components/ExternalFileApp.tsx
index e1278f24f..091628ad1 100644
--- a/packages/app-core/src/components/ExternalFileApp.tsx
+++ b/packages/app-core/src/components/ExternalFileApp.tsx
@@ -15,6 +15,7 @@ import { Annotation, Compartment, EditorState, type Transaction } from '@codemir
 import { EditorView, highlightActiveLine, keymap } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
 import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { mapDefaultHalfPageKeys, registerHalfPageMotion } from '../lib/cm-vim-half-page-motion'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
@@ -172,6 +173,7 @@ export function ExternalFileApp(): JSX.Element {
           vimImeGuard(() => prefs.vimBlockImeInNormalMode && !isTouchPrimaryDevice()),
           vimVisualHighlightExtension,
           history(),
+          scrollerClickFocus,
           floatingCursorDrawSelection(),
           editorTabSize(prefs.editorTabSize),
           highlightActiveLine(),
diff --git a/packages/app-core/src/components/FloatingNoteApp.tsx b/packages/app-core/src/components/FloatingNoteApp.tsx
index c957b4778..e196a9acf 100644
--- a/packages/app-core/src/components/FloatingNoteApp.tsx
+++ b/packages/app-core/src/components/FloatingNoteApp.tsx
@@ -26,6 +26,7 @@ import {
 } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
 import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { noteMarkdown } from '../lib/cm-markdown-language'
@@ -348,6 +349,7 @@ export function FloatingNoteApp({ notePath }: { notePath: string }): JSX.Element
           vimImeGuard(() => prefs.vimBlockImeInNormalMode && !isTouchPrimaryDevice()),
           vimVisualHighlightExtension,
           history(),
+          scrollerClickFocus,
           floatingCursorDrawSelection(),
           editorTabSize(prefs.editorTabSize),
           highlightActiveLine(),
diff --git a/packages/app-core/src/components/PinnedReferencePane.tsx b/packages/app-core/src/components/PinnedReferencePane.tsx
index c9f975654..0f018562a 100644
--- a/packages/app-core/src/components/PinnedReferencePane.tsx
+++ b/packages/app-core/src/components/PinnedReferencePane.tsx
@@ -27,6 +27,7 @@ import {
 } from '@codemirror/view'
 import { vim } from '@replit/codemirror-vim'
 import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { isTouchPrimaryDevice, vimImeGuard } from '../lib/cm-vim-ime-guard'
 import { getKeymapBinding, type KeymapOverrides } from '../lib/keymaps'
@@ -248,6 +249,7 @@ export function PinnedReferencePane(): JSX.Element | null {
           ),
           vimVisualHighlightExtension,
           history(),
+          scrollerClickFocus,
           drawSelectionCompartment.of(cursorDrawSelection(s0.cursorBlink)),
           tabSizeCompartment.of([
             editorTabSize(s0.editorTabSize),
diff --git a/packages/app-core/src/components/QuickCaptureApp.tsx b/packages/app-core/src/components/QuickCaptureApp.tsx
index 79e08242c..046079a22 100644
--- a/packages/app-core/src/components/QuickCaptureApp.tsx
+++ b/packages/app-core/src/components/QuickCaptureApp.tsx
@@ -43,6 +43,7 @@ import {
 } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
 import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { registerDisplayLineMotion } from '../lib/cm-vim-display-line'
@@ -482,6 +483,7 @@ export function QuickCaptureApp(): JSX.Element {
             ])
           ),
           history(),
+          scrollerClickFocus,
           storedCursorDrawSelection(PREFS_KEY, () => loadPrefs().cursorBlink),
           editorTabSize(prefs.editorTabSize),
           highlightActiveLine(),
diff --git a/packages/app-core/src/components/TemplateEditorModal.tsx b/packages/app-core/src/components/TemplateEditorModal.tsx
index abcdf21dc..5fa7bb860 100644
--- a/packages/app-core/src/components/TemplateEditorModal.tsx
+++ b/packages/app-core/src/components/TemplateEditorModal.tsx
@@ -10,6 +10,7 @@ import { Compartment, EditorState, type Transaction } from '@codemirror/state'
 import { EditorView, highlightActiveLine, keymap, tooltips } from '@codemirror/view'
 import { vim } from '@replit/codemirror-vim'
 import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { isTouchPrimaryDevice, vimImeGuard } from '../lib/cm-vim-ime-guard'
@@ -130,6 +131,7 @@ export function TemplateEditorModal({
         ),
         vimVisualHighlightExtension,
         history(),
+        scrollerClickFocus,
         cursorDrawSelection(useStore.getState().cursorBlink),
         editorTabSize(useStore.getState().editorTabSize),
         highlightActiveLine(),
diff --git a/packages/app-core/src/lib/cm-scroller-click-focus.test.ts b/packages/app-core/src/lib/cm-scroller-click-focus.test.ts
new file mode 100644
index 000000000..72e601903
--- /dev/null
+++ b/packages/app-core/src/lib/cm-scroller-click-focus.test.ts
@@ -0,0 +1,93 @@
+// @vitest-environment jsdom
+
+import { EditorSelection, EditorState, type Extension } from '@codemirror/state'
+import { EditorView } from '@codemirror/view'
+import { getCM, vim } from '@replit/codemirror-vim'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { scrollerClickFocus } from './cm-scroller-click-focus'
+
+const DOC = '# Short\n\nfirst line\nsecond line'
+
+let views: EditorView[] = []
+afterEach(() => {
+  for (const view of views) view.destroy()
+  views = []
+  document.body.innerHTML = ''
+})
+
+/** An editor whose scroller is 800 by 600 with its text ending far above the
+ *  bottom. jsdom has no layout, so the size and the position CodeMirror reads
+ *  for a point in the padding (the document's end) are stubbed. */
+function mount(extensions: Extension[] = []): { view: EditorView; focus: ReturnType<typeof vi.fn> } {
+  const view = new EditorView({
+    state: EditorState.create({
+      doc: DOC,
+      selection: EditorSelection.cursor(3),
+      extensions: [scrollerClickFocus, ...extensions]
+    }),
+    parent: document.body.appendChild(document.createElement('div'))
+  })
+  views.push(view)
+  Object.defineProperty(view.scrollDOM, 'clientWidth', { value: 800 })
+  Object.defineProperty(view.scrollDOM, 'clientHeight', { value: 600 })
+  vi.spyOn(view, 'posAtCoords').mockReturnValue(DOC.length)
+  const focus = vi.fn()
+  view.focus = focus
+  return { view, focus }
+}
+
+function press(target: Element, init: MouseEventInit): MouseEvent {
+  const event = new MouseEvent('mousedown', { bubbles: true, cancelable: true, button: 0, ...init })
+  target.dispatchEvent(event)
+  return event
+}
+
+describe('scrollerClickFocus (#970)', () => {
+  it('puts the caret where the click points and focuses the text, not the scroller', () => {
+    const { view, focus } = mount()
+    const event = press(view.scrollDOM, { clientX: 120, clientY: 520 })
+    // Prevented, so the browser does not give the scroller the focus.
+    expect(event.defaultPrevented).toBe(true)
+    expect(view.posAtCoords).toHaveBeenCalledWith({ x: 120, y: 520 }, false)
+    expect(view.state.selection.main.empty).toBe(true)
+    expect(view.state.selection.main.head).toBe(DOC.length)
+    expect(focus).toHaveBeenCalledTimes(1)
+  })
+
+  it('extends the selection on Shift-click', () => {
+    const { view } = mount()
+    press(view.scrollDOM, { clientX: 120, clientY: 520, shiftKey: true })
+    expect(view.state.selection.main.anchor).toBe(3)
+    expect(view.state.selection.main.head).toBe(DOC.length)
+  })
+
+  it('leaves clicks on what the scroller holds to their owners', () => {
+    const { view, focus } = mount()
+    const gutter = view.scrollDOM.insertBefore(document.createElement('div'), view.contentDOM)
+    const event = press(gutter, { clientX: 4, clientY: 40 })
+    expect(event.defaultPrevented).toBe(false)
+    expect(view.state.selection.main.head).toBe(3)
+    expect(focus).not.toHaveBeenCalled()
+  })
+
+  it('leaves a press on the scrollbars and other buttons alone', () => {
+    const { view, focus } = mount()
+    const presses = [
+      press(view.scrollDOM, { clientX: 805, clientY: 300 }),
+      press(view.scrollDOM, { clientX: 300, clientY: 605 }),
+      press(view.scrollDOM, { clientX: 120, clientY: 520, button: 2 })
+    ]
+    expect(presses.map((event) => event.defaultPrevented)).toEqual([false, false, false])
+    expect(view.state.selection.main.head).toBe(3)
+    expect(focus).not.toHaveBeenCalled()
+  })
+
+  it('keeps Vim in Normal mode', () => {
+    const { view } = mount([vim()])
+    press(view.scrollDOM, { clientX: 120, clientY: 520 })
+    const state = getCM(view)?.state.vim as { insertMode?: boolean; visualMode?: boolean }
+    expect(state.insertMode).toBeFalsy()
+    expect(state.visualMode).toBeFalsy()
+    expect(view.state.doc.lineAt(view.state.selection.main.head).number).toBe(4)
+  })
+})
diff --git a/packages/app-core/src/lib/cm-scroller-click-focus.ts b/packages/app-core/src/lib/cm-scroller-click-focus.ts
new file mode 100644
index 000000000..1f8c2c00f
--- /dev/null
+++ b/packages/app-core/src/lib/cm-scroller-click-focus.ts
@@ -0,0 +1,45 @@
+import { EditorSelection } from '@codemirror/state'
+import { ViewPlugin, type EditorView } from '@codemirror/view'
+
+/**
+ * A click in the editor's empty space places the caret and keeps the keyboard
+ * in the editor. The scroller pads 20vh under the text and centers a capped
+ * text column, so the space below a short note, above it and beside the
+ * column belongs to `.cm-scroller`, not to the content. CodeMirror listens on
+ * the content only, so it never saw those clicks, and the browser gave their
+ * focus to the scroller (focusable, tabindex -1), where no key handler runs:
+ * Vim's keys did nothing and the editor looked frozen until a click on the
+ * text (#970). The caret goes where CodeMirror puts it for coordinates there:
+ * the document's end below the text, its start above, the nearest column of
+ * that row beside it.
+ */
+export const scrollerClickFocus = ViewPlugin.fromClass(
+  class {
+    constructor(readonly view: EditorView) {
+      view.scrollDOM.addEventListener('mousedown', this.onMouseDown)
+    }
+
+    onMouseDown = (event: MouseEvent): void => {
+      const { view } = this
+      const scroller = view.scrollDOM
+      // Gutters, the content and its widgets handle their own clicks.
+      if (event.button !== 0 || event.target !== scroller || event.defaultPrevented) return
+      // A press on the scroller's own scrollbars stays a scrollbar drag.
+      const rect = scroller.getBoundingClientRect()
+      if (event.clientX >= rect.left + scroller.clientLeft + scroller.clientWidth) return
+      if (event.clientY >= rect.top + scroller.clientTop + scroller.clientHeight) return
+      event.preventDefault()
+      const pos = view.posAtCoords({ x: event.clientX, y: event.clientY }, false)
+      const main = view.state.selection.main
+      view.dispatch({
+        selection: event.shiftKey ? EditorSelection.range(main.anchor, pos) : EditorSelection.cursor(pos),
+        userEvent: 'select.pointer'
+      })
+      view.focus()
+    }
+
+    destroy(): void {
+      this.view.scrollDOM.removeEventListener('mousedown', this.onMouseDown)
+    }
+  }
+)

From 0305e8300b2c3dd3bb46e856686ade18de9f80b3 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Tue, 20 Oct 2026 15:18:37 -0500
Subject: [PATCH 05/20] Fix(editor): Ctrl+Shift+Z redoes on Windows too (#967)

The editor's context menu lists Redo as Mod+Shift+Z, which reads
Ctrl+Shift+Z on Windows, but there only Ctrl+Y redid. CodeMirror's
historyKeymap binds Mod-y everywhere but macOS (where redo is
Cmd+Shift+Z) and adds Ctrl-Shift-z on Linux only. Windows apps take both,
and Ctrl+Shift+Z is the one the reporter reached for.

appHistoryKeymap (lib/history-keymap.ts) is CodeMirror's keymap plus
Ctrl-Shift-z on Windows, and every editor that used historyKeymap now
uses it: note panes, the floating note window, the pinned reference
pane, Quick capture, the standalone file window and the template editor.
Ctrl+Y keeps redoing, and the macOS and Linux bindings are unchanged.
The menu keeps its hint, which is now true on every platform.

On Windows 11 (a VM), keys pressed on the VM's keyboard, against the
shipped 2.73.0 zip and the same zip with this branch's renderer (this
branch's main bundle is byte-identical to the shipped one): with Vim
off, after an undo, Ctrl+Shift+Z did nothing before and redid after,
and Ctrl+Y redid in both; with Vim on, after u, Ctrl+Shift+Z did nothing
before and redid after. The context menu there shows Redo as
Ctrl+Shift+Z.

Tests, on CodeMirror's Windows platform: its own keymap leaves
Ctrl+Shift+Z unbound (which also proves the platform took), and
appHistoryKeymap redoes on Ctrl+Shift+Z and on Ctrl+Y. The Ctrl+Shift+Z
test fails without this change.

app-core 3,357 tests, typecheck clean.
---
 .../app-core/src/components/EditorPane.tsx    |  4 +-
 .../src/components/ExternalFileApp.tsx        |  5 +-
 .../src/components/FloatingNoteApp.tsx        |  5 +-
 .../src/components/PinnedReferencePane.tsx    |  5 +-
 .../src/components/QuickCaptureApp.tsx        |  5 +-
 .../src/components/TemplateEditorModal.tsx    |  5 +-
 .../app-core/src/lib/history-keymap.test.ts   | 62 +++++++++++++++++++
 packages/app-core/src/lib/history-keymap.ts   | 13 ++++
 8 files changed, 92 insertions(+), 12 deletions(-)
 create mode 100644 packages/app-core/src/lib/history-keymap.test.ts
 create mode 100644 packages/app-core/src/lib/history-keymap.ts

diff --git a/packages/app-core/src/components/EditorPane.tsx b/packages/app-core/src/components/EditorPane.tsx
index 4e9028a09..4998f2001 100644
--- a/packages/app-core/src/components/EditorPane.tsx
+++ b/packages/app-core/src/components/EditorPane.tsx
@@ -42,7 +42,6 @@ import type { AssetMeta, ImportedAsset, NoteComment, NoteFolder } from '@shared/
 import { registerNoteEditor } from '../lib/note-editor-context'
 import { noteEditorHostExtension } from '../lib/editor-host'
 import {
-  historyKeymap,
   indentWithTab,
   moveLineDown,
   moveLineUp,
@@ -55,6 +54,7 @@ import {
 import { isImeComposing } from '../lib/ime'
 import { displayRowBoundaryKeymap } from '../lib/cm-display-row'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { noteMarkdown } from '../lib/cm-markdown-language'
 import { customCodeFenceHighlightExtension } from '../lib/cm-custom-code-languages'
 import { markdownLinkExtension } from '../lib/cm-markdown-links'
@@ -438,7 +438,7 @@ function buildEditorKeymap(vimMode: boolean, overrides: KeymapOverrides): Extens
     ...mathBlockArrowKeymap,
     indentWithTab,
     ...vimAwareDefaultKeymap(vimMode),
-    ...historyKeymap,
+    ...appHistoryKeymap,
     ...vimAwareSearchKeymap(vimMode)
   ])
 }
diff --git a/packages/app-core/src/components/ExternalFileApp.tsx b/packages/app-core/src/components/ExternalFileApp.tsx
index 091628ad1..286b8b2e2 100644
--- a/packages/app-core/src/components/ExternalFileApp.tsx
+++ b/packages/app-core/src/components/ExternalFileApp.tsx
@@ -14,8 +14,9 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Annotation, Compartment, EditorState, type Transaction } from '@codemirror/state'
 import { EditorView, highlightActiveLine, keymap } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
-import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { history, indentWithTab } from '@codemirror/commands'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { mapDefaultHalfPageKeys, registerHalfPageMotion } from '../lib/cm-vim-half-page-motion'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
@@ -193,7 +194,7 @@ export function ExternalFileApp(): JSX.Element {
             ...vimHalfPageKeymap(prefs.vimMode, {}),
             indentWithTab,
             ...vimAwareDefaultKeymap(prefs.vimMode),
-            ...historyKeymap,
+            ...appHistoryKeymap,
             ...vimAwareSearchKeymap(prefs.vimMode)
           ]),
           EditorView.domEventHandlers({
diff --git a/packages/app-core/src/components/FloatingNoteApp.tsx b/packages/app-core/src/components/FloatingNoteApp.tsx
index e196a9acf..f9bae9a0a 100644
--- a/packages/app-core/src/components/FloatingNoteApp.tsx
+++ b/packages/app-core/src/components/FloatingNoteApp.tsx
@@ -25,8 +25,9 @@ import {
   lineNumbers
 } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
-import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { history, indentWithTab } from '@codemirror/commands'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { noteMarkdown } from '../lib/cm-markdown-language'
@@ -370,7 +371,7 @@ export function FloatingNoteApp({ notePath }: { notePath: string }): JSX.Element
             ...vimHalfPageKeymap(prefs.vimMode, {}),
             indentWithTab,
             ...vimAwareDefaultKeymap(prefs.vimMode),
-            ...historyKeymap,
+            ...appHistoryKeymap,
             ...vimAwareSearchKeymap(prefs.vimMode)
           ]),
           EditorView.updateListener.of((upd) => {
diff --git a/packages/app-core/src/components/PinnedReferencePane.tsx b/packages/app-core/src/components/PinnedReferencePane.tsx
index 0f018562a..63add99cc 100644
--- a/packages/app-core/src/components/PinnedReferencePane.tsx
+++ b/packages/app-core/src/components/PinnedReferencePane.tsx
@@ -26,8 +26,9 @@ import {
   tooltips
 } from '@codemirror/view'
 import { vim } from '@replit/codemirror-vim'
-import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { history, indentWithTab } from '@codemirror/commands'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { isTouchPrimaryDevice, vimImeGuard } from '../lib/cm-vim-ime-guard'
 import { getKeymapBinding, type KeymapOverrides } from '../lib/keymaps'
@@ -143,7 +144,7 @@ function buildReferenceKeymap(vimMode: boolean, overrides: KeymapOverrides): Ext
     }),
     indentWithTab,
     ...vimAwareDefaultKeymap(vimMode),
-    ...historyKeymap,
+    ...appHistoryKeymap,
     ...vimAwareSearchKeymap(vimMode)
   ])
 }
diff --git a/packages/app-core/src/components/QuickCaptureApp.tsx b/packages/app-core/src/components/QuickCaptureApp.tsx
index 046079a22..e2d24b460 100644
--- a/packages/app-core/src/components/QuickCaptureApp.tsx
+++ b/packages/app-core/src/components/QuickCaptureApp.tsx
@@ -42,8 +42,9 @@ import {
   placeholder
 } from '@codemirror/view'
 import { Vim, vim } from '@replit/codemirror-vim'
-import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { history, indentWithTab } from '@codemirror/commands'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap, vimAwareSearchKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { registerDisplayLineMotion } from '../lib/cm-vim-display-line'
@@ -534,7 +535,7 @@ export function QuickCaptureApp(): JSX.Element {
             ...vimHalfPageKeymap(prefs.vimMode, {}),
             indentWithTab,
             ...vimAwareDefaultKeymap(prefs.vimMode),
-            ...historyKeymap,
+            ...appHistoryKeymap,
             ...vimAwareSearchKeymap(prefs.vimMode)
           ]),
           EditorView.updateListener.of((upd) => {
diff --git a/packages/app-core/src/components/TemplateEditorModal.tsx b/packages/app-core/src/components/TemplateEditorModal.tsx
index 5fa7bb860..ec12d8378 100644
--- a/packages/app-core/src/components/TemplateEditorModal.tsx
+++ b/packages/app-core/src/components/TemplateEditorModal.tsx
@@ -9,8 +9,9 @@ import { useCallback, useMemo, useRef, useState } from 'react'
 import { Compartment, EditorState, type Transaction } from '@codemirror/state'
 import { EditorView, highlightActiveLine, keymap, tooltips } from '@codemirror/view'
 import { vim } from '@replit/codemirror-vim'
-import { history, historyKeymap, indentWithTab } from '@codemirror/commands'
+import { history, indentWithTab } from '@codemirror/commands'
 import { scrollerClickFocus } from '../lib/cm-scroller-click-focus'
+import { appHistoryKeymap } from '../lib/history-keymap'
 import { vimAwareDefaultKeymap, vimAwareMarkdownKeymap } from '../lib/cm-vim-default-keymap'
 import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight'
 import { isTouchPrimaryDevice, vimImeGuard } from '../lib/cm-vim-ime-guard'
@@ -179,7 +180,7 @@ export function TemplateEditorModal({
         keymap.of([
           indentWithTab,
           ...vimAwareDefaultKeymap(vimModeRef.current),
-          ...historyKeymap
+          ...appHistoryKeymap
         ]),
         editorTheme,
         EditorView.updateListener.of((upd) => {
diff --git a/packages/app-core/src/lib/history-keymap.test.ts b/packages/app-core/src/lib/history-keymap.test.ts
new file mode 100644
index 000000000..c65e3d4e8
--- /dev/null
+++ b/packages/app-core/src/lib/history-keymap.test.ts
@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+
+import { vi } from 'vitest'
+
+// CodeMirror picks its platform when @codemirror/view loads, so Windows has to
+// be in place before the imports below run.
+vi.hoisted(() => {
+  Object.defineProperty(navigator, 'platform', { value: 'Win32', configurable: true })
+})
+
+import { history, historyKeymap, undo } from '@codemirror/commands'
+import { EditorState, type Extension } from '@codemirror/state'
+import { EditorView, keymap, runScopeHandlers, type KeyBinding } from '@codemirror/view'
+import { afterEach, describe, expect, it } from 'vitest'
+import { appHistoryKeymap } from './history-keymap'
+
+let views: EditorView[] = []
+afterEach(() => {
+  for (const view of views) view.destroy()
+  views = []
+  document.body.innerHTML = ''
+})
+
+/** An editor whose last edit was just undone, so a redo has work to do. */
+function undoneEditor(bindings: readonly KeyBinding[]): EditorView {
+  const extensions: Extension[] = [history(), keymap.of(bindings)]
+  const view = new EditorView({
+    state: EditorState.create({ doc: 'hello', extensions }),
+    parent: document.body.appendChild(document.createElement('div'))
+  })
+  views.push(view)
+  view.dispatch({ changes: { from: 5, insert: ' world' }, userEvent: 'input.type' })
+  undo(view)
+  expect(view.state.doc.toString()).toBe('hello')
+  return view
+}
+
+function press(view: EditorView, key: string, keyCode: number, init: KeyboardEventInit): boolean {
+  const event = new KeyboardEvent('keydown', { key, bubbles: true, cancelable: true, ...init })
+  Object.defineProperty(event, 'keyCode', { value: keyCode })
+  return runScopeHandlers(view, event, 'editor')
+}
+
+describe('appHistoryKeymap on Windows (#967)', () => {
+  it("is a platform CodeMirror's own keymap leaves without Ctrl+Shift+Z", () => {
+    const view = undoneEditor(historyKeymap)
+    expect(press(view, 'Z', 90, { ctrlKey: true, shiftKey: true })).toBe(false)
+    expect(view.state.doc.toString()).toBe('hello')
+  })
+
+  it('redoes on Ctrl+Shift+Z, the shortcut the context menu shows', () => {
+    const view = undoneEditor(appHistoryKeymap)
+    expect(press(view, 'Z', 90, { ctrlKey: true, shiftKey: true })).toBe(true)
+    expect(view.state.doc.toString()).toBe('hello world')
+  })
+
+  it('keeps Ctrl+Y redoing too', () => {
+    const view = undoneEditor(appHistoryKeymap)
+    expect(press(view, 'y', 89, { ctrlKey: true })).toBe(true)
+    expect(view.state.doc.toString()).toBe('hello world')
+  })
+})
diff --git a/packages/app-core/src/lib/history-keymap.ts b/packages/app-core/src/lib/history-keymap.ts
new file mode 100644
index 000000000..6f7575dc2
--- /dev/null
+++ b/packages/app-core/src/lib/history-keymap.ts
@@ -0,0 +1,13 @@
+import { historyKeymap, redo } from '@codemirror/commands'
+import type { KeyBinding } from '@codemirror/view'
+
+/**
+ * CodeMirror's undo/redo keys, with Ctrl+Shift+Z redoing on Windows as well.
+ * CodeMirror binds it on Linux and Cmd+Shift+Z on macOS, but on Windows only
+ * Ctrl+Y, while the editor's context menu shows Mod+Shift+Z everywhere and
+ * that is what Windows apps use too (#967). Ctrl+Y keeps working.
+ */
+export const appHistoryKeymap: readonly KeyBinding[] = [
+  ...historyKeymap,
+  { win: 'Ctrl-Shift-z', run: redo, preventDefault: true }
+]

From 56faa5ab23c2656a7ac0db29f36f9e8896ec4e1c Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 08:41:23 -0500
Subject: [PATCH 06/20] Fix(quick-capture): the panel opens on the display
 under the pointer (#976)

With two displays, the Quick capture hotkey always opened the panel on
the display it was first shown on, even with the pointer and the focused
window on the other one. The panel is created once and hidden between
captures, and showQuickCaptureWindow() only called show() and focus(), so
it kept the bounds of its first show: centered on the main display. As a
macOS panel floating above other windows, tiling window managers
(AeroSpace, yabai) leave it alone too, so nothing outside the app could
move it either. Switching Spaces on the same display already worked.

A hidden panel now opens on the display under the pointer, the way
Spotlight-style launchers do. On the display it is already on, it stays
exactly where the user left it. On another display it takes the same
place there (quickCaptureBoundsOnDisplay in quick-capture-placement.ts):
its center keeps its relative position in the work area, so a centered
panel opens centered and one dragged to a corner opens in that corner,
shrunk to fit a smaller work area and kept inside it. Main remembers
where it last sat on each display it left, so coming back restores that
exact spot instead of mapping again, which on a real Mac drifted a pixel
per round trip.

It does not move a panel that is already on screen: the hotkey only
focuses it, as before, so a pinned panel stays where it was put. Under
native Wayland the compositor places windows and ignores the move.

On a Mac with a Studio Display and the built-in display, with the panel
opened through the same toggle the hotkey runs and the real pointer moved
between them: 2.73.0 opened it at the same spot on the Studio Display
every time, with the pointer and the main window on the built-in one;
this build opened it on the pointer's display in all five shows
alternating between the two, at exactly the same spot on each return.

Tests: the same display stays put, centered and corner placements carry
over, a smaller work area shrinks and contains it, a panel hanging off
its display lands fully on the new one, the remembered spot comes back
exactly and gives way when it no longer fits. The remembered-spot test
fails without the memory.

desktop main 1,002 tests, typecheck clean.
---
 apps/desktop/src/main/index.ts                | 23 ++++++
 .../src/main/quick-capture-placement.test.ts  | 73 +++++++++++++++++++
 .../src/main/quick-capture-placement.ts       | 65 +++++++++++++++++
 3 files changed, 161 insertions(+)
 create mode 100644 apps/desktop/src/main/quick-capture-placement.test.ts
 create mode 100644 apps/desktop/src/main/quick-capture-placement.ts

diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index aed439ea5..65a7ca399 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -295,6 +295,7 @@ import {
   showTray,
 } from "./tray";
 import { shouldQuitWithOnlyQuickCaptureLeft } from "./last-window";
+import { quickCaptureBoundsOnDisplay } from "./quick-capture-placement";
 import {
   checkForAppUpdates,
   describeInstall,
@@ -5537,10 +5538,32 @@ async function showQuickCaptureWindow(): Promise<void> {
   ) {
     inheritWindowWorkspaceSession(sourceWindow, win);
   }
+  // A hidden panel opens on the display under the pointer (#976). One already
+  // on screen stays put: the user can see it, and a pinned panel sits where
+  // it was placed.
+  if (!win.isVisible()) moveQuickCaptureToPointerDisplay(win);
   win.show();
   win.focus();
 }
 
+/** Where the panel last sat on each display it left, by display id. */
+const quickCaptureBoundsByDisplay = new Map<number, Electron.Rectangle>();
+
+function moveQuickCaptureToPointerDisplay(win: BrowserWindow): void {
+  const bounds = win.getBounds();
+  const from = screen.getDisplayMatching(bounds);
+  const to = screen.getDisplayNearestPoint(screen.getCursorScreenPoint());
+  const next = quickCaptureBoundsOnDisplay({
+    bounds,
+    from,
+    to,
+    remembered: quickCaptureBoundsByDisplay.get(to.id),
+  });
+  if (!next) return;
+  quickCaptureBoundsByDisplay.set(from.id, bounds);
+  win.setBounds(next);
+}
+
 async function toggleQuickCaptureWindow(): Promise<void> {
   const win = quickCaptureWindow;
   if (win && !win.isDestroyed() && win.isVisible() && win.isFocused()) {
diff --git a/apps/desktop/src/main/quick-capture-placement.test.ts b/apps/desktop/src/main/quick-capture-placement.test.ts
new file mode 100644
index 000000000..b9be26dfb
--- /dev/null
+++ b/apps/desktop/src/main/quick-capture-placement.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest'
+import { quickCaptureBoundsOnDisplay, type DisplayArea } from './quick-capture-placement'
+
+// Work areas of a two-display Mac like the one in #976: a main display with
+// the Dock below, and a smaller built-in display to its left, lower down.
+const main: DisplayArea = { id: 1, workArea: { x: 0, y: 30, width: 2560, height: 1356 } }
+const side: DisplayArea = { id: 2, workArea: { x: -1728, y: 206, width: 1728, height: 1085 } }
+
+describe('the Quick capture panel opens on the display under the pointer (#976)', () => {
+  it('stays exactly where it is on its own display', () => {
+    const bounds = { x: 140, y: 90, width: 620, height: 480 }
+    expect(quickCaptureBoundsOnDisplay({ bounds, from: main, to: main })).toBeNull()
+  })
+
+  it('opens centered on the other display when it was centered', () => {
+    const bounds = { x: 970, y: 468, width: 620, height: 480 }
+    expect(quickCaptureBoundsOnDisplay({ bounds, from: main, to: side })).toEqual({
+      x: -1728 + (1728 - 620) / 2,
+      y: Math.round(206 + (1085 - 480) / 2),
+      width: 620,
+      height: 480
+    })
+  })
+
+  it('keeps a corner the user dragged it to', () => {
+    // Top right of the main display, flush with its edges.
+    const bounds = { x: 2560 - 620, y: 30, width: 620, height: 480 }
+    expect(quickCaptureBoundsOnDisplay({ bounds, from: main, to: side })).toEqual({
+      x: -620,
+      y: 206,
+      width: 620,
+      height: 480
+    })
+  })
+
+  it('shrinks to fit a smaller work area and stays inside it', () => {
+    const small: DisplayArea = { id: 3, workArea: { x: 2560, y: 0, width: 500, height: 400 } }
+    const bounds = { x: 200, y: 200, width: 620, height: 480 }
+    expect(quickCaptureBoundsOnDisplay({ bounds, from: main, to: small })).toEqual({
+      x: 2560,
+      y: 0,
+      width: 500,
+      height: 400
+    })
+  })
+
+  it('returns exactly to where it last sat on a display', () => {
+    const bounds = { x: 1700, y: 90, width: 700, height: 520 }
+    const there = quickCaptureBoundsOnDisplay({ bounds, from: main, to: side })!
+    expect(
+      quickCaptureBoundsOnDisplay({ bounds: there, from: side, to: main, remembered: bounds })
+    ).toEqual(bounds)
+  })
+
+  it('maps afresh when the remembered spot no longer fits the display', () => {
+    // The display got smaller since, so the old spot hangs off its edge.
+    const remembered = { x: 2200, y: 1200, width: 620, height: 480 }
+    const bounds = { x: -1174, y: 509, width: 620, height: 480 }
+    const next = quickCaptureBoundsOnDisplay({ bounds, from: side, to: main, remembered })!
+    expect(next).not.toEqual(remembered)
+    expect(next.x + next.width).toBeLessThanOrEqual(2560)
+    expect(next.y + next.height).toBeLessThanOrEqual(30 + 1356)
+  })
+
+  it('lands fully on the new display when it hung off the edge of the old one', () => {
+    const bounds = { x: 2400, y: 1300, width: 620, height: 480 }
+    const next = quickCaptureBoundsOnDisplay({ bounds, from: main, to: side })!
+    expect(next.x + next.width).toBeLessThanOrEqual(0)
+    expect(next.y + next.height).toBeLessThanOrEqual(206 + 1085)
+    expect(next.x).toBeGreaterThanOrEqual(-1728)
+    expect(next.y).toBeGreaterThanOrEqual(206)
+  })
+})
diff --git a/apps/desktop/src/main/quick-capture-placement.ts b/apps/desktop/src/main/quick-capture-placement.ts
new file mode 100644
index 000000000..30783deab
--- /dev/null
+++ b/apps/desktop/src/main/quick-capture-placement.ts
@@ -0,0 +1,65 @@
+/** A rectangle in Electron's screen coordinates (DIPs, all displays share one space). */
+export interface ScreenRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/** The part of a display Electron reports that windows may use. */
+export interface DisplayArea {
+  id: number
+  workArea: ScreenRect
+}
+
+const clamp = (value: number, min: number, max: number): number =>
+  Math.min(Math.max(value, min), Math.max(min, max))
+
+const contains = (area: ScreenRect, rect: ScreenRect): boolean =>
+  rect.x >= area.x &&
+  rect.y >= area.y &&
+  rect.x + rect.width <= area.x + area.width &&
+  rect.y + rect.height <= area.y + area.height
+
+/**
+ * Where the Quick capture panel opens when the hotkey shows it again. The
+ * panel is created once and hidden between captures, so it kept the bounds of
+ * its first show and came back on that display even with the pointer and the
+ * focused window on another one (#976); as a macOS panel floating above other
+ * windows, tiling window managers leave it alone, so nothing outside the app
+ * could move it either.
+ *
+ * On the display it is already on, it stays exactly where the user left it
+ * (null). Back on a display it has been on, it returns to where it last sat
+ * there, as long as that still fits the display's work area. On a display it
+ * has not been on, it takes the same place there: its center keeps its
+ * relative position in the work area, so a centered panel opens centered and
+ * one dragged to a corner opens in that corner, shrunk to fit a smaller work
+ * area and kept inside it. That mapping rounds, so without the remembered
+ * spot each trip there and back could move the panel by a pixel.
+ */
+export function quickCaptureBoundsOnDisplay(input: {
+  bounds: ScreenRect
+  /** The display the panel is on now. */
+  from: DisplayArea
+  /** The display under the pointer. */
+  to: DisplayArea
+  /** Where the panel last sat on `to`, if it has been there. */
+  remembered?: ScreenRect
+}): ScreenRect | null {
+  const { bounds, from, to, remembered } = input
+  if (from.id === to.id) return null
+  const source = from.workArea
+  const area = to.workArea
+  if (remembered && contains(area, remembered)) return { ...remembered }
+  const width = Math.min(bounds.width, area.width)
+  const height = Math.min(bounds.height, area.height)
+  const fx = source.width > 0 ? clamp((bounds.x + bounds.width / 2 - source.x) / source.width, 0, 1) : 0.5
+  const fy = source.height > 0 ? clamp((bounds.y + bounds.height / 2 - source.y) / source.height, 0, 1) : 0.5
+  return {
+    x: clamp(Math.round(area.x + fx * area.width - width / 2), area.x, area.x + area.width - width),
+    y: clamp(Math.round(area.y + fy * area.height - height / 2), area.y, area.y + area.height - height),
+    width,
+    height
+  }
+}

From ee2fd2a06058ef654b07ba27f8a46022671d54a8 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 08:59:58 -0500
Subject: [PATCH 07/20] Fix(links): a link to a missing [[2026-11-03]] creates
 that day's daily note
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Following a wikilink to a note that does not exist yet creates it from
the link text, in the Inbox root. For a link named like a daily note
that was the wrong note: with daily notes on, the day's note lives where
the Periodic notes folder and title pattern put it (`Daily Notes/` by
default), and the calendar counts a note only at that exact path
(classifyDateNote). So `[[2026-11-03]]` made `inbox/2026-11-03.md`, which
never showed on the calendar, skipped the daily template, and became a
second note of the same name once the day was created from the calendar.
A Discord user planning tasks on future days ran into it: the only way
to get a future day's note seemed to be typing its date into a title.

dateNoteForTitle (vault-layout.ts) reads a title against the current
daily, weekly and monthly title patterns: it names the periodic note
when exactly one date produces that title, for a kind that is on. The
link paths in create-note-from-link.ts check it first. Cmd/Ctrl-click
and `gD` create the note at once through openDailyNoteForDate (or the
weekly or monthly twin), the same call the calendar makes, so it lands
in its folder with its template; a plain click, gd and the reading view
ask the calendar's question ("2026-11-04 does not exist yet. Create it
as your daily note?") instead of the path prompt. `[[2026-W45]]` and
`[[2026-11]]` work the same way for weekly and monthly notes.

Not in this change: a link that names a folder (`journal/2026-11-03`)
says where the note goes, so it keeps the plain path. Only the current
patterns count, since a new note always takes the current one, and a
title the pattern cannot pin to one date (the year in the directory,
say) names none. The website docs mirror the manual in a separate
change.

In the built app, a vault with daily notes on in `Daily Notes`, a note
linking [[2026-11-03]] and [[2026-11-04]]: before, a Cmd-click created
inbox/2026-11-03.md and a plain click offered the path prompt for
/2026-11-04.md; after, the Cmd-click created
inbox/Daily Notes/2026-11-03.md, the plain click asked "New daily note"
and created inbox/Daily Notes/2026-11-04.md, the calendar panel offered
"Open daily note" for both days (and still "Create" for the 5th), and
both links drew as live.

The manual says so under Links are actionable, gD and Settings → Daily
notes, which now also names the calendar's double-click for another day.

Tests: daily, weekly and monthly titles, a custom pattern and only its
exact output, a kind that is off, an impossible day, unrelated titles, a
title the pattern cannot pin; the link paths create the daily or weekly
note, ask first on the confirming path, create nothing when declined,
and keep the plain path with daily notes off or a folder in the link.
The three link tests that expect the new note fail without this change.

app-core 3,367 tests, typecheck clean.
---
 .../src/lib/create-note-from-link.test.ts     | 68 +++++++++++++++++++
 .../app-core/src/lib/create-note-from-link.ts | 54 ++++++++++++++-
 packages/app-core/src/lib/help.ts             |  6 +-
 .../app-core/src/lib/vault-layout.test.ts     | 58 ++++++++++++++++
 packages/app-core/src/lib/vault-layout.ts     | 58 ++++++++++++++++
 5 files changed, 239 insertions(+), 5 deletions(-)

diff --git a/packages/app-core/src/lib/create-note-from-link.test.ts b/packages/app-core/src/lib/create-note-from-link.test.ts
index c5865d7f8..c8c86d92d 100644
--- a/packages/app-core/src/lib/create-note-from-link.test.ts
+++ b/packages/app-core/src/lib/create-note-from-link.test.ts
@@ -7,22 +7,33 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const state = vi.hoisted(() => ({
   notes: [{ path: 'inbox/Existing.md', title: 'Existing', folder: 'inbox' as const }],
+  vaultSettings: null as unknown,
   selectNote: vi.fn(() => Promise.resolve()),
   createAndOpen: vi.fn(() => Promise.resolve()),
+  openDailyNoteForDate: vi.fn((_date: Date) => Promise.resolve()),
+  openWeeklyNoteForDate: vi.fn((_date: Date) => Promise.resolve()),
+  openMonthlyNoteForDate: vi.fn((_date: Date) => Promise.resolve()),
   setFocusedPanel: vi.fn(),
   editorViewRef: null
 }))
 const promptApp = vi.hoisted(() => vi.fn(() => Promise.resolve(null)))
+const confirmApp = vi.hoisted(() => vi.fn(() => Promise.resolve(true)))
 
 vi.mock('../store', () => ({ useStore: { getState: () => state } }))
 vi.mock('./prompt-requests', () => ({ promptApp }))
+vi.mock('./confirm-requests', () => ({ confirmApp }))
 
 const { createNoteFromLinkNow, offerCreateNoteFromLink } = await import('./create-note-from-link')
 
 beforeEach(() => {
   promptApp.mockClear()
+  confirmApp.mockClear()
+  state.vaultSettings = null
   state.selectNote.mockClear()
   state.createAndOpen.mockClear()
+  state.openDailyNoteForDate.mockClear()
+  state.openWeeklyNoteForDate.mockClear()
+  state.openMonthlyNoteForDate.mockClear()
 })
 
 describe('createNoteFromLinkNow (#768)', () => {
@@ -59,3 +70,60 @@ describe('createNoteFromLinkNow (#768)', () => {
     expect(state.createAndOpen).not.toHaveBeenCalled()
   })
 })
+
+describe('a dead link that names a periodic note', () => {
+  const periodic = {
+    dailyNotes: { enabled: true, directory: 'Daily Notes' },
+    weeklyNotes: { enabled: true, directory: 'Weekly Notes' }
+  }
+  const dayOf = (date: Date | undefined): string | null =>
+    date ? `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}` : null
+
+  it("creates that day's daily note, not a plain Inbox note", async () => {
+    state.vaultSettings = periodic
+    await createNoteFromLinkNow('2026-11-03')
+
+    expect(state.createAndOpen).not.toHaveBeenCalled()
+    expect(state.openDailyNoteForDate).toHaveBeenCalledTimes(1)
+    expect(dayOf(state.openDailyNoteForDate.mock.calls[0]?.[0])).toBe('2026-11-3')
+  })
+
+  it('asks the way the calendar does, then creates it', async () => {
+    state.vaultSettings = periodic
+    await offerCreateNoteFromLink('2026-11-03#Research')
+
+    expect(promptApp).not.toHaveBeenCalled()
+    expect(confirmApp).toHaveBeenCalledWith(
+      expect.objectContaining({ title: 'New daily note', confirmLabel: 'Create' })
+    )
+    expect(dayOf(state.openDailyNoteForDate.mock.calls[0]?.[0])).toBe('2026-11-3')
+  })
+
+  it('creates nothing when the question is declined', async () => {
+    state.vaultSettings = periodic
+    confirmApp.mockResolvedValueOnce(false)
+    await offerCreateNoteFromLink('2026-11-03')
+
+    expect(state.openDailyNoteForDate).not.toHaveBeenCalled()
+    expect(state.createAndOpen).not.toHaveBeenCalled()
+  })
+
+  it('goes to the weekly note for a week title', async () => {
+    state.vaultSettings = periodic
+    await createNoteFromLinkNow('2026-W45')
+
+    expect(state.openWeeklyNoteForDate).toHaveBeenCalledTimes(1)
+    expect(state.openDailyNoteForDate).not.toHaveBeenCalled()
+  })
+
+  it('keeps the plain path when daily notes are off or the link names a folder', async () => {
+    await createNoteFromLinkNow('2026-11-03')
+    expect(state.createAndOpen).toHaveBeenLastCalledWith('inbox', '', { title: '2026-11-03' })
+
+    state.vaultSettings = periodic
+    await createNoteFromLinkNow('journal/2026-11-03')
+    expect(state.createAndOpen).toHaveBeenLastCalledWith('inbox', 'journal', { title: '2026-11-03' })
+    expect(state.openDailyNoteForDate).not.toHaveBeenCalled()
+  })
+})
+
diff --git a/packages/app-core/src/lib/create-note-from-link.ts b/packages/app-core/src/lib/create-note-from-link.ts
index c548fe3bb..817521268 100644
--- a/packages/app-core/src/lib/create-note-from-link.ts
+++ b/packages/app-core/src/lib/create-note-from-link.ts
@@ -1,7 +1,39 @@
+import { confirmApp } from './confirm-requests'
 import { promptApp } from './prompt-requests'
-import { parseCreateNotePath, suggestCreateNotePath } from './wikilinks'
+import { dateNoteForTitle, type DateNoteInfo } from './vault-layout'
+import { parseCreateNotePath, stripWikilinkAnchor, suggestCreateNotePath } from './wikilinks'
 import { useStore } from '../store'
 
+const DATE_NOTE_LABEL: Record<DateNoteInfo['kind'], string> = {
+  daily: 'daily',
+  weekly: 'weekly',
+  monthly: 'monthly'
+}
+
+/**
+ * The periodic note a dead link names: a bare `[[2026-11-03]]` while daily
+ * notes are on, `[[2026-W45]]` for weekly notes, and so on. It is created the
+ * way the calendar creates it, in the folder its pattern gives and from its
+ * template; made as a plain note from the link text it landed in the Inbox
+ * root, where the calendar never counted it as that day's note and creating
+ * the day there later made a second note of the same name. A link that names
+ * a folder (`journal/2026-11-03`) says where the note goes, so it keeps the
+ * plain path.
+ */
+function dateNoteForLink(target: string): { info: DateNoteInfo; title: string } | null {
+  const title = stripWikilinkAnchor(target).trim().replace(/\.md$/i, '')
+  if (!title || title.includes('/') || title.includes('\\')) return null
+  const info = dateNoteForTitle(title, useStore.getState().vaultSettings)
+  return info ? { info, title } : null
+}
+
+async function openDateNote(info: DateNoteInfo): Promise<void> {
+  const state = useStore.getState()
+  if (info.kind === 'daily') await state.openDailyNoteForDate(info.date)
+  else if (info.kind === 'weekly') await state.openWeeklyNoteForDate(info.date)
+  else await state.openMonthlyNoteForDate(info.date)
+}
+
 /**
  * Offer to create a note for a dead link `target`, confirming first. Shared by
  * the cmd/ctrl-click and `gd` follow-link paths so a link to a not-yet-existing
@@ -10,6 +42,18 @@ import { useStore } from '../store'
  * out to already exist, that note is opened instead.
  */
 export async function offerCreateNoteFromLink(target: string): Promise<void> {
+  const dateNote = dateNoteForLink(target)
+  if (dateNote) {
+    const kind = DATE_NOTE_LABEL[dateNote.info.kind]
+    const ok = await confirmApp({
+      title: `New ${kind} note`,
+      description: `${dateNote.title} does not exist yet. Create it as your ${kind} note?`,
+      confirmLabel: 'Create',
+      cancelLabel: 'Never mind'
+    })
+    if (ok) await openDateNote(dateNote.info)
+    return
+  }
   const value = await promptApp({
     title: `Create note for "${target}"?`,
     description:
@@ -36,9 +80,15 @@ export async function offerCreateNoteFromLink(target: string): Promise<void> {
  * unless the link names a top folder. The fast path behind a Cmd/Ctrl-click on
  * an unresolved wikilink and the `gD` motion (#768): when the note belongs
  * where the link already says, the confirmation only costs a keystroke. A
- * note that already exists at that path is opened instead.
+ * note that already exists at that path is opened instead, and a link that
+ * names a periodic note creates that note where its pattern puts it.
  */
 export async function createNoteFromLinkNow(target: string): Promise<void> {
+  const dateNote = dateNoteForLink(target)
+  if (dateNote) {
+    await openDateNote(dateNote.info)
+    return
+  }
   await createNoteAtPath(suggestCreateNotePath(target))
 }
 
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index e7f10dba1..27fbc00de 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -427,7 +427,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Links are actionable',
     body:
-      'Use [[wikilinks]] or markdown links. Following a link (click it, Cmd/Ctrl-click it, or use the follow-link motion `gd` in normal mode) opens the note under the cursor and pins PDFs into the reference pane. If the note does not exist yet, following the link offers to create it (after you confirm) rather than leaving a dead link; hold Cmd (macOS) or Ctrl (Windows/Linux) while clicking the link, or use `gD` in normal mode, to create it at once at the suggested path: Inbox, named after the link text. A link at a note that does not exist yet is drawn muted with a dashed underline, in the editor and in the reading view, so you can tell live links from ones that would create a note. Prefix a wikilink with `!` to embed rather than link: `![[Note]]` inlines the target note content in the reading view and PDF export (recursively, with cycle protection), so a master note can pull in sub-notes and export to PDF as one document. `![[image.png]]` embeds an image and `![[drawing.excalidraw]]` embeds an Excalidraw drawing as a PNG preview; both take optional `|width` or `|WxH` size hints (`![[image.png|300]]`, `![[image.png|600x400]]`), and the markdown form carries the same hint after the alt text (`![caption|300](image.png)`). In the editor, drag the handle on a picture\'s right edge to resize it; the width is written back as that hint, so the reading view, exports and Obsidian all show the same size. Resize Image… in the command palette (or `:imgwidth 480` in Vim mode, `:imgw auto` to reset) sets it by number for the image under the cursor. Right-click a web link or an email address, in the editor or the reading view, to open it or copy it (the address itself, without `mailto:`); `gy` in normal mode, or Copy Link Under Cursor in the palette, copies the one under the caret.'
+      'Use [[wikilinks]] or markdown links. Following a link (click it, Cmd/Ctrl-click it, or use the follow-link motion `gd` in normal mode) opens the note under the cursor and pins PDFs into the reference pane. If the note does not exist yet, following the link offers to create it (after you confirm) rather than leaving a dead link; hold Cmd (macOS) or Ctrl (Windows/Linux) while clicking the link, or use `gD` in normal mode, to create it at once at the suggested path: Inbox, named after the link text. A link named like one of your daily, weekly or monthly notes, such as `[[2026-11-03]]` while daily notes are on, creates that note instead, in its folder and from its template, the way the calendar does, so it shows up on that day; a link that names a folder (`[[journal/2026-11-03]]`) still makes a plain note there. A link at a note that does not exist yet is drawn muted with a dashed underline, in the editor and in the reading view, so you can tell live links from ones that would create a note. Prefix a wikilink with `!` to embed rather than link: `![[Note]]` inlines the target note content in the reading view and PDF export (recursively, with cycle protection), so a master note can pull in sub-notes and export to PDF as one document. `![[image.png]]` embeds an image and `![[drawing.excalidraw]]` embeds an Excalidraw drawing as a PNG preview; both take optional `|width` or `|WxH` size hints (`![[image.png|300]]`, `![[image.png|600x400]]`), and the markdown form carries the same hint after the alt text (`![caption|300](image.png)`). In the editor, drag the handle on a picture\'s right edge to resize it; the width is written back as that hint, so the reading view, exports and Obsidian all show the same size. Resize Image… in the command palette (or `:imgwidth 480` in Vim mode, `:imgw auto` to reset) sets it by number for the image under the cursor. Right-click a web link or an email address, in the editor or the reading view, to open it or copy it (the address itself, without `mailto:`); `gy` in normal mode, or Copy Link Under Cursor in the palette, copies the one under the caret.'
   },
   {
     title: 'Open links in other applications',
@@ -963,7 +963,7 @@ export const HELP_VIM_COMMANDS: HelpExCommand[] = [
   {
     command: 'gD',
     summary: 'Create the note for the link under the cursor',
-    detail: 'Like `gd`, but a link at a note that does not exist yet creates it at once at the suggested path (Inbox, named after the link) instead of asking first. The keyboard twin of Cmd/Ctrl-clicking an unresolved wikilink.'
+    detail: 'Like `gd`, but a link at a note that does not exist yet creates it at once at the suggested path (Inbox, named after the link) instead of asking first. A link named like a daily, weekly or monthly note, such as `[[2026-11-03]]`, creates that note where the calendar would. The keyboard twin of Cmd/Ctrl-clicking an unresolved wikilink.'
   },
   {
     command: 'gy',
@@ -1189,7 +1189,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
       { label: 'Vault name', detail: 'What the sidebar header, the vault switcher and the title bar call this vault; the folder keeps its own name on disk. Leave it empty to use the folder name. Saved in the vault’s `.zennotes/vault.json`, so it follows the folder wherever it is opened. Also “Rename Vault…” in the command palette (`:vault_rename`) and the sidebar’s vault menu. Local vaults only.' },
       { label: 'Primary notes location', detail: 'Treat `inbox/` as the main notes area, or use the vault root directly for an Obsidian-style flat vault.' },
       { label: 'New Drawings, Databases & Tasks location', detail: 'Choose where new Excalidraw drawings, databases, and task files are created so they do not pile up in the vault root: the primary notes location (the default), the folder of the note you are currently viewing, or a specific folder you name (e.g. `assets/drawings` or `Tasks`). A specific folder lives inside the primary notes area, so `Tasks` means `inbox/Tasks/` in an Inbox vault and `Tasks/` in a root vault; the folder field shows the exact destination. Search Settings for "tasks folder" or "drawings folder" to jump there. Only new files are affected; existing ones stay put.' },
-      { label: 'Daily notes', detail: "Enable a daily-notes workflow, choose a directory pattern, naming pattern, locale, and template so each day’s note starts in the right place. Supported tokens are `yyyy`, `yy`, `M`, `MM`, `MMM`, `MMMM`, `d`, `dd`, `EEE`, `EEEE`, `w`, and `ww`; quote literal words like `'Daily Notes'/yyyy/MM-MMM`. Open today’s note with `Space d`, `:daily`, or the command palette. Two task options live here too: “Tasks are due on the note’s date” makes tasks in a daily note show on the calendar for that day (on by default), and “Roll over unfinished tasks to today” moves every unchecked task from past daily notes into today when you open it (off by default; also runnable from the command palette)." },
+      { label: 'Daily notes', detail: "Enable a daily-notes workflow, choose a directory pattern, naming pattern, locale, and template so each day’s note starts in the right place. Supported tokens are `yyyy`, `yy`, `M`, `MM`, `MMM`, `MMMM`, `d`, `dd`, `EEE`, `EEEE`, `w`, and `ww`; quote literal words like `'Daily Notes'/yyyy/MM-MMM`. Open today’s note with `Space d`, `:daily`, or the command palette. For another day, past or future, double-click it in the calendar panel, or follow a link like `[[2026-11-03]]` to a day that has no note yet: both create that day’s note in the right place, from its template. Two task options live here too: “Tasks are due on the note’s date” makes tasks in a daily note show on the calendar for that day (on by default), and “Roll over unfinished tasks to today” moves every unchecked task from past daily notes into today when you open it (off by default; also runnable from the command palette)." },
       { label: 'Weekly notes', detail: "Enable weekly notes with a directory pattern, naming pattern, locale, and template. Weekly patterns support the same tokens as daily notes plus ISO week `w` and `ww`; the default title pattern is `yyyy-'W'ww`. Open this week’s note with `Space w`, `:weekly`, or the command palette." },
       { label: 'Monthly notes', detail: 'Enable monthly notes with a directory pattern, naming pattern, locale, and template. It creates one note per calendar month, handy for monthly reviews and reflections. The default title pattern is `yyyy-MM` (e.g. `2026-07`). Open this month’s note with `Space m`, `:monthly`, or the command palette. Each notes section in Settings now collapses its fields when its toggle is off.' },
       { label: 'Folder Paths', detail: 'Point any of the four system folders (Inbox, Quick Notes, Archive, Trash) at a directory of your choosing, labels included; stored as `systemFolderPaths` in `vault.json` so the vault stays portable. Relabeling without moving anything on disk works too.' },
diff --git a/packages/app-core/src/lib/vault-layout.test.ts b/packages/app-core/src/lib/vault-layout.test.ts
index b2db47046..fa02b3429 100644
--- a/packages/app-core/src/lib/vault-layout.test.ts
+++ b/packages/app-core/src/lib/vault-layout.test.ts
@@ -5,6 +5,7 @@ import {
   assetFolderSubpath,
   classifyDateNote,
   dailyNoteLocationForDate,
+  dateNoteForTitle,
   dateNoteFolderMayBelongToDatePattern,
   dateNoteDirectoryDisplayLabel,
   favoriteFolderKey,
@@ -918,3 +919,60 @@ describe('normalizeVaultSettings: harper', () => {
     expect(normalizeVaultSettings(base).harper).toBeUndefined()
   })
 })
+
+describe('dateNoteForTitle', () => {
+  const withPeriodic = (overrides: Partial<VaultSettings> = {}): VaultSettings =>
+    normalizeVaultSettings({
+      dailyNotes: { enabled: true, directory: 'Daily Notes' },
+      weeklyNotes: { enabled: true, directory: 'Weekly Notes' },
+      monthlyNotes: { enabled: true, directory: 'Monthly Notes' },
+      ...overrides
+    } as Partial<VaultSettings> as VaultSettings)
+
+  it('names the daily note a dead [[2026-11-03]] points at', () => {
+    const info = dateNoteForTitle('2026-11-03', withPeriodic())
+    expect(info?.kind).toBe('daily')
+    expect(info?.date.getFullYear()).toBe(2026)
+    expect(info?.date.getMonth()).toBe(10)
+    expect(info?.date.getDate()).toBe(3)
+    // And creating it lands where the calendar looks for it.
+    expect(dailyNoteLocationForDate(info!.date, withPeriodic())).toEqual({
+      title: '2026-11-03',
+      subpath: 'Daily Notes'
+    })
+  })
+
+  it('names weekly and monthly notes by their own patterns', () => {
+    const week = dateNoteForTitle('2026-W45', withPeriodic())
+    expect(week?.kind).toBe('weekly')
+    expect(weeklyNoteLocationForDate(week!.date, withPeriodic()).title).toBe('2026-W45')
+    const month = dateNoteForTitle('2026-11', withPeriodic())
+    expect(month?.kind).toBe('monthly')
+    expect(month?.date.getMonth()).toBe(10)
+  })
+
+  it('follows a custom title pattern, and only its exact output', () => {
+    const settings = withPeriodic({
+      dailyNotes: { enabled: true, directory: 'Journal', titlePattern: 'dd.MM.yyyy' }
+    } as Partial<VaultSettings>)
+    expect(dateNoteForTitle('03.11.2026', settings)?.kind).toBe('daily')
+    expect(dateNoteForTitle('2026-11-03', settings)).toBeNull()
+    expect(dateNoteForTitle('3.11.2026', settings)).toBeNull()
+  })
+
+  it('names nothing for a kind that is off, a day that does not exist, or other titles', () => {
+    expect(dateNoteForTitle('2026-11-03', normalizeVaultSettings(null))).toBeNull()
+    expect(dateNoteForTitle('2026-02-30', withPeriodic())).toBeNull()
+    expect(dateNoteForTitle('Meeting notes', withPeriodic())).toBeNull()
+    expect(dateNoteForTitle('2026-11-03 standup', withPeriodic())).toBeNull()
+  })
+
+  it('names nothing when the title alone cannot pin the date', () => {
+    // The year lives in the directory, so `11-03` could be any year's.
+    const settings = withPeriodic({
+      dailyNotes: { enabled: true, directory: 'yyyy', titlePattern: 'MM-dd' }
+    } as Partial<VaultSettings>)
+    expect(dateNoteForTitle('11-03', settings)).toBeNull()
+  })
+})
+
diff --git a/packages/app-core/src/lib/vault-layout.ts b/packages/app-core/src/lib/vault-layout.ts
index 9d5d900be..13770b071 100644
--- a/packages/app-core/src/lib/vault-layout.ts
+++ b/packages/app-core/src/lib/vault-layout.ts
@@ -1567,6 +1567,64 @@ export function findMonthlyNoteForDate(
   )
 }
 
+/**
+ * The periodic note a title names, for a note that does not exist yet: the
+ * daily, weekly or monthly note whose current title pattern produces exactly
+ * `title` for one date. A link to a missing `[[2026-11-03]]` creates that day's
+ * note through this, where the pattern puts it and with its template, instead
+ * of a plain Inbox note the calendar would never count. Only the title is read
+ * (a link has no folder); a pattern that cannot pin the title to one date,
+ * with the year in the directory say, names none. Earlier patterns are left
+ * out: a new note always takes the current one.
+ */
+export function dateNoteForTitle(
+  title: string,
+  settings: VaultSettings | null | undefined
+): DateNoteInfo | null {
+  const s = normalizeVaultSettings(settings)
+  const kinds: Array<{
+    kind: DateNoteInfo['kind']
+    enabled: boolean
+    pattern: DateNotePatternSettings
+    defaultTitlePattern: string
+    candidates: (n: DateNotePatternMatch) => Date[]
+    titleFor: (date: Date) => string
+  }> = [
+    {
+      kind: 'daily',
+      enabled: s.dailyNotes.enabled,
+      pattern: currentDailyNotePattern(s),
+      defaultTitlePattern: DEFAULT_DAILY_NOTE_TITLE_PATTERN,
+      candidates: dailyCandidateDates,
+      titleFor: (date) => dailyNoteLocationForPattern(date, s, currentDailyNotePattern(s)).title
+    },
+    {
+      kind: 'weekly',
+      enabled: s.weeklyNotes.enabled,
+      pattern: currentWeeklyNotePattern(s),
+      defaultTitlePattern: DEFAULT_WEEKLY_NOTE_TITLE_PATTERN,
+      candidates: weeklyCandidateMondays,
+      titleFor: (date) => weeklyNoteLocationForPattern(date, s, currentWeeklyNotePattern(s)).title
+    },
+    {
+      kind: 'monthly',
+      enabled: s.monthlyNotes.enabled,
+      pattern: currentMonthlyNotePattern(s),
+      defaultTitlePattern: DEFAULT_MONTHLY_NOTE_TITLE_PATTERN,
+      candidates: monthlyCandidateDates,
+      titleFor: (date) => monthlyNoteLocationForPattern(date, s, currentMonthlyNotePattern(s)).title
+    }
+  ]
+  for (const { kind, enabled, pattern, defaultTitlePattern, candidates, titleFor } of kinds) {
+    if (!enabled) continue
+    const numerics = matchDateNotePattern(pattern.titlePattern ?? defaultTitlePattern, title)
+    if (!numerics) continue
+    const dates = candidates(numerics).filter((date) => titleFor(date) === title)
+    if (dates.length === 1) return { kind, date: dates[0] }
+  }
+  return null
+}
+
 export function findDateNoteByTitle(
   notes: readonly NoteMeta[],
   settings: VaultSettings | null | undefined,

From d06cf66d3dd25330e8ccc9fc944a4ef2871a9ec7 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 09:36:00 -0500
Subject: [PATCH 08/20] Feat(tabs): next and previous tab work with Vim mode
 off (#973)

Stepping through open tabs from the keyboard was Vim's alone: `gt` and
`gT` are Vim bindings, and the command palette had Close, Reopen, the
buffer switcher and Back/Forward but no Next or Previous Tab. With Vim
mode off, the only tab keys were Alt+1-9 (Ctrl+1-9 on macOS), which jump
to a position rather than to the neighbouring tab and stop at nine.

Two app-level actions, Next tab (`tabs.next`) and Previous tab
(`tabs.previous`), work with Vim on or off and from any panel. They walk
the order `gt`/`gT` and the digit shortcuts use, every pane's tabs in
pane order (openTabOrder in buffer-navigation.ts), and wrap at either end.
getTabStepTarget is open tabs only: with one tab open it goes nowhere,
where `gt` falls back to a recent note or a new quick note the way Vim's
buffer commands do. From a pane showing no tab, next starts at the first
tab and previous at the last. The palette gains Next Tab and Previous
Tab under Tabs, with their keys.

The defaults leave Ctrl+Tab to Switch to previous note, which it has
meant on every platform, and take the other common conventions:
Ctrl+PageDown / Ctrl+PageUp (browsers, VS Code) on Windows and Linux, and
Cmd+Option+Right / Left on macOS (Chrome, VS Code), where Ctrl+PageDown
needs fn. Plain PageDown, Cmd+Right and Option+Right keep paging and
moving the caret. Anyone who wants Ctrl+Tab for tabs can rebind it under
Settings, Keymaps, and the manual says so. Like Alt+1-9, the shortcuts sit
mid-chain in the app handler, so an explicit rebind of the same keys to a
later action wins, and they stay quiet while an overlay is open.

Found while testing in the app: with Vim on and the sidebar focused,
VimNav's panel handlers take every ArrowLeft and ArrowRight whatever the
modifiers, so Cmd+Option+Right opened the sidebar row under the cursor.
VimNav now leaves the two tab chords to the app handler before it routes
keys to a panel.

The manual lists the keys next to Alt+1-9, and the `gt / gT` entry now
says it walks the open tabs across panes (it said the active pane) and
names the keys for Vim mode off.

In the built app on macOS, four notes open as tabs, Cmd+Option+Right and
Left pressed over CDP: from the editor, Delta stepped to Alpha (wrapping),
Bravo, back to Alpha, Delta (wrapping) and Charlie, with no text typed
into the note; from the sidebar and from the palette's Next Tab, the same.
Vim on and Vim off alike, after the VimNav guard (before it, the sidebar
case did nothing with Vim on). The Windows and Linux keys are covered by
the unit tests, not run in an app.

Tests: the step order against gt's across panes, wrapping both ways, no
fallback with one tab, a pane showing no tab; the defaults per platform,
the chords firing, plain paging and word motions untouched, no clash
with any default, and Ctrl+Tab still Switch to previous note. The
catalog mirror test covers the config.toml list.

app-core 3,374 tests, shared-domain 2,048, desktop 1,190, typecheck clean.
---
 packages/app-core/src/App.tsx                 | 17 ++++++-
 packages/app-core/src/components/VimNav.tsx   | 12 +++++
 .../src/lib/buffer-navigation.test.ts         | 49 ++++++++++++++++++-
 .../app-core/src/lib/buffer-navigation.ts     | 31 ++++++++++++
 packages/app-core/src/lib/commands.ts         | 25 ++++++++++
 packages/app-core/src/lib/help.ts             |  3 +-
 packages/app-core/src/lib/keymaps.test.ts     | 48 ++++++++++++++++++
 packages/app-core/src/lib/keymaps.ts          | 29 +++++++++++
 packages/shared-domain/src/keymaps-catalog.ts |  2 +
 9 files changed, 213 insertions(+), 3 deletions(-)

diff --git a/packages/app-core/src/App.tsx b/packages/app-core/src/App.tsx
index 9854f18ff..899a8d489 100644
--- a/packages/app-core/src/App.tsx
+++ b/packages/app-core/src/App.tsx
@@ -38,7 +38,7 @@ import {
   matchesShortcut,
   TAB_SELECT_KEYMAP_IDS
 } from './lib/keymaps'
-import { selectActiveBuffer } from './lib/buffer-navigation'
+import { selectActiveBuffer, stepActiveTab } from './lib/buffer-navigation'
 import { resolveCloseShortcut } from './lib/close-shortcut'
 import { focusPaneOrEdgePanel } from './lib/pane-nav'
 import {
@@ -841,6 +841,21 @@ function App(): JSX.Element {
           return
         }
       }
+      // Next / previous tab with Vim on or off (#973), in the same order gt/gT
+      // walk. Inserted mid-chain like the digits above, so an explicit rebind
+      // of the same combination to a later action still wins.
+      if (!overlayOpen) {
+        for (const [id, delta] of [
+          ['tabs.next', 1],
+          ['tabs.previous', -1]
+        ] as const) {
+          if (!matchesShortcut(e, overrides, id)) continue
+          if (!overrides[id] && eventMatchesUserOverride(e, overrides, id)) continue
+          e.preventDefault()
+          stepActiveTab(state, delta)
+          return
+        }
+      }
       // The template pickers as plain shortcuts, so they no longer need Vim's
       // leader (#847). Same overlay rule as tab selection: a picker opened
       // under Settings or another palette would strand the user behind it.
diff --git a/packages/app-core/src/components/VimNav.tsx b/packages/app-core/src/components/VimNav.tsx
index 0012b8c7b..5ebbe3ae5 100644
--- a/packages/app-core/src/components/VimNav.tsx
+++ b/packages/app-core/src/components/VimNav.tsx
@@ -34,6 +34,7 @@ import {
   getKeymapDisplay,
   getSequenceTokens,
   matchesSequenceToken,
+  matchesShortcut,
   matchesShortcutBinding,
   UNBOUND_BINDING,
   sequenceTokenFromEvent
@@ -1266,6 +1267,17 @@ export function VimNav(): JSX.Element | null {
       // right test here.
       if (target?.closest(EXCALIDRAW_SURFACE)) return
 
+      // Next / previous tab (#973) belong to the app handler in every panel.
+      // The panel handlers below take every ArrowLeft / ArrowRight whatever
+      // its modifiers, so the Mac default Cmd+Option+Right opened the sidebar
+      // row under the cursor instead of stepping to the next tab.
+      if (
+        matchesShortcut(e, overrides, 'tabs.next') ||
+        matchesShortcut(e, overrides, 'tabs.previous')
+      ) {
+        return
+      }
+
       // ------- Sidebar navigation (explicit) -----------------------------
       // When focusedPanel is 'sidebar', always handle here — even if the
       // editor still holds stale DOM focus from a previous interaction.
diff --git a/packages/app-core/src/lib/buffer-navigation.test.ts b/packages/app-core/src/lib/buffer-navigation.test.ts
index 85d3e01e7..a2bb035f7 100644
--- a/packages/app-core/src/lib/buffer-navigation.test.ts
+++ b/packages/app-core/src/lib/buffer-navigation.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import type { NoteMeta } from '@shared/ipc'
 import type { PaneLayout } from './pane-layout'
-import { getBufferNavigationTarget, getBufferSelectTarget } from './buffer-navigation'
+import { getBufferNavigationTarget, getBufferSelectTarget, getTabStepTarget } from './buffer-navigation'
 
 function note(path: string, updatedAt: number, folder: NoteMeta['folder'] = 'inbox'): Pick<NoteMeta, 'path' | 'folder' | 'updatedAt'> {
   return { path, folder, updatedAt }
@@ -113,3 +113,50 @@ describe('getBufferSelectTarget (#497)', () => {
     expect(getBufferSelectTarget(layout, 'pane-a', 1)).toEqual({ kind: 'none' })
   })
 })
+
+describe('getTabStepTarget (#973)', () => {
+  const twoPanes: PaneLayout = {
+    kind: 'split',
+    id: 'root',
+    direction: 'row',
+    sizes: [0.5, 0.5],
+    children: [leaf('pane-a', ['one.md', 'two.md'], 'two.md'), leaf('pane-b', ['three.md'], 'three.md')]
+  }
+
+  it('steps in the order gt and gT walk, across panes', () => {
+    expect(getTabStepTarget(twoPanes, 'pane-a', 1)).toEqual({ kind: 'focus', paneId: 'pane-b', path: 'three.md' })
+    expect(getTabStepTarget(twoPanes, 'pane-a', -1)).toEqual({ kind: 'focus', paneId: 'pane-a', path: 'one.md' })
+    for (const delta of [1, -1]) {
+      expect(getTabStepTarget(twoPanes, 'pane-a', delta)).toEqual(
+        getBufferNavigationTarget(twoPanes, 'pane-a', [], delta)
+      )
+    }
+  })
+
+  it('wraps from the last tab to the first and back', () => {
+    expect(getTabStepTarget(twoPanes, 'pane-b', 1)).toEqual({ kind: 'focus', paneId: 'pane-a', path: 'one.md' })
+    const first: PaneLayout = leaf('pane-a', ['one.md', 'two.md'], 'one.md')
+    expect(getTabStepTarget(first, 'pane-a', -1)).toEqual({ kind: 'focus', paneId: 'pane-a', path: 'two.md' })
+  })
+
+  it('goes nowhere with one tab open, where gt would open a recent note', () => {
+    const single = leaf('pane-a', ['one.md'], 'one.md')
+    const notes = [note('two.md', 2), note('one.md', 1)]
+    expect(getTabStepTarget(single, 'pane-a', 1)).toEqual({ kind: 'none' })
+    expect(getBufferNavigationTarget(single, 'pane-a', notes, 1).kind).toBe('open')
+    expect(getTabStepTarget(leaf('pane-a', [], null), 'pane-a', 1)).toEqual({ kind: 'none' })
+  })
+
+  it('starts at the first tab, or the last going back, from a pane showing none', () => {
+    const layout: PaneLayout = {
+      kind: 'split',
+      id: 'root',
+      direction: 'row',
+      sizes: [0.5, 0.5],
+      children: [leaf('pane-a', ['one.md', 'two.md'], 'one.md'), leaf('pane-b', [], null)]
+    }
+    expect(getTabStepTarget(layout, 'pane-b', 1)).toEqual({ kind: 'focus', paneId: 'pane-a', path: 'one.md' })
+    expect(getTabStepTarget(layout, 'pane-b', -1)).toEqual({ kind: 'focus', paneId: 'pane-a', path: 'two.md' })
+  })
+})
+
diff --git a/packages/app-core/src/lib/buffer-navigation.ts b/packages/app-core/src/lib/buffer-navigation.ts
index d5f7f197d..fe0f4009b 100644
--- a/packages/app-core/src/lib/buffer-navigation.ts
+++ b/packages/app-core/src/lib/buffer-navigation.ts
@@ -108,6 +108,33 @@ export function getBufferSelectTarget(
   return targetFor(paneLayout, leaf.id, leaf.tabs, order[clamped - 1])
 }
 
+/** Next / previous tab for the app shortcuts and the palette (#973), with or
+ *  without Vim: the order gt/gT walk, wrapping at either end, but open tabs
+ *  only. gt with one tab open falls back to recent notes or a new quick note,
+ *  the way Vim's buffer commands do; a "next tab" with one tab open has
+ *  nowhere to go. From a pane showing no tab, next starts at the first tab
+ *  and previous at the last. */
+export function getTabStepTarget(
+  paneLayout: PaneLayout,
+  activePaneId: string,
+  delta: number
+): BufferNavigationTarget {
+  const leaf = findLeaf(paneLayout, activePaneId)
+  if (!leaf) return { kind: 'none' }
+
+  const order = openTabOrder(paneLayout)
+  const baseIndex = leaf.activeTab ? order.indexOf(leaf.activeTab) : -1
+  let nextIndex: number
+  if (baseIndex < 0) {
+    if (order.length === 0) return { kind: 'none' }
+    nextIndex = delta > 0 ? 0 : order.length - 1
+  } else {
+    if (order.length < 2) return { kind: 'none' }
+    nextIndex = (((baseIndex + delta) % order.length) + order.length) % order.length
+  }
+  return targetFor(paneLayout, leaf.id, leaf.tabs, order[nextIndex])
+}
+
 function applyTarget(runtime: BufferNavigationRuntime, target: BufferNavigationTarget): void {
   if (target.kind === 'focus') {
     void runtime.focusTabInPane(target.paneId, target.path)
@@ -138,3 +165,7 @@ export function selectActiveBuffer(runtime: BufferNavigationRuntime, index: numb
     getBufferSelectTarget(runtime.paneLayout, runtime.activePaneId, index)
   )
 }
+
+export function stepActiveTab(runtime: BufferNavigationRuntime, delta: number): void {
+  applyTarget(runtime, getTabStepTarget(runtime.paneLayout, runtime.activePaneId, delta))
+}
diff --git a/packages/app-core/src/lib/commands.ts b/packages/app-core/src/lib/commands.ts
index 7855c66c8..5f1ef69f5 100644
--- a/packages/app-core/src/lib/commands.ts
+++ b/packages/app-core/src/lib/commands.ts
@@ -17,6 +17,7 @@ import { buildMoveNotePrompt, moveNoteVocabulary, parseMoveNoteTarget } from './
 import { focusPaneInDirection } from './pane-nav'
 import { focusSidebarPanel } from './sidebar-focus'
 import { findLeaf } from './pane-layout'
+import { getTabStepTarget, stepActiveTab } from './buffer-navigation'
 import { requestPaneMode } from './pane-mode'
 import { resolveQuickNoteTitle } from './quick-note-title'
 import { forwardTaskWithPicker, taskAtEditorCursor } from './forward-task'
@@ -628,6 +629,30 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma
       when: () => getState().closedTabStack.length > 0,
       run: () => getState().reopenLastClosedTab()
     },
+    {
+      id: 'tab.next',
+      title: 'Next Tab',
+      category: 'Tabs',
+      shortcut: shortcut('tabs.next'),
+      keywords: 'cycle switch right gt ctrl+tab',
+      when: () => {
+        const s = getState()
+        return getTabStepTarget(s.paneLayout, s.activePaneId, 1).kind !== 'none'
+      },
+      run: () => stepActiveTab(getState(), 1)
+    },
+    {
+      id: 'tab.previous',
+      title: 'Previous Tab',
+      category: 'Tabs',
+      shortcut: shortcut('tabs.previous'),
+      keywords: 'cycle switch left gT back ctrl+shift+tab',
+      when: () => {
+        const s = getState()
+        return getTabStepTarget(s.paneLayout, s.activePaneId, -1).kind !== 'none'
+      },
+      run: () => stepActiveTab(getState(), -1)
+    },
     {
       id: 'tab.pin',
       title: isActiveTabPinned() ? 'Unpin Tab' : 'Pin Tab',
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 27fbc00de..ec4d7cd92 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -541,6 +541,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'Mod+W', action: 'Close active tab', detail: 'Close the current note or virtual tab. With Settings open it closes Settings instead, and in a floating window or the quick capture window it closes that window, like its close button. While a dialog, palette or menu is open it does nothing, so it never closes the tab behind it; press Esc to dismiss those first. With Vim mode on, Linux and Windows keep Ctrl+W as the pane prefix while a tab is open: close the tab with :q or :bd, from the tab menu, or rebind this.' },
       { keys: 'Ctrl+Tab', action: 'Switch to previous note', detail: 'Switch to the most recently used note. Press again to alternate between the last two notes.' },
       { keys: 'Alt+1 … Alt+9', action: 'Go to tab 1 through 9', detail: 'Jump straight to a tab by position, browser-style (Ctrl+1 … Ctrl+9 on macOS, where Option types characters and the ⌘ digits are taken). Tab numbers count across panes in the same order gt cycles; rebindable under Settings → Keymaps. Vim users get the same jump as {count}gt. Heads-up for macOS with multiple Spaces: Mission Control claims Ctrl+digit for Switch to Desktop, so rebind here or free the key under System Settings → Keyboard Shortcuts.' },
+      { keys: 'Ctrl+PageDown / Ctrl+PageUp', action: 'Next / previous tab', detail: 'Step through the open tabs, counted across panes in the same order gt and gT cycle, wrapping at either end. Works with Vim mode on or off, and from the command palette as Next Tab and Previous Tab. On macOS the defaults are Cmd+Option+Right and Cmd+Option+Left. Rebindable under Settings → Keymaps, to Ctrl+Tab for example if you would rather have that than Switch to previous note.' },
       { keys: 'Shift+Mod+T', action: 'Reopen closed tab', detail: 'Reopen the most recently closed tab, restoring its position and pinned state. Repeat to walk back through your close history.' },
       { keys: 'Mod+O', action: 'Open file', detail: 'Desktop only: pick a Markdown file with the native dialog. A file inside a known vault opens against that vault; anything else opens in a standalone external-file window. Links in that window follow from the file\'s own folder: a relative link such as `../README.md` opens the file it names, and a `[[wikilink]]` finds a page of that name in the folder or below it, each in its own window (or in its vault, when the target lives in one).' },
       { keys: 'Mod+4 / Mod+5 / Mod+6', action: 'Edit / Split / Preview mode', detail: 'Switch the active note between the raw editor, side-by-side split, and rendered preview. Preview opens at the line you were editing; Edit and Split open on the section you were reading when you scrolled away from the cursor in Preview, and keep the cursor where it was when you only peeked.' },
@@ -1073,7 +1074,7 @@ export const HELP_VIM_COMMANDS: HelpExCommand[] = [
   {
     command: 'gt / gT',
     summary: 'Next / previous tab',
-    detail: 'Move through the tabs in the active pane. Also `:tabnext` / `:tabprevious` on the ex line, and rebindable under Settings → Keymaps.'
+    detail: 'Move through the open tabs, across panes. Also `:tabnext` / `:tabprevious` on the ex line, and rebindable under Settings → Keymaps. With Vim mode off, Ctrl+PageDown / Ctrl+PageUp (Cmd+Option+Right / Left on macOS) do the same.'
   },
   {
     command: '{count}gt / {count}gT',
diff --git a/packages/app-core/src/lib/keymaps.test.ts b/packages/app-core/src/lib/keymaps.test.ts
index f8a6063ba..6faeb60bc 100644
--- a/packages/app-core/src/lib/keymaps.test.ts
+++ b/packages/app-core/src/lib/keymaps.test.ts
@@ -231,6 +231,54 @@ describe('sequenceTokenFromEvent', () => {
   })
 })
 
+describe('next / previous tab (#973)', () => {
+  it('default to Ctrl+PageDown / Ctrl+PageUp, and Cmd+Option+arrows on the Mac', () => {
+    withPlatform('darwin', () => {
+      expect(getDefaultKeymapBinding('tabs.next')).toBe('Alt+Mod+ArrowRight')
+      expect(getDefaultKeymapBinding('tabs.previous')).toBe('Alt+Mod+ArrowLeft')
+    })
+    for (const platform of ['linux', 'win32'] as const) {
+      withPlatform(platform, () => {
+        expect(getDefaultKeymapBinding('tabs.next')).toBe('Mod+PageDown')
+        expect(getDefaultKeymapBinding('tabs.previous')).toBe('Mod+PageUp')
+      })
+    }
+  })
+
+  it('fire on those chords and leave plain paging and word motions alone', () => {
+    withPlatform('linux', () => {
+      const ctrl = (key: string): KeyboardEvent => fakeEvent({ key, code: key, ctrlKey: true })
+      expect(matchesShortcut(ctrl('PageDown'), {}, 'tabs.next')).toBe(true)
+      expect(matchesShortcut(ctrl('PageUp'), {}, 'tabs.previous')).toBe(true)
+      expect(matchesShortcut(fakeEvent({ key: 'PageDown', code: 'PageDown' }), {}, 'tabs.next')).toBe(false)
+    })
+    withPlatform('darwin', () => {
+      const cmdOption = (key: string): KeyboardEvent =>
+        fakeEvent({ key, code: key, metaKey: true, altKey: true })
+      expect(matchesShortcut(cmdOption('ArrowRight'), {}, 'tabs.next')).toBe(true)
+      expect(matchesShortcut(cmdOption('ArrowLeft'), {}, 'tabs.previous')).toBe(true)
+      // Cmd+Right is end of line and Option+Right a word: neither is a tab step.
+      const cmdRight = fakeEvent({ key: 'ArrowRight', code: 'ArrowRight', metaKey: true })
+      const optionRight = fakeEvent({ key: 'ArrowRight', code: 'ArrowRight', altKey: true })
+      expect(matchesShortcut(cmdRight, {}, 'tabs.next')).toBe(false)
+      expect(matchesShortcut(optionRight, {}, 'tabs.next')).toBe(false)
+    })
+  })
+
+  it('clash with no other default, and leave Ctrl+Tab to Switch to previous note', () => {
+    for (const platform of ['darwin', 'linux', 'win32'] as const) {
+      withPlatform(platform, () => {
+        for (const id of ['tabs.next', 'tabs.previous'] as const) {
+          expect(findKeymapConflict({}, id, getDefaultKeymapBinding(id))).toBeNull()
+        }
+        const ctrlTab = fakeEvent({ key: 'Tab', code: 'Tab', ctrlKey: true })
+        expect(matchesShortcut(ctrlTab, {}, 'global.toggleRecentNote')).toBe(true)
+        expect(matchesShortcut(ctrlTab, {}, 'tabs.next')).toBe(false)
+      })
+    }
+  })
+})
+
 describe('template shortcuts (#847)', () => {
   it('bind New note from template to ⌘⌥T on the Mac and leave Linux and Windows unbound', () => {
     withPlatform('darwin', () => {
diff --git a/packages/app-core/src/lib/keymaps.ts b/packages/app-core/src/lib/keymaps.ts
index ea614983f..40777e9c9 100644
--- a/packages/app-core/src/lib/keymaps.ts
+++ b/packages/app-core/src/lib/keymaps.ts
@@ -50,6 +50,8 @@ export type KeymapId =
   | "tabs.select7"
   | "tabs.select8"
   | "tabs.select9"
+  | "tabs.next"
+  | "tabs.previous"
   | "vim.leaderPrefix"
   | "vim.leaderOpenBuffers"
   | "vim.leaderWorkflows"
@@ -510,6 +512,33 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [
       defaultBindingMac: `Ctrl+${n}`,
     }),
   ),
+  // Step through the open tabs with or without Vim (#973), in the order gt/gT
+  // and the digit shortcuts use. Ctrl+Tab stays Switch to previous note, so
+  // these take the other common conventions: Ctrl+PageDown / Ctrl+PageUp
+  // (browsers, VS Code), and Cmd+Option+Right / Left on macOS (Chrome, VS
+  // Code), where Ctrl+PageDown needs fn.
+  {
+    id: "tabs.next",
+    kind: "shortcut",
+    scope: "app",
+    group: "global",
+    title: "Next tab",
+    description:
+      "Go to the next open tab, counted across panes in the same order gt cycles, wrapping from the last tab to the first. Works with Vim mode on or off.",
+    defaultBinding: "Mod+PageDown",
+    defaultBindingMac: "Alt+Mod+ArrowRight",
+  },
+  {
+    id: "tabs.previous",
+    kind: "shortcut",
+    scope: "app",
+    group: "global",
+    title: "Previous tab",
+    description:
+      "Go to the previous open tab, counted across panes in the same order gT cycles, wrapping from the first tab to the last. Works with Vim mode on or off.",
+    defaultBinding: "Mod+PageUp",
+    defaultBindingMac: "Alt+Mod+ArrowLeft",
+  },
   {
     id: "vim.leaderPrefix",
     kind: "sequence",
diff --git a/packages/shared-domain/src/keymaps-catalog.ts b/packages/shared-domain/src/keymaps-catalog.ts
index f28257b63..4ccb0dafa 100644
--- a/packages/shared-domain/src/keymaps-catalog.ts
+++ b/packages/shared-domain/src/keymaps-catalog.ts
@@ -82,6 +82,8 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [
   { id: "tabs.select7", group: "global", defaultBinding: "Alt+7", defaultBindingMac: "Ctrl+7", title: "Go to tab 7" },
   { id: "tabs.select8", group: "global", defaultBinding: "Alt+8", defaultBindingMac: "Ctrl+8", title: "Go to tab 8" },
   { id: "tabs.select9", group: "global", defaultBinding: "Alt+9", defaultBindingMac: "Ctrl+9", title: "Go to tab 9" },
+  { id: "tabs.next", group: "global", defaultBinding: "Mod+PageDown", defaultBindingMac: "Alt+Mod+ArrowRight", title: "Next tab" },
+  { id: "tabs.previous", group: "global", defaultBinding: "Mod+PageUp", defaultBindingMac: "Alt+Mod+ArrowLeft", title: "Previous tab" },
   { id: "vim.leaderPrefix", group: "vim", defaultBinding: "Space", title: "Leader key" },
   { id: "vim.leaderOpenBuffers", group: "vim", defaultBinding: "o", title: "Leader: open buffers" },
   { id: "vim.leaderCloudConflicts", group: "vim", defaultBinding: "r", title: "Leader: review Cloud conflicts" },

From 27771b677d0760b8b9b78de05aed224321a65137 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 09:59:38 -0500
Subject: [PATCH 09/20] Fix(calendar): hovering a day shows its note the way it
 reads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Hovering a day in the calendar panel showed the note's index excerpt in
a 260 px card: one run of text with every line joined, cut off after four
lines, with `- [ ]` and the heading words in the middle of it. A Discord
user plans each day in its daily note (Focus, Schedule, Notes, Tasks) and
wanted to read a day at a glance without opening it; the card turned
that plan into one paragraph. The excerpt is the index's summary and
feeds other views and the Go server, so it stays as it is.

The calendar now shows the same preview a link gets (NoteHoverPreview):
the note's opening rendered as the note, headings, lists and task boxes
on their own lines, under the note's title and path. It opens beside the
panel, level with the hovered day, so it never covers the days and weeks
the pointer moves to next; the old card sat over the left of the grid.
Weekly notes in the week column get the same preview.

NoteHoverPreview said "Loading preview…" forever on a note with an empty
body, which the calendar meets often (a day created ahead of time and
left blank). It now tells loading from empty and says "Empty note", for
link previews and the Connections panel too.

Not in this change: plain lines with no blank line between them still
join into one line, as in standard Markdown and the reading view, so the
preview matches Preview mode rather than the editor. Lines kept apart as
a list read one per line. The preview is for the pointer; the calendar's
keyboard selection does not open it.

The manual says so under Settings, Daily notes.

In the built app, a vault with daily notes on and a note shaped like the
report: before, hovering the 28th showed the excerpt card (one paragraph,
no headings, lists or boxes); after, the preview drew 6 headings, 3 list
items and the task box, 380 px wide, to the left of the panel with the
whole grid and week list in view; a day whose note is only its title
showed the title, and a day with no note showed nothing.

Tests: the preview draws a day's plan with its headings, list items and
task box, says an empty note is empty, and says it is loading while the
note is read. The empty-note test fails without this change.

app-core 3,377 tests, typecheck clean.
---
 .../app-core/src/components/CalendarPanel.tsx | 33 ++++----
 .../src/components/NoteHoverPreview.test.ts   | 78 +++++++++++++++++++
 .../src/components/NoteHoverPreview.tsx       |  2 +
 packages/app-core/src/lib/help.ts             |  2 +-
 4 files changed, 96 insertions(+), 19 deletions(-)
 create mode 100644 packages/app-core/src/components/NoteHoverPreview.test.ts

diff --git a/packages/app-core/src/components/CalendarPanel.tsx b/packages/app-core/src/components/CalendarPanel.tsx
index eb39be2dc..4817952e4 100644
--- a/packages/app-core/src/components/CalendarPanel.tsx
+++ b/packages/app-core/src/components/CalendarPanel.tsx
@@ -41,6 +41,7 @@ import { confirmApp } from '../lib/confirm-requests'
 import { usePanelResize } from '../lib/use-panel-resize'
 import { PanelResizeHandle } from './PanelResizeHandle'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
+import { LazyNoteHoverPreview as NoteHoverPreview } from './LazyNoteHoverPreview'
 import { buildTaskMenuItems } from '../lib/task-context-menu'
 
 const FULL_DAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
@@ -377,7 +378,10 @@ export function CalendarPanel({
   )
 
   // --- Hover preview -------------------------------------------------------
-  const [hover, setHover] = useState<{ meta: NoteMeta; right: number; top: number } | null>(null)
+  const [hover, setHover] = useState<{
+    meta: NoteMeta
+    rect: Pick<DOMRect, 'left' | 'top' | 'right' | 'bottom' | 'width' | 'height'>
+  } | null>(null)
   const hoverTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
   const clearHover = useCallback(() => {
     if (hoverTimer.current) clearTimeout(hoverTimer.current)
@@ -386,10 +390,14 @@ export function CalendarPanel({
   }, [])
   const armHover = useCallback((el: HTMLElement, meta: NoteMeta | undefined) => {
     if (!meta) return
-    const rect = el.getBoundingClientRect()
+    // The preview opens beside the panel, level with the day, so it never
+    // covers the days and weeks the pointer moves on to next.
+    const day = el.getBoundingClientRect()
+    const edge = el.closest('[data-calendar-panel]')?.getBoundingClientRect().left ?? day.left
+    const rect = { left: edge, right: edge, width: 0, top: day.top, bottom: day.bottom, height: day.height }
     if (hoverTimer.current) clearTimeout(hoverTimer.current)
     hoverTimer.current = setTimeout(() => {
-      setHover({ meta, right: window.innerWidth - rect.left + 8, top: rect.top })
+      setHover({ meta, rect })
     }, HOVER_DELAY_MS)
   }, [])
   useEffect(() => clearHover, [clearHover])
@@ -1209,21 +1217,10 @@ export function CalendarPanel({
         </div>
       )}
 
-      {hover && (
-        <div
-          className="fixed z-50 max-w-[260px] rounded-lg border border-paper-300/75 bg-paper-50 p-3 shadow-[0_12px_28px_-18px_rgb(var(--z-shadow)/0.8)]"
-          style={{ right: hover.right, top: Math.min(hover.top, window.innerHeight - 140) }}
-        >
-          <div className="truncate text-xs font-semibold text-ink-900">{hover.meta.title}</div>
-          {hover.meta.excerpt ? (
-            <div className="mt-1 line-clamp-4 text-xs leading-5 text-ink-500">
-              {hover.meta.excerpt}
-            </div>
-          ) : (
-            <div className="mt-1 text-xs italic text-ink-400">Empty note</div>
-          )}
-        </div>
-      )}
+      {/* The day's note drawn as the note, the same preview a link gets. The
+          index excerpt runs every line together, so a day's plan would read
+          as one paragraph. */}
+      {hover && <NoteHoverPreview note={hover.meta} anchorRect={hover.rect} />}
 
       {menu && (
         <ContextMenu x={menu.x} y={menu.y} items={menu.items} onClose={() => setMenu(null)} />
diff --git a/packages/app-core/src/components/NoteHoverPreview.test.ts b/packages/app-core/src/components/NoteHoverPreview.test.ts
new file mode 100644
index 000000000..b64e75cb9
--- /dev/null
+++ b/packages/app-core/src/components/NoteHoverPreview.test.ts
@@ -0,0 +1,78 @@
+// @vitest-environment jsdom
+
+import { act, createElement } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { useStore } from '../store'
+import { NoteHoverPreview } from './NoteHoverPreview'
+
+;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+
+const PLAN = [
+  '# Wednesday, October 28, 2026',
+  '',
+  '## Focus',
+  '- Dentist 10:30 a.m.',
+  "- Leave for Lori & Steve's after work",
+  '',
+  '## Tasks',
+  '- [ ] Pack my bags before I leave'
+].join('\n')
+
+const note = { path: 'inbox/Daily Notes/2026-10-28.md', title: '2026-10-28' }
+const anchorRect = { left: 1200, top: 300, right: 1230, bottom: 320, width: 30, height: 20 }
+
+// The calendar's day preview shows the note the way it reads, line by line,
+// instead of the index excerpt that ran every line into one paragraph.
+describe('NoteHoverPreview', () => {
+  let host: HTMLDivElement
+  let root: Root
+  let readNote: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    host = document.createElement('div')
+    document.body.append(host)
+    root = createRoot(host)
+    readNote = vi.fn()
+    ;(window as unknown as { zen: unknown }).zen = { readNote }
+    useStore.setState({ activeNote: null })
+  })
+
+  afterEach(() => {
+    act(() => root.unmount())
+    host.remove()
+    document.body.innerHTML = ''
+  })
+
+  const render = async (): Promise<HTMLElement> => {
+    await act(async () => {
+      root.render(createElement(NoteHoverPreview, { note, anchorRect }))
+    })
+    await act(async () => {
+      await Promise.resolve()
+    })
+    return document.body.querySelector<HTMLElement>('.note-hover-preview')!
+  }
+
+  it("draws a day's plan with its headings, list items and task box", async () => {
+    readNote.mockResolvedValue({ ...note, body: PLAN })
+    const card = await render()
+    const article = card.querySelector('article')!
+    expect([...article.querySelectorAll('h2')].map((h) => h.textContent)).toEqual(['Focus', 'Tasks'])
+    expect(article.querySelectorAll('li')).toHaveLength(3)
+    expect(article.querySelector('input[type="checkbox"]')).not.toBeNull()
+  })
+
+  it('says an empty note is empty instead of loading forever', async () => {
+    readNote.mockResolvedValue({ ...note, body: '' })
+    const card = await render()
+    expect(card.textContent).toContain('Empty note')
+    expect(card.textContent).not.toContain('Loading preview')
+  })
+
+  it('says it is loading while the note is read', async () => {
+    readNote.mockReturnValue(new Promise(() => {}))
+    const card = await render()
+    expect(card.textContent).toContain('Loading preview')
+  })
+})
diff --git a/packages/app-core/src/components/NoteHoverPreview.tsx b/packages/app-core/src/components/NoteHoverPreview.tsx
index a32f906dc..983919089 100644
--- a/packages/app-core/src/components/NoteHoverPreview.tsx
+++ b/packages/app-core/src/components/NoteHoverPreview.tsx
@@ -186,6 +186,8 @@ export function NoteHoverPreview({
             className="prose-zen prose-hover-preview"
             dangerouslySetInnerHTML={{ __html: html }}
           />
+        ) : content ? (
+          <div className="text-sm italic text-ink-400">Empty note</div>
         ) : (
           <div className="text-sm text-ink-400">Loading preview…</div>
         )}
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index ec4d7cd92..089d29d29 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -1190,7 +1190,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [
       { label: 'Vault name', detail: 'What the sidebar header, the vault switcher and the title bar call this vault; the folder keeps its own name on disk. Leave it empty to use the folder name. Saved in the vault’s `.zennotes/vault.json`, so it follows the folder wherever it is opened. Also “Rename Vault…” in the command palette (`:vault_rename`) and the sidebar’s vault menu. Local vaults only.' },
       { label: 'Primary notes location', detail: 'Treat `inbox/` as the main notes area, or use the vault root directly for an Obsidian-style flat vault.' },
       { label: 'New Drawings, Databases & Tasks location', detail: 'Choose where new Excalidraw drawings, databases, and task files are created so they do not pile up in the vault root: the primary notes location (the default), the folder of the note you are currently viewing, or a specific folder you name (e.g. `assets/drawings` or `Tasks`). A specific folder lives inside the primary notes area, so `Tasks` means `inbox/Tasks/` in an Inbox vault and `Tasks/` in a root vault; the folder field shows the exact destination. Search Settings for "tasks folder" or "drawings folder" to jump there. Only new files are affected; existing ones stay put.' },
-      { label: 'Daily notes', detail: "Enable a daily-notes workflow, choose a directory pattern, naming pattern, locale, and template so each day’s note starts in the right place. Supported tokens are `yyyy`, `yy`, `M`, `MM`, `MMM`, `MMMM`, `d`, `dd`, `EEE`, `EEEE`, `w`, and `ww`; quote literal words like `'Daily Notes'/yyyy/MM-MMM`. Open today’s note with `Space d`, `:daily`, or the command palette. For another day, past or future, double-click it in the calendar panel, or follow a link like `[[2026-11-03]]` to a day that has no note yet: both create that day’s note in the right place, from its template. Two task options live here too: “Tasks are due on the note’s date” makes tasks in a daily note show on the calendar for that day (on by default), and “Roll over unfinished tasks to today” moves every unchecked task from past daily notes into today when you open it (off by default; also runnable from the command palette)." },
+      { label: 'Daily notes', detail: "Enable a daily-notes workflow, choose a directory pattern, naming pattern, locale, and template so each day’s note starts in the right place. Supported tokens are `yyyy`, `yy`, `M`, `MM`, `MMM`, `MMMM`, `d`, `dd`, `EEE`, `EEEE`, `w`, and `ww`; quote literal words like `'Daily Notes'/yyyy/MM-MMM`. Open today’s note with `Space d`, `:daily`, or the command palette. For another day, past or future, double-click it in the calendar panel, or follow a link like `[[2026-11-03]]` to a day that has no note yet: both create that day’s note in the right place, from its template. Hover a day in the calendar panel to read its note, drawn the way it reads, without opening it. Two task options live here too: “Tasks are due on the note’s date” makes tasks in a daily note show on the calendar for that day (on by default), and “Roll over unfinished tasks to today” moves every unchecked task from past daily notes into today when you open it (off by default; also runnable from the command palette)." },
       { label: 'Weekly notes', detail: "Enable weekly notes with a directory pattern, naming pattern, locale, and template. Weekly patterns support the same tokens as daily notes plus ISO week `w` and `ww`; the default title pattern is `yyyy-'W'ww`. Open this week’s note with `Space w`, `:weekly`, or the command palette." },
       { label: 'Monthly notes', detail: 'Enable monthly notes with a directory pattern, naming pattern, locale, and template. It creates one note per calendar month, handy for monthly reviews and reflections. The default title pattern is `yyyy-MM` (e.g. `2026-07`). Open this month’s note with `Space m`, `:monthly`, or the command palette. Each notes section in Settings now collapses its fields when its toggle is off.' },
       { label: 'Folder Paths', detail: 'Point any of the four system folders (Inbox, Quick Notes, Archive, Trash) at a directory of your choosing, labels included; stored as `systemFolderPaths` in `vault.json` so the vault stays portable. Relabeling without moving anything on disk works too.' },

From 5d1de89f48b0ab9563c686a47985864ad85ed235 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 09:59:42 -0500
Subject: [PATCH 10/20] Test(editor): fold and diagram tests pass whether or
 not a parse runs out of time

While checking #973, the full app-core run failed about one time in four,
once in cm-heading-fold ("folds the list item on the cursor line") and once
in cm-mermaid-render ("rebuilds when the theme identity changes"), never
when either file ran alone. Both tests assumed a parse finishes inside
CodeMirror's 20 ms slice, and on a cold, loaded worker it sometimes does not.

The fold tests: the "list item folding (#848)" and "heading arrows" mounts
never forced the parse. A cut first parse keeps only the blocks it reached
(markdown runs inside parseMixed, which reports no progress until its base
parse ends), so foldAtCursor found no list, and the `#` lines in the fence
and the indented block read as headings. Both mounts now call forceParsing,
as the other mounts in the repo do. The first describe's mounts stay as
they are: their notes hold no code, and headings are matched by their text.

The diagram test: not the first parse. A cut there is harmless, since the
field rebuilds when the parse finishes. The mount's two nudge edits (insert
a space, delete it) were the exposure: a note under 128 characters parses
from scratch on every edit, under the same 20 ms slice, and a cut parse
drops the fence from the tree. The field then forgets the block, and the
fence returns as a new widget that renders a second time (the "called 2
times" of the failed run), or, when the second nudge is cut, not at all.
The nudges were never needed, because the field has rebuilt on tree changes
since #530, so the mount now ends at forceParsing. The theme test checks
the renderer's calls exactly, right after each step: one render of the
diagram after the mount, one more after the theme change. Reconfiguring
with the same theme key fails it.

Proof: a setup file that lets each 20 ms slice take a chosen number of
parser steps. On the old files, a cut first parse failed 8 to 9 fold tests,
and a cut on the first nudge failed the theme test with the message of the
failed run. The new files pass at every cut point tried. The full app-core
suite passed 16 runs in a row, typecheck clean.

Not covered here: "keeps the last good drawing" still fails when its own
edit's parse is cut, because the cut drops the block's memory in
cm-mermaid-render.ts itself, and six other test files nudge after
forceParsing the same way. Both are being looked at separately.
---
 .../app-core/src/lib/cm-heading-fold.test.ts     |  5 +++++
 .../app-core/src/lib/cm-mermaid-render.test.ts   | 16 +++++++++-------
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/packages/app-core/src/lib/cm-heading-fold.test.ts b/packages/app-core/src/lib/cm-heading-fold.test.ts
index 3f7791a18..cdbeea5bb 100644
--- a/packages/app-core/src/lib/cm-heading-fold.test.ts
+++ b/packages/app-core/src/lib/cm-heading-fold.test.ts
@@ -164,6 +164,9 @@ describe('list item folding (#848)', () => {
       parent,
       state: state.update({ selection: { anchor: state.doc.line(line).from } }).state
     })
+    // Folds read the syntax tree, and on a cold, loaded worker the first parse
+    // can run out of its time budget before it reaches the list.
+    forceParsing(view, text.length, 5000)
     return {
       view,
       done: () => {
@@ -331,6 +334,8 @@ describe('heading arrows', () => {
         extensions: [markdown({ base: markdownLanguage }), headingFolding({ showLevelLabels: true })]
       })
     })
+    // Only the tree knows the `#` lines in the fence and the indented block are code.
+    forceParsing(view, text.length, 5000)
     return {
       view,
       done: () => {
diff --git a/packages/app-core/src/lib/cm-mermaid-render.test.ts b/packages/app-core/src/lib/cm-mermaid-render.test.ts
index 1a9e0beb2..26e8b4c16 100644
--- a/packages/app-core/src/lib/cm-mermaid-render.test.ts
+++ b/packages/app-core/src/lib/cm-mermaid-render.test.ts
@@ -33,10 +33,12 @@ function mount(
       extensions: [markdown({ base: markdownLanguage }), extension]
     })
   })
+  // The field rebuilds whenever the syntax tree changes, so finishing the parse
+  // is all a mount needs. Nothing edits the note after it: a note this short
+  // parses from scratch on every edit, under the same 20 ms budget, and a cut
+  // parse drops the fence from the tree, so the block comes back as a new
+  // widget (a second render) or not at all.
   forceParsing(view, doc.length, 5000)
-  // Nudge a rebuild so decorations reflect the fully parsed tree.
-  view.dispatch({ changes: { from: doc.length, insert: ' ' } })
-  view.dispatch({ changes: { from: doc.length, to: doc.length + 1 } })
   return view
 }
 
@@ -82,18 +84,18 @@ describe('mermaidRenderExtension', () => {
   // The theme identity carries the text font, and a new font has to be measured
   // again, so the widget is rebuilt and asks the renderer (which answers from
   // its cache when only the palette changed).
-  it('rebuilds when the theme identity changes without changing light/dark mode', async () => {
+  it('rebuilds when the theme identity changes without changing light/dark mode', () => {
     mermaidMocks.renderMermaidSvg.mockResolvedValue({ ok: true, svg: '<svg data-theme="a" />' })
     const theme = new Compartment()
     const view = mount(DIAGRAM, undefined, theme.of(mermaidRenderExtension('light', 'theme-a')))
+    const source = 'flowchart LR\n  A --> B'
+    expect(mermaidMocks.renderMermaidSvg.mock.calls).toEqual([[source]])
 
-    await vi.waitFor(() => expect(mermaidMocks.renderMermaidSvg).toHaveBeenCalledTimes(1))
     view.dispatch({
       effects: theme.reconfigure(mermaidRenderExtension('light', 'theme-b'))
     })
 
-    await vi.waitFor(() => expect(mermaidMocks.renderMermaidSvg).toHaveBeenCalledTimes(2))
-    expect(mermaidMocks.renderMermaidSvg).toHaveBeenLastCalledWith(expect.stringContaining('flowchart LR'))
+    expect(mermaidMocks.renderMermaidSvg.mock.calls).toEqual([[source], [source]])
     view.destroy()
   })
 

From 6b230681b902f277f95eedc95d6ae7f7ae0f832c Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 10:13:29 -0500
Subject: [PATCH 11/20] Fix(templates): an edited Daily Note template still
 fills new daily notes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Discord user renamed Focus in the built-in Daily Note template and
left the rest alone. From then on every daily note came out as its title
and nothing else, today's and the ones created ahead from the calendar,
until they reset the template.

Editing a built-in saves an edited copy, a custom template under its own
id that carries the built-in's id as `builtinId`, and mergeTemplates
drops the built-in it replaces. The daily, weekly and monthly note
creators look their template up by the id Periodic notes saved, which is
the built-in's (`builtin.daily`): with the built-in gone from the merged
list and the copy under another id, the lookup found nothing and the note
was created blank. Settings had the same gap and showed the daily note
template as "[Missing template]". The zn TUI already matched both ids.

findTemplate (shared-domain template-files.ts) looks a template up by its
id and then by the built-in id an edited copy stands in for. The store's
periodic note creators, the Settings template picker and workflow
`apply-template` steps go through it. Picking an edited copy in the
picker now saves the built-in's id (templateSettingId), so resetting the
copy falls back to the built-in instead of leaving the setting on a file
that is gone; picking any other template saves its own id as before.

In the built app, a vault with daily notes on, Periodic notes set to the
Daily Note template and an edited copy with Focus renamed to Today:
before, today's note and the 26th double-clicked in the calendar were
each just "# <title>", and Settings read "[Missing template]"; after,
both had the edited body (## Today and their own date heading) and
Settings read "Personal · Daily Note".

Tests: the built-in's id reaches its edited copy once merging dropped the
built-in, own ids and untouched built-ins still resolve, a template with
the id itself wins over a copy pointing at it, missing ids find nothing,
and an edited copy is stored by the built-in's id so a reset falls back;
a workflow step finds an edited built-in by the built-in's id.

app-core 3,383 tests, shared-domain 2,048, typecheck clean.
---
 .../app-core/src/components/SettingsModal.tsx | 21 +++++---
 .../app-core/src/lib/template-files.test.ts   | 53 ++++++++++++++++++-
 .../app-core/src/lib/workflow-run.test.ts     |  5 ++
 packages/app-core/src/lib/workflow-run.ts     | 14 +++--
 packages/app-core/src/store.ts                |  7 +--
 packages/shared-domain/src/template-files.ts  | 23 ++++++++
 6 files changed, 107 insertions(+), 16 deletions(-)

diff --git a/packages/app-core/src/components/SettingsModal.tsx b/packages/app-core/src/components/SettingsModal.tsx
index 6f8df80ca..6f947d108 100644
--- a/packages/app-core/src/components/SettingsModal.tsx
+++ b/packages/app-core/src/components/SettingsModal.tsx
@@ -124,7 +124,12 @@ import {
   specificFolderDestination,
 } from "../lib/vault-layout";
 import { BUILTIN_TEMPLATES } from "@shared/builtin-templates";
-import { composeTemplateFile, mergeTemplates } from "@shared/template-files";
+import {
+  composeTemplateFile,
+  findTemplate,
+  mergeTemplates,
+  templateSettingId,
+} from "@shared/template-files";
 import { TemplateEditorModal } from "./TemplateEditorModal";
 import type { NoteTemplate } from "@bridge-contract/templates";
 import {
@@ -7303,8 +7308,9 @@ function TemplateSelectRow({
 }): JSX.Element {
   // A configured template that no longer exists (deleted) shows as missing so
   // the user can pick a replacement; daily/weekly creation falls back to blank.
-  const missing = !!value && !templates.some((t) => t.id === value);
-  const selected = templates.find((t) => t.id === value);
+  // A built-in's id still names it once edited (findTemplate).
+  const selected = findTemplate(templates, value);
+  const missing = !!value && !selected;
   const triggerLabel = missing
     ? "[Missing template]"
     : selected
@@ -7329,7 +7335,7 @@ function TemplateSelectRow({
   // Highlight the current selection when the menu opens.
   useEffect(() => {
     if (!open) return;
-    const current = value ? items.findIndex((t) => t?.id === value) : 0;
+    const current = value ? items.findIndex((t) => !!t && t === selected) : 0;
     setActiveIdx(current >= 0 ? current : 0);
   }, [open, items, value]);
 
@@ -7402,7 +7408,8 @@ function TemplateSelectRow({
       setActiveIdx((i) => Math.max(0, i - 1));
     } else if (e.key === "Enter" || e.key === " ") {
       e.preventDefault();
-      commit(items[activeIdx]?.id);
+      const picked = items[activeIdx];
+      commit(picked ? templateSettingId(picked) : undefined);
     } else if (e.key === "Escape") {
       e.preventDefault();
       setOpen(false);
@@ -7474,7 +7481,7 @@ function TemplateSelectRow({
           >
             <div ref={listRef} className="min-h-0 flex-1 overflow-y-auto py-1">
               {items.map((tpl, idx) => {
-                const isSelected = tpl ? tpl.id === value : !value && !missing;
+                const isSelected = tpl ? tpl === selected : !value && !missing;
                 const text = tpl
                   ? `${tpl.category} · ${tpl.name}`
                   : "None (blank note)";
@@ -7485,7 +7492,7 @@ function TemplateSelectRow({
                     role="option"
                     aria-selected={isSelected}
                     data-idx={idx}
-                    onClick={() => commit(tpl?.id)}
+                    onClick={() => commit(tpl ? templateSettingId(tpl) : undefined)}
                     onMouseMove={() => setActiveIdx(idx)}
                     className={[
                       "flex w-full items-center px-3 py-1.5 text-left text-sm",
diff --git a/packages/app-core/src/lib/template-files.test.ts b/packages/app-core/src/lib/template-files.test.ts
index 72df194cd..5a34514c8 100644
--- a/packages/app-core/src/lib/template-files.test.ts
+++ b/packages/app-core/src/lib/template-files.test.ts
@@ -1,11 +1,14 @@
 import { describe, expect, it } from 'vitest'
 import {
   composeTemplateFile,
+  findTemplate,
   mergeTemplates,
   parseCustomTemplate,
   parseFrontmatter,
-  slugifyTemplateName
+  slugifyTemplateName,
+  templateSettingId
 } from '@shared/template-files'
+import { BUILTIN_TEMPLATES } from '@shared/builtin-templates'
 import type { NoteTemplate } from '@bridge-contract/templates'
 
 describe('parseFrontmatter', () => {
@@ -140,3 +143,51 @@ describe('composeTemplateFile builtinId round trip', () => {
     expect(parseCustomTemplate(raw, '.zennotes/templates/adr.md').builtinId).toBe('builtin.adr')
   })
 })
+
+describe('findTemplate', () => {
+  // The Daily Note built-in, edited in Settings: Focus renamed to Today.
+  const edited = parseCustomTemplate(
+    composeTemplateFile({
+      name: 'Daily Note',
+      category: 'Personal',
+      titleTemplate: '{{date:YYYY-MM-DD}}',
+      builtinId: 'builtin.daily',
+      body: '# {{date:dddd, MMMM D, YYYY}}\n\n## Today\n\n- {{cursor}}\n'
+    }),
+    '.zennotes/templates/daily-note.md'
+  )
+  const merged = mergeTemplates(BUILTIN_TEMPLATES, [edited])
+
+  it("reaches the edited copy through the built-in's id, which merging drops", () => {
+    expect(merged.some((t) => t.id === 'builtin.daily')).toBe(false)
+    const found = findTemplate(merged, 'builtin.daily')
+    expect(found?.id).toBe(edited.id)
+    expect(found?.body).toContain('## Today')
+  })
+
+  it('still finds templates by their own id, and a built-in nobody edited', () => {
+    expect(findTemplate(merged, edited.id)).toBe(edited)
+    expect(findTemplate(merged, 'builtin.weekly')?.builtin).toBe(true)
+  })
+
+  it('prefers a template that has the id itself over an edited copy pointing at it', () => {
+    const both: NoteTemplate[] = [
+      { ...edited, id: 'custom:other', builtinId: 'builtin.adr' },
+      BUILTIN_TEMPLATES.find((t) => t.id === 'builtin.adr')!
+    ]
+    expect(findTemplate(both, 'builtin.adr')?.builtin).toBe(true)
+  })
+
+  it('finds nothing for no id or a template that is gone', () => {
+    expect(findTemplate(merged, undefined)).toBeUndefined()
+    expect(findTemplate(merged, 'custom:deleted')).toBeUndefined()
+  })
+
+  it("stores the built-in's id for an edited copy, so a reset falls back to the built-in", () => {
+    expect(templateSettingId(edited)).toBe('builtin.daily')
+    expect(templateSettingId(BUILTIN_TEMPLATES[0])).toBe(BUILTIN_TEMPLATES[0].id)
+    const afterReset = mergeTemplates(BUILTIN_TEMPLATES, [])
+    expect(findTemplate(afterReset, templateSettingId(edited))?.id).toBe('builtin.daily')
+  })
+})
+
diff --git a/packages/app-core/src/lib/workflow-run.test.ts b/packages/app-core/src/lib/workflow-run.test.ts
index 826f315ee..b07769484 100644
--- a/packages/app-core/src/lib/workflow-run.test.ts
+++ b/packages/app-core/src/lib/workflow-run.test.ts
@@ -317,6 +317,11 @@ describe('findTemplateByRef', () => {
     expect(findTemplateByRef(TEMPLATES, 'ADR')?.id).toBe('builtin.adr')
   })
 
+  it("finds an edited built-in by the built-in's id", () => {
+    const edited = template({ id: 'custom:adr', name: 'Decision record', builtinId: 'builtin.adr' })
+    expect(findTemplateByRef([template(), edited], 'builtin.adr')?.id).toBe('custom:adr')
+  })
+
   it('answers null for the unknown and the blank', () => {
     expect(findTemplateByRef(TEMPLATES, 'meeting-notes')).toBeNull()
     expect(findTemplateByRef(TEMPLATES, '  ')).toBeNull()
diff --git a/packages/app-core/src/lib/workflow-run.ts b/packages/app-core/src/lib/workflow-run.ts
index bcde94d1e..0d407129c 100644
--- a/packages/app-core/src/lib/workflow-run.ts
+++ b/packages/app-core/src/lib/workflow-run.ts
@@ -18,7 +18,7 @@ import type {
   WorkflowRunSummary,
   WorkflowUndoResult
 } from '@bridge-contract/workflows'
-import { slugifyTemplateName } from '@shared/template-files'
+import { findTemplate, slugifyTemplateName } from '@shared/template-files'
 import type { Diagnostic, Workflow, WorkflowOp } from '@shared/workflows/types'
 // Type only, so nothing here imports the store at runtime: this file stays the
 // pure half of running a workflow.
@@ -299,10 +299,11 @@ export function collectRunSideEffects(ops: readonly WorkflowOp[]): RunSideEffect
  * Find the template an `apply-template` step names.
  *
  * The reference is whatever the author typed as one token, so matching is
- * forgiving in a fixed order: the template's id (`custom:reading-notes`), its
- * display name ignoring case, then slug equality so `book-review` finds a
- * template named "Book Review". First match wins within each rule, which keeps
- * the answer stable when two templates share a slug.
+ * forgiving in a fixed order: the template's id (`custom:reading-notes`), the
+ * built-in id an edited copy stands in for, its display name ignoring case,
+ * then slug equality so `book-review` finds a template named "Book Review".
+ * First match wins within each rule, which keeps the answer stable when two
+ * templates share a slug.
  */
 export function findTemplateByRef(
   templates: readonly NoteTemplate[],
@@ -314,6 +315,9 @@ export function findTemplateByRef(
   for (const template of templates) {
     if (template.id.toLowerCase() === lower) return template
   }
+  // A built-in's id still names it after it was edited.
+  const byBuiltinId = findTemplate(templates, trimmed)
+  if (byBuiltinId) return byBuiltinId
   for (const template of templates) {
     if (template.name.toLowerCase() === lower) return template
   }
diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts
index 7b4b0ac83..e16e7caba 100644
--- a/packages/app-core/src/store.ts
+++ b/packages/app-core/src/store.ts
@@ -196,6 +196,7 @@ import type { WorkflowRunReceipt, WorkflowUndoResult } from '@bridge-contract/wo
 import { BUILTIN_TEMPLATES } from '@shared/builtin-templates'
 import {
   composeTemplateFile,
+  findTemplate,
   mergeTemplates,
   parseCustomTemplate,
   slugifyTemplateName
@@ -477,13 +478,13 @@ async function refreshVaultIndexes(): Promise<void> {
     })
 }
 
-/** Find a template (built-in or custom) by id, or undefined if it's gone. */
+/** Find a template (built-in or custom) by id, or undefined if it's gone. A
+ *  built-in's id reaches its edited copy (see findTemplate). */
 function resolveTemplate(
   customTemplates: NoteTemplate[],
   id: string | undefined
 ): NoteTemplate | undefined {
-  if (!id) return undefined
-  return mergeTemplates(BUILTIN_TEMPLATES, customTemplates).find((t) => t.id === id)
+  return findTemplate(mergeTemplates(BUILTIN_TEMPLATES, customTemplates), id)
 }
 
 function isDeletedAssetRecord(value: unknown): value is DeletedAsset {
diff --git a/packages/shared-domain/src/template-files.ts b/packages/shared-domain/src/template-files.ts
index 9d41c1cfb..8b1537086 100644
--- a/packages/shared-domain/src/template-files.ts
+++ b/packages/shared-domain/src/template-files.ts
@@ -114,6 +114,29 @@ export function mergeTemplates(
   })
 }
 
+/**
+ * The template an id names in a merged list. Editing a built-in saves an
+ * edited copy under its own id, carrying the built-in's id as `builtinId`,
+ * and mergeTemplates drops the built-in it replaces. Anything that stored
+ * the built-in's id (the daily, weekly and monthly note templates) has to
+ * reach the edited copy through it: looking up the id alone found nothing,
+ * so a daily note came out blank once the Daily Note template was edited.
+ */
+export function findTemplate(
+  templates: readonly NoteTemplate[],
+  id: string | undefined
+): NoteTemplate | undefined {
+  if (!id) return undefined
+  return templates.find((t) => t.id === id) ?? templates.find((t) => t.builtinId === id)
+}
+
+/** The id a setting should store for `template`: the built-in's for an
+ *  edited copy, so resetting the copy falls back to the built-in rather
+ *  than leaving the setting pointing at a file that is gone. */
+export function templateSettingId(template: NoteTemplate): string {
+  return template.builtinId ?? template.id
+}
+
 export interface ComposeTemplateInput {
   name: string
   description?: string

From b24efdeddeae6f005409d7a097faeca9b3104da9 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 10:30:28 -0500
Subject: [PATCH 12/20] Test(editor): six more editor test mounts end on a
 complete parse

Six test files mounted the editor, forced the parse, then "nudged" the note
(insert a space at one end, delete it) so the plugin under test would rebuild.
A note under 128 characters parses from scratch on every edit, under
CodeMirror's 20 ms slice, so on a cold, loaded worker a nudge could end on a
cut tree that stops before the node under test. Same cause as the mermaid
mount in 5d1de89f.

Where the plugin or field rebuilds when the syntax tree changes, the nudge
was never needed (forceParsing dispatches when the tree changed), so those
mounts now end at forceParsing: cm-math-render, cm-math-nav,
cm-wikilink-render, cm-table and table-to-database. cm-task-metadata's
plugin redraws only on edits and viewport changes, so its mount finishes the
parse first and then adds the plugin with StateEffect.appendConfig, which
keeps the parsed tree. cm-table's "re-resizing replaces the marker" also
finishes the parse between its two drags: a cut parse of the first drag's
marker edit dropped the table, and the second drag found no handle.

Proof: a setup file that lets each 20 ms slice take a chosen number of parser
steps and cuts only the parses dispatched from the mount helpers. On the old
files, cutting the nudges failed 41 of 116 tests (cm-math-render 2, cm-table
37, table-to-database 2). cm-wikilink-render, cm-task-metadata and
cm-math-nav were immune only because their code sits in the note's first
block, which the first parser step always covers; probe notes with the code
further down failed the old mounts and passed the new ones. The new files
pass with every parse cut, at every cut point tried. The full app-core suite
passed 6 runs in a row, typecheck clean.
---
 packages/app-core/src/lib/cm-math-nav.test.ts    |  6 +++---
 packages/app-core/src/lib/cm-math-render.test.ts |  7 ++++---
 packages/app-core/src/lib/cm-table.test.ts       | 11 ++++++++---
 .../app-core/src/lib/cm-task-metadata.test.ts    | 16 ++++++++--------
 .../app-core/src/lib/cm-wikilink-render.test.ts  | 10 ++++++----
 .../app-core/src/lib/table-to-database.test.ts   |  7 ++++---
 6 files changed, 33 insertions(+), 24 deletions(-)

diff --git a/packages/app-core/src/lib/cm-math-nav.test.ts b/packages/app-core/src/lib/cm-math-nav.test.ts
index 76ba34a74..1a6656dd7 100644
--- a/packages/app-core/src/lib/cm-math-nav.test.ts
+++ b/packages/app-core/src/lib/cm-math-nav.test.ts
@@ -38,10 +38,10 @@ describe('keyboard navigation into rendered block math', () => {
       })
     })
     views.push(view)
+    // The math field rebuilds whenever the syntax tree changes, so finishing the
+    // parse is all a mount needs. An edit after it would reparse this short note
+    // from scratch under the same 20 ms budget and could end on a cut tree.
     forceParsing(view, DOC.length, 5000)
-    // Nudge a rebuild so decorations reflect the fully parsed tree.
-    view.dispatch({ changes: { from: DOC.length, insert: ' ' } })
-    view.dispatch({ changes: { from: DOC.length, to: DOC.length + 1 } })
     view.focus()
     return view
   }
diff --git a/packages/app-core/src/lib/cm-math-render.test.ts b/packages/app-core/src/lib/cm-math-render.test.ts
index 04bc6dfeb..0b5e6ed6d 100644
--- a/packages/app-core/src/lib/cm-math-render.test.ts
+++ b/packages/app-core/src/lib/cm-math-render.test.ts
@@ -18,10 +18,11 @@ function mount(doc: string, selection?: EditorSelection | { anchor: number }): E
       extensions: [markdown({ base: markdownLanguage }), mathRenderExtension('katex')]
     })
   })
+  // The field rebuilds whenever the syntax tree changes, so finishing the parse
+  // is all a mount needs. Nothing edits the note after it: a note this short
+  // parses from scratch on every edit, under the same 20 ms budget, and a cut
+  // parse can stop before the quote around a $$ block.
   forceParsing(view, doc.length, 5000)
-  // Nudge a rebuild so decorations reflect the fully parsed tree.
-  view.dispatch({ changes: { from: doc.length, insert: ' ' } })
-  view.dispatch({ changes: { from: doc.length, to: doc.length + 1 } })
   return view
 }
 
diff --git a/packages/app-core/src/lib/cm-table.test.ts b/packages/app-core/src/lib/cm-table.test.ts
index 48707b3e1..85e67272a 100644
--- a/packages/app-core/src/lib/cm-table.test.ts
+++ b/packages/app-core/src/lib/cm-table.test.ts
@@ -51,10 +51,11 @@ function mount(doc: string): EditorView {
       extensions: [markdown({ base: markdownLanguage }), history(), tablePlugin]
     })
   })
-  // Ensure the GFM table node is parsed, then nudge the field to rebuild.
+  // Ensure the GFM table node is parsed. The field rebuilds whenever the syntax
+  // tree changes, so that is all a mount needs. Nothing edits the note after
+  // it: an edit at the top reparses from there under the same 20 ms budget,
+  // and a cut parse can stop before the table.
   forceParsing(view, doc.length, 5000)
-  view.dispatch({ changes: { from: 0, insert: ' ' } })
-  view.dispatch({ changes: { from: 0, to: 1 } })
   return view
 }
 
@@ -789,6 +790,10 @@ describe('tablePlugin — column widths (#294)', () => {
   it('re-resizing replaces the marker — never duplicates it', () => {
     const view = mount(PLAIN_DOC)
     drag(view, 100, 180)
+    // The marker edit reparses this short note under the 20 ms budget, and a
+    // cut parse stops before the table. Finish it, as the app's parse worker
+    // would, so the second drag finds the widget again.
+    forceParsing(view, view.state.doc.length, 5000)
     drag(view, 100, 140)
     const markers = view.state.doc.toString().match(/zen:cols/g) ?? []
     expect(markers.length).toBe(1)
diff --git a/packages/app-core/src/lib/cm-task-metadata.test.ts b/packages/app-core/src/lib/cm-task-metadata.test.ts
index b786d5ba6..b50c78079 100644
--- a/packages/app-core/src/lib/cm-task-metadata.test.ts
+++ b/packages/app-core/src/lib/cm-task-metadata.test.ts
@@ -2,7 +2,7 @@
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { forceParsing } from '@codemirror/language'
-import { EditorState } from '@codemirror/state'
+import { EditorState, StateEffect } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { describe, expect, it } from 'vitest'
 import { taskMetadataExtension } from './cm-task-metadata'
@@ -12,15 +12,15 @@ function mount(doc: string): EditorView {
   document.body.append(parent)
   const view = new EditorView({
     parent,
-    state: EditorState.create({
-      doc,
-      extensions: [markdown({ base: markdownLanguage }), taskMetadataExtension]
-    })
+    state: EditorState.create({ doc, extensions: [markdown({ base: markdownLanguage })] })
   })
+  // The plugin redraws on edits and viewport changes, not when only the syntax
+  // tree changes, so it joins once the parse is complete and builds against the
+  // full tree. An edit would not do: a note this short parses from scratch on
+  // every edit, under the same 20 ms budget, and a cut parse can stop before
+  // the code fence.
   forceParsing(view, doc.length, 5000)
-  // nudge the doc so the plugin rebuilds against a fully-parsed tree
-  view.dispatch({ changes: { from: doc.length, insert: ' ' } })
-  view.dispatch({ changes: { from: doc.length, to: doc.length + 1 } })
+  view.dispatch({ effects: StateEffect.appendConfig.of(taskMetadataExtension) })
   return view
 }
 const classesOn = (view: EditorView, sel: string) =>
diff --git a/packages/app-core/src/lib/cm-wikilink-render.test.ts b/packages/app-core/src/lib/cm-wikilink-render.test.ts
index 27117a665..0fcdf79c5 100644
--- a/packages/app-core/src/lib/cm-wikilink-render.test.ts
+++ b/packages/app-core/src/lib/cm-wikilink-render.test.ts
@@ -26,13 +26,15 @@ function mount(doc: string, anchor: number): EditorView {
   })
 }
 
-/** Mount and force a full markdown parse so code-context detection is reliable. */
+/**
+ * Mount and force a full markdown parse so code-context detection is reliable.
+ * The plugin redraws when only the syntax tree changes, so nothing edits the
+ * note after the parse: a note this short parses from scratch on every edit,
+ * under the same 20 ms budget, and a cut parse can stop before the code.
+ */
 function mountParsed(doc: string, anchor: number): EditorView {
   const view = mount(doc, anchor)
   forceParsing(view, doc.length, 5000)
-  // Nudge a no-op change so decorations rebuild against the parsed tree.
-  view.dispatch({ changes: { from: doc.length, insert: ' ' } })
-  view.dispatch({ changes: { from: doc.length, to: doc.length + 1 } })
   return view
 }
 
diff --git a/packages/app-core/src/lib/table-to-database.test.ts b/packages/app-core/src/lib/table-to-database.test.ts
index c72f6d710..618afc9d7 100644
--- a/packages/app-core/src/lib/table-to-database.test.ts
+++ b/packages/app-core/src/lib/table-to-database.test.ts
@@ -51,10 +51,11 @@ function mount(doc: string, withWidgets: boolean): EditorView {
       ]
     })
   })
+  // The table field rebuilds whenever the syntax tree changes, so finishing the
+  // parse is all a mount needs. Nothing edits the note after it: an edit at the
+  // top reparses from there under the same 20 ms budget, and a cut parse can
+  // stop before the table.
   forceParsing(view, doc.length, 5000)
-  // Nudge the table field so it rebuilds against the completed parse.
-  view.dispatch({ changes: { from: 0, insert: ' ' } })
-  view.dispatch({ changes: { from: 0, to: 1 } })
   return view
 }
 

From 2f8c825482cc2b513b006f4f7e7d451f73cbf98c Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 10:30:41 -0500
Subject: [PATCH 13/20] Fix(editor): task metadata chips redraw when a cut
 parse finishes

One more plugin of the kind c9502598 fixed. cm-task-metadata reads the
syntax tree to skip task-looking lines inside code, but rebuilt only on an
edit or a scroll. CodeMirror parses under a time budget and finishes a cut
parse in a later update that changes nothing else, so a task line inside a
code fence that the first parse had not reached kept its priority, due date
and @field chips until the next edit or scroll.

The plugin now also rebuilds when syntaxTree(update.startState) differs from
syntaxTree(update.state), as the others do. Its test changes only the tree
(the markdown language swapped in through a compartment) and fails without
this change. With the plugin redrawing on tree changes, the test mount no
longer adds the plugin after the parse; it ends at forceParsing like the
other mounts.
---
 .../app-core/src/lib/cm-task-metadata.test.ts | 39 +++++++++++++++----
 packages/app-core/src/lib/cm-task-metadata.ts |  9 ++++-
 2 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/packages/app-core/src/lib/cm-task-metadata.test.ts b/packages/app-core/src/lib/cm-task-metadata.test.ts
index b50c78079..86c65a4ad 100644
--- a/packages/app-core/src/lib/cm-task-metadata.test.ts
+++ b/packages/app-core/src/lib/cm-task-metadata.test.ts
@@ -2,7 +2,7 @@
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
 import { forceParsing } from '@codemirror/language'
-import { EditorState, StateEffect } from '@codemirror/state'
+import { Compartment, EditorState } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { describe, expect, it } from 'vitest'
 import { taskMetadataExtension } from './cm-task-metadata'
@@ -12,15 +12,16 @@ function mount(doc: string): EditorView {
   document.body.append(parent)
   const view = new EditorView({
     parent,
-    state: EditorState.create({ doc, extensions: [markdown({ base: markdownLanguage })] })
+    state: EditorState.create({
+      doc,
+      extensions: [markdown({ base: markdownLanguage }), taskMetadataExtension]
+    })
   })
-  // The plugin redraws on edits and viewport changes, not when only the syntax
-  // tree changes, so it joins once the parse is complete and builds against the
-  // full tree. An edit would not do: a note this short parses from scratch on
-  // every edit, under the same 20 ms budget, and a cut parse can stop before
-  // the code fence.
+  // The plugin redraws whenever the syntax tree changes, so finishing the parse
+  // is all a mount needs. Nothing edits the note after it: a note this short
+  // parses from scratch on every edit, under the same 20 ms budget, and a cut
+  // parse can stop before the code fence.
   forceParsing(view, doc.length, 5000)
-  view.dispatch({ effects: StateEffect.appendConfig.of(taskMetadataExtension) })
   return view
 }
 const classesOn = (view: EditorView, sel: string) =>
@@ -73,4 +74,26 @@ describe('cm-task-metadata (#454)', () => {
     expect(classesOn(view, '.cm-task-prio-low')).toEqual(['!low'])
     view.destroy()
   })
+
+  it('redraws when only the syntax tree changes, as when a cut parse finishes', () => {
+    // Swapping the language in changes the tree and nothing else: no edit, no
+    // selection, no viewport. A parse that finishes after its time budget ran
+    // out reaches the plugin the same way.
+    const language = new Compartment()
+    const doc = '```md\n- [ ] Example !high\n```\n\n- [ ] Real !low'
+    const parent = document.createElement('div')
+    document.body.append(parent)
+    const view = new EditorView({
+      parent,
+      state: EditorState.create({ doc, extensions: [language.of([]), taskMetadataExtension] })
+    })
+    // No tree yet, so nothing says the fence is code.
+    expect(classesOn(view, '.cm-task-prio-high')).toEqual(['!high'])
+    view.dispatch({ effects: language.reconfigure(markdown({ base: markdownLanguage })) })
+    forceParsing(view, doc.length, 5000)
+    expect(classesOn(view, '.cm-task-prio-high')).toEqual([])
+    expect(classesOn(view, '.cm-task-prio-low')).toEqual(['!low'])
+    view.destroy()
+    parent.remove()
+  })
 })
diff --git a/packages/app-core/src/lib/cm-task-metadata.ts b/packages/app-core/src/lib/cm-task-metadata.ts
index 8cfa287f0..1ec137516 100644
--- a/packages/app-core/src/lib/cm-task-metadata.ts
+++ b/packages/app-core/src/lib/cm-task-metadata.ts
@@ -11,6 +11,7 @@
  *
  * WYSIWYG-only: registered via `wysiwygExtensions()`.
  */
+import { syntaxTree } from '@codemirror/language'
 import { RangeSetBuilder } from '@codemirror/state'
 import {
   Decoration,
@@ -70,7 +71,13 @@ const taskMetadataPlugin = ViewPlugin.fromClass(
       this.decorations = buildDecorations(view)
     }
     update(update: ViewUpdate): void {
-      if (update.docChanged || update.viewportChanged) {
+      if (
+        update.docChanged ||
+        update.viewportChanged ||
+        // A parse cut short by its time budget finishes in a later update
+        // that changes nothing else.
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      ) {
         this.decorations = buildDecorations(update.view)
       }
     }

From ab96e7978f57b1b1762b881a25b10ee064beef49 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 10:30:55 -0500
Subject: [PATCH 14/20] Fix(diagrams): a diagram keeps its last good drawing
 through a cut parse

A mermaid or d2 block edited into an invalid source keeps showing its last
good drawing instead of an error, from a memory that follows the block
through edits. The field rebuilt that list of memories from the fences in
the current syntax tree only, so one update whose parse ran out of time
before a block dropped the block's memory. When the parse caught up, the
block came back as a new one and showed the error. In the test suite this
was "keeps the last good drawing for a block while its edited source is
invalid" failing when its own edit's parse was cut.

While the tree is incomplete, the memories of fences past where the parse
stopped are now kept until a tree reaches them again; only a complete tree
can say a block is gone. Where it stopped is the end of the tree's last
block: the note language's mixed parser pads a cut tree to the note's full
length, so tree.length cannot tell.

Tests: a parse cut on purpose (the clock stalled for one edit, so the 20 ms
slice stops after its first step) keeps the drawing in plain markdown and in
the note language; both fail without this change, and a version that reads
tree.length fails the note language case. A deleted fence is still
forgotten once a complete parse no longer has it, so a new invalid fence
typed in its place shows the error; a version that always kept memories
fails that test.

Not changed: fences past a cut still show as source until the parse catches
up, as every decoration that reads the tree does today.
---
 .../src/lib/cm-mermaid-render.test.ts         | 98 ++++++++++++++++++-
 .../app-core/src/lib/cm-mermaid-render.ts     | 14 ++-
 2 files changed, 110 insertions(+), 2 deletions(-)

diff --git a/packages/app-core/src/lib/cm-mermaid-render.test.ts b/packages/app-core/src/lib/cm-mermaid-render.test.ts
index 26e8b4c16..adbd2bd63 100644
--- a/packages/app-core/src/lib/cm-mermaid-render.test.ts
+++ b/packages/app-core/src/lib/cm-mermaid-render.test.ts
@@ -1,10 +1,11 @@
 // @vitest-environment jsdom
 
 import { markdown, markdownLanguage } from '@codemirror/lang-markdown'
-import { forceParsing } from '@codemirror/language'
+import { forceParsing, syntaxTreeAvailable } from '@codemirror/language'
 import { Compartment, EditorState, type EditorSelection, type Extension } from '@codemirror/state'
 import { EditorView } from '@codemirror/view'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { noteMarkdown } from './cm-markdown-language'
 import { mermaidBlockLineRanges, mermaidRenderExtension } from './cm-mermaid-render'
 
 // mermaid itself is never loaded here: the widget paints asynchronously and
@@ -44,6 +45,22 @@ function mount(
 
 const DIAGRAM = 'start\n\n```mermaid\nflowchart LR\n  A --> B\n```\n\nend'
 
+/** Runs `edit` while every clock read jumps 25 ms, so the parse that follows
+ *  runs out of CodeMirror's 20 ms budget after its first step, as it does on a
+ *  stalled worker. Here that step parses `start` and stops before the fence. */
+function withStalledClock(edit: () => void): void {
+  let now = Date.now()
+  const clock = vi.spyOn(Date, 'now').mockImplementation(() => (now += 25))
+  try {
+    edit()
+  } finally {
+    clock.mockRestore()
+  }
+}
+
+/** Lets a mocked render's promise settle. */
+const settle = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0))
+
 describe('mermaidRenderExtension', () => {
   beforeEach(() => {
     mermaidMocks.peekMermaidSvg.mockReset().mockReturnValue(null)
@@ -122,6 +139,85 @@ describe('mermaidRenderExtension', () => {
     view.destroy()
   })
 
+  // A parse that runs out of time keeps only the blocks it reached, and the
+  // rest of the note catches up on a later update. The block is still there in
+  // between, so it must still have its last good drawing when the parse comes
+  // back to it. The app's note language pads a cut tree to the note's length,
+  // which is why both languages are checked.
+  describe('when a parse runs out of time before the block', () => {
+    function mountIn(language: Extension, doc = DIAGRAM): EditorView {
+      const parent = document.createElement('div')
+      document.body.append(parent)
+      const view = new EditorView({
+        parent,
+        state: EditorState.create({
+          doc,
+          selection: { anchor: 0 },
+          extensions: [language, mermaidRenderExtension('light', 'theme-a')]
+        })
+      })
+      forceParsing(view, doc.length, 5000)
+      return view
+    }
+
+    beforeEach(() => {
+      mermaidMocks.renderMermaidSvg.mockImplementation((source: string) =>
+        Promise.resolve(
+          source.includes('INVALID')
+            ? { ok: false, error: 'parse failed' }
+            : { ok: true, svg: '<svg data-last-good="true" />' }
+        )
+      )
+    })
+
+    it.each([
+      ['markdown', () => markdown({ base: markdownLanguage })],
+      ['the note language', () => noteMarkdown()]
+    ])('keeps the last good drawing through the cut parse (%s)', async (_name, language) => {
+      const view = mountIn(language())
+      await vi.waitFor(() =>
+        expect(view.dom.querySelector('[data-last-good="true"]')).not.toBeNull()
+      )
+      const from = DIAGRAM.indexOf('flowchart LR')
+      withStalledClock(() =>
+        view.dispatch({ changes: { from, to: from + 'flowchart LR'.length, insert: 'INVALID' } })
+      )
+      // The edit's parse stopped before the fence, so the block is out of the tree.
+      expect(syntaxTreeAvailable(view.state)).toBe(false)
+      expect(mermaidBlockLineRanges(view.state)).toEqual([])
+
+      forceParsing(view, view.state.doc.length, 5000)
+      expect(mermaidMocks.renderMermaidSvg).toHaveBeenLastCalledWith('INVALID\n  A --> B')
+      await settle()
+      expect(view.dom.querySelector('[data-last-good="true"]')).not.toBeNull()
+      expect(view.dom.querySelector('.cm-mermaid-error')).toBeNull()
+      view.destroy()
+    })
+
+    it('still forgets a block once a complete parse no longer has it', async () => {
+      // The fence ends the note, so nothing the parse reaches comes after it.
+      const doc = 'start\n\n```mermaid\nflowchart LR\n  A --> B\n```'
+      const view = mountIn(markdown({ base: markdownLanguage }), doc)
+      await vi.waitFor(() =>
+        expect(view.dom.querySelector('[data-last-good="true"]')).not.toBeNull()
+      )
+      const from = doc.indexOf('```mermaid')
+      withStalledClock(() => view.dispatch({ changes: { from, to: doc.length } }))
+      expect(syntaxTreeAvailable(view.state)).toBe(false)
+      forceParsing(view, view.state.doc.length, 5000)
+
+      // A new fence typed where the old one was is a new block: with an invalid
+      // source it has no drawing to fall back on.
+      view.dispatch({ changes: { from, insert: '```mermaid\nINVALID\n```' } })
+      forceParsing(view, view.state.doc.length, 5000)
+      expect(mermaidMocks.renderMermaidSvg).toHaveBeenLastCalledWith('INVALID')
+      await settle()
+      expect(view.dom.querySelector('.cm-mermaid-error')).not.toBeNull()
+      expect(view.dom.querySelector('[data-last-good="true"]')).toBeNull()
+      view.destroy()
+    })
+  })
+
   // A rendered block is one widget with no cursor coordinates inside it, so
   // vertical motion sails over it unless the nav helpers know the block is
   // there. Without these ranges a keyboard-only user can never open the source.
diff --git a/packages/app-core/src/lib/cm-mermaid-render.ts b/packages/app-core/src/lib/cm-mermaid-render.ts
index 241f71bb2..6c049fda3 100644
--- a/packages/app-core/src/lib/cm-mermaid-render.ts
+++ b/packages/app-core/src/lib/cm-mermaid-render.ts
@@ -26,7 +26,7 @@
  *
  * WYSIWYG-only: registered via `wysiwygExtensions()`.
  */
-import { syntaxTree } from '@codemirror/language'
+import { syntaxTree, syntaxTreeAvailable } from '@codemirror/language'
 import { Facet, RangeSetBuilder, StateField, type EditorState, type Extension } from '@codemirror/state'
 import { Decoration, type DecorationSet, EditorView, WidgetType } from '@codemirror/view'
 
@@ -247,6 +247,18 @@ function buildMermaidDecorations(
     }
   })
 
+  // A parse that ran out of time stops partway down the note and finishes on a
+  // later, parse-only update. Fences past where it stopped are still in the
+  // note, so they keep their memory until a tree reaches them again. (The
+  // note's mixed parser pads a cut tree to the note's length, so where it
+  // stopped is the end of its last block, not tree.length.)
+  if (!syntaxTreeAvailable(state)) {
+    const reach = tree.topNode.lastChild?.to ?? 0
+    for (const [from, memory] of previousMemory) {
+      if (from > reach) blocks.push({ from, memory })
+    }
+  }
+
   return { decorations: builder.finish(), blockLines, blocks }
 }
 

From de82278efe939a119a4cbea14d9a3aebfd7dd7fa Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 11:42:31 -0500
Subject: [PATCH 15/20] Feat(databases): create pages for every record at once
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A database record is a note links can reach only once it has a page,
and a page was made only by opening its record, one at a time. A
Discord user converted CSVs to databases with zn and found none of
their records could be linked until each was opened, with hundreds of
records to go.

"Create pages for all records" gives every record that has no page its
page note in the database's folder, the page opening it would make: the
row's properties as frontmatter and its title as the heading.
planRecordPages (shared-domain database-records.ts) decides which: a
record whose page is mapped and still there keeps it, one whose page was
deleted gets a new one, as opening it would, and one with an empty title
is left out, since its page would only be "Untitled" and nothing could
link to it by name. The note list says whether a mapped page still
exists, so planning reads no files. The store action asks first, with
the counts, writes the pages, then updates the schema once on the latest
doc, so a row edited or deleted meanwhile keeps that edit; when a page
fails partway it keeps the pages already written and says how far it
got. A loose CSV, which cannot hold pages, is told so.

It runs from a new ⋯ menu in the database header, from the command
palette while a database is open (Create Pages for All Records), and as
`O` in the grid, the capital of `o` (open this record's page). `O` is a
new single-key shortcut, so it only fires in Vim mode.

`zn base pages` does the same from the terminal, with the same rules, in
the zn repo. The manual names it, the grid key and the menu.

Not in this change: the grid's existing single keys (j, k, o, x, dd and
the rest) still fire with Vim mode off.

In the built app, a vault with Books.base holding only its data.csv
(three titled records and a blank one) and a note linking [[Kindred]] and
[[Emma]]: before, both links drew as broken; the ⋯ menu asked "Create
pages for 3 records?", left the blank record out, created Dune.md,
Kindred.md and Emma.md with their frontmatter and heading, mapped them in
schema.json, and both links drew as live; `O` then reported that every
titled record has a page; the palette listed the action; with Vim mode
off, `O` did nothing and wrote nothing. A vault whose pages `zn base
pages` wrote opened with its links live and every page counted.

Tests: the planner (pages kept, deleted pages made again, blank titles
and a database with no title field left out) and the store action (the
pages and the schema, declining, a failure partway, nothing to do).

app-core 3,391 tests, shared-domain 2,051, typecheck clean.
---
 .../src/components/DatabaseTableView.tsx      |   8 ++
 .../app-core/src/components/DatabaseView.tsx  |  32 ++++-
 .../src/database-record-pages.test.ts         | 125 ++++++++++++++++++
 packages/app-core/src/lib/commands.ts         |  17 +++
 packages/app-core/src/lib/database-cells.ts   |   2 +
 packages/app-core/src/lib/help.ts             |   5 +-
 packages/app-core/src/store.ts                |  93 ++++++++++++-
 .../src/database-records.test.ts              |  43 ++++++
 .../shared-domain/src/database-records.ts     |  44 ++++++
 9 files changed, 365 insertions(+), 4 deletions(-)
 create mode 100644 packages/app-core/src/database-record-pages.test.ts
 create mode 100644 packages/shared-domain/src/database-records.test.ts

diff --git a/packages/app-core/src/components/DatabaseTableView.tsx b/packages/app-core/src/components/DatabaseTableView.tsx
index 8a3388707..6dd2ab59e 100644
--- a/packages/app-core/src/components/DatabaseTableView.tsx
+++ b/packages/app-core/src/components/DatabaseTableView.tsx
@@ -344,6 +344,14 @@ export function DatabaseTableView({ csvPath, doc, view, isActive }: Props): JSX.
         e.preventDefault()
         return openPage(c.row.id)
       }
+      case 'O': {
+        // Every record's page at once (o opens one). A new single-key
+        // shortcut, so it stays off with Vim mode off.
+        if (!useStore.getState().vimMode) return
+        e.preventDefault()
+        void useStore.getState().createAllRecordPages(csvPath)
+        return
+      }
       case 'm': {
         // Open the context menu (like the sidebar's `m`), anchored to the
         // active header or cell. On a header → field menu; on a cell → row menu.
diff --git a/packages/app-core/src/components/DatabaseView.tsx b/packages/app-core/src/components/DatabaseView.tsx
index d8859131e..b9586c324 100644
--- a/packages/app-core/src/components/DatabaseView.tsx
+++ b/packages/app-core/src/components/DatabaseView.tsx
@@ -17,7 +17,7 @@ import { DatabaseBoardView } from './DatabaseBoardView'
 import { ContextMenu, type ContextMenuItem } from './ContextMenu'
 import { DatabaseFilterMenu } from './DatabaseFilterMenu'
 import { Button, IconButton } from './ui/Button'
-import { DatabaseIcon, TableIcon, KanbanIcon, PlusIcon, FilterIcon } from './icons'
+import { DatabaseIcon, TableIcon, KanbanIcon, PlusIcon, FilterIcon, MoreIcon } from './icons'
 
 /**
  * Host for a CSV database tab: loads the database, renders the header
@@ -40,6 +40,9 @@ export function DatabaseView({
   const updateDatabaseRows = useStore((s) => s.updateDatabaseRows)
   const updateDatabaseSchema = useStore((s) => s.updateDatabaseSchema)
   const renameDatabase = useStore((s) => s.renameDatabase)
+  const createAllRecordPages = useStore((s) => s.createAllRecordPages)
+  const vimMode = useStore((s) => s.vimMode)
+  const [databaseMenu, setDatabaseMenu] = useState<{ x: number; y: number } | null>(null)
   const [viewMenu, setViewMenu] = useState<{ viewId: string; x: number; y: number } | null>(null)
   const [renamingView, setRenamingView] = useState<string | null>(null)
   const [rawMode, setRawMode] = useState(false)
@@ -218,6 +221,17 @@ export function DatabaseView({
               </Button>
             </>
           )}
+          <IconButton
+            size="sm"
+            title="More database actions"
+            aria-label="More database actions"
+            onClick={(e) => {
+              const rect = e.currentTarget.getBoundingClientRect()
+              setDatabaseMenu({ x: rect.left, y: rect.bottom + 4 })
+            }}
+          >
+            <MoreIcon className="h-3.5 w-3.5" />
+          </IconButton>
         </div>
       </header>
 
@@ -244,6 +258,22 @@ export function DatabaseView({
         />
       )}
 
+      {databaseMenu && (
+        <ContextMenu
+          x={databaseMenu.x}
+          y={databaseMenu.y}
+          items={[
+            {
+              label: 'Create pages for all records',
+              hint: vimMode ? 'O' : undefined,
+              disabled: doc.rows.length === 0 || !formDirFromCsvPath(csvPath),
+              onSelect: () => void createAllRecordPages(csvPath)
+            }
+          ]}
+          onClose={() => setDatabaseMenu(null)}
+        />
+      )}
+
       {viewMenu && (
         <ContextMenu
           x={viewMenu.x}
diff --git a/packages/app-core/src/database-record-pages.test.ts b/packages/app-core/src/database-record-pages.test.ts
new file mode 100644
index 000000000..9de71bffb
--- /dev/null
+++ b/packages/app-core/src/database-record-pages.test.ts
@@ -0,0 +1,125 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { DatabaseDoc } from '@shared/databases'
+
+// "Create pages for all records": a database converted from a CSV has no
+// record pages, and a record is a note links can reach only once it has one.
+
+const CSV = 'Books.base/data.csv'
+const DUNE = 'Books.base/Dune.md'
+const GONE = 'Books.base/Emma.md'
+
+beforeEach(() => {
+  vi.resetModules()
+  localStorage.clear()
+})
+
+async function setup(overrides: { createRecordPage?: (csv: string, title: string, body: string) => Promise<string> } = {}) {
+  const files = new Map([[DUNE, '---\nAuthor: Herbert\n---\n# Dune\n\nRead twice.\n']])
+  const metadata = (path: string) => ({
+    path, title: path.split('/').pop()!.replace(/\.md$/, ''), folder: 'inbox' as const,
+    siblingOrder: 0, createdAt: 1, updatedAt: 1, size: 0, tags: [], wikilinks: [], assetEmbeds: [], hasAttachments: false, excerpt: ''
+  })
+  const doc: DatabaseDoc = {
+    version: 1, path: CSV, title: 'Books', idFieldId: 'id', activeViewId: 'table', views: [],
+    fields: [{ id: 'id', name: 'ID', type: 'text' }, { id: 'title', name: 'Title', type: 'text' }, { id: 'author', name: 'Author', type: 'text' }],
+    rows: [
+      { id: 'dune', cells: { id: 'dune', title: 'Dune', author: 'Herbert' } },
+      // Mapped to a page that was deleted since.
+      { id: 'emma', cells: { id: 'emma', title: 'Emma', author: 'Austen' } },
+      { id: 'kindred', cells: { id: 'kindred', title: 'Kindred', author: 'Butler' } },
+      { id: 'blank', cells: { id: 'blank', title: '  ', author: 'Nobody' } }
+    ],
+    pages: { dune: DUNE, emma: GONE },
+    pageHasContent: { dune: true, emma: false }
+  }
+  const createRecordPage = vi.fn(
+    overrides.createRecordPage ??
+      (async (_csv: string, title: string, body: string) => {
+        const path = `Books.base/${title}.md`
+        files.set(path, body)
+        return path
+      })
+  )
+  const bridge = {
+    getCapabilities: () => ({}), listNotes: async () => [...files.keys()].map(metadata), listFolders: async () => [],
+    scanTasks: async () => [], scanTasksForPath: async () => [], hasAssetsDir: async () => false,
+    getRemoteWorkspaceInfo: async () => null, setVaultSettings: async (s: unknown) => s,
+    readNote: vi.fn(async (path: string) => ({ ...metadata(path), body: files.get(path) ?? '' })),
+    writeDatabaseRows: vi.fn(async () => {}),
+    writeDatabaseSchema: vi.fn(async () => {}),
+    createRecordPage
+  }
+  Object.defineProperty(window, 'zen', { configurable: true, value: bridge })
+  const { useStore } = await import('./store')
+  const prompts = await import('./lib/confirm-requests')
+  const toasts = (await import('./lib/toast')).useToastStore
+  useStore.setState({
+    vault: { root: '/test', name: 'Test' },
+    databases: { [CSV]: doc },
+    notes: [...files.keys()].map(metadata),
+    noteContents: {},
+    noteDirty: {}
+  })
+  const run = async (answer: boolean) => {
+    const running = useStore.getState().createAllRecordPages(CSV)
+    await vi.waitFor(() => expect(prompts.getConfirmRequest()).not.toBeNull())
+    const request = prompts.getConfirmRequest()!
+    prompts.settleConfirmRequest(request, answer)
+    return { request, result: await running }
+  }
+  return { useStore, bridge, files, run, prompts, toasts, doc }
+}
+
+describe('createAllRecordPages', () => {
+  it('gives each record without a page its page, and leaves the rest', async () => {
+    const s = await setup()
+    const { request, result } = await s.run(true)
+
+    expect(request.options.title).toBe('Create pages for 2 records?')
+    expect(result).toEqual({ created: 2, existing: 1, untitled: 1 })
+    expect(s.bridge.createRecordPage.mock.calls.map((c) => c[1])).toEqual(['Emma', 'Kindred'])
+    // The page the grid's own "open" would make: properties as frontmatter, the title as its heading.
+    expect(s.files.get('Books.base/Kindred.md')).toBe('---\nAuthor: Butler\n---\n# Kindred\n\n')
+    const pages = s.useStore.getState().databases[CSV].pages
+    expect(pages).toEqual({ dune: DUNE, emma: 'Books.base/Emma.md', kindred: 'Books.base/Kindred.md' })
+    expect(s.files.get(DUNE)).toContain('Read twice.')
+  })
+
+  it('writes nothing when the question is declined', async () => {
+    const s = await setup()
+    const { result } = await s.run(false)
+    expect(result).toBeNull()
+    expect(s.bridge.createRecordPage).not.toHaveBeenCalled()
+    expect(s.useStore.getState().databases[CSV].pages).toEqual(s.doc.pages)
+  })
+
+  it('keeps the pages it made when one fails partway, and says so', async () => {
+    let calls = 0
+    const s = await setup({
+      createRecordPage: async (_csv, title) => {
+        calls++
+        if (calls === 2) throw new Error('disk full')
+        return `Books.base/${title}.md`
+      }
+    })
+    const { result } = await s.run(true)
+    expect(result).toEqual({ created: 1, existing: 1, untitled: 1 })
+    expect(s.useStore.getState().databases[CSV].pages).toMatchObject({ emma: 'Books.base/Emma.md' })
+    expect(s.useStore.getState().databases[CSV].pages).not.toHaveProperty('kindred')
+    expect(s.toasts.getState().toasts.at(-1)?.message).toContain('Created 1 of 2 record pages, then: disk full')
+  })
+
+  it('asks nothing when every titled record already has its page', async () => {
+    const s = await setup()
+    const done = {
+      ...s.doc,
+      rows: s.doc.rows.filter((r) => r.id === 'dune' || r.id === 'blank')
+    }
+    s.useStore.setState({ databases: { [CSV]: done } })
+    const result = await s.useStore.getState().createAllRecordPages(CSV)
+    expect(result).toEqual({ created: 0, existing: 1, untitled: 1 })
+    expect(s.prompts.getConfirmRequest()).toBeNull()
+    expect(s.bridge.createRecordPage).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/app-core/src/lib/commands.ts b/packages/app-core/src/lib/commands.ts
index 5f1ef69f5..e7a7ccdd5 100644
--- a/packages/app-core/src/lib/commands.ts
+++ b/packages/app-core/src/lib/commands.ts
@@ -34,6 +34,7 @@ import {
 import { harperEditorConfig, harperSupported } from './harper-runtime'
 import { reflowParagraph } from './cm-reflow'
 import { convertTableToDatabase } from './table-to-database'
+import { csvPathFromDatabaseTab } from '@shared/databases'
 import { canRenameVault, renameVaultWithPrompt } from './rename-vault'
 import { promptImageWidth } from './image-resize'
 import { copyLinkAtCursor } from './link-copy'
@@ -1031,6 +1032,22 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma
         view.focus()
       }
     },
+    {
+      id: 'database.create-record-pages',
+      title: 'Create Pages for All Records',
+      category: 'Database',
+      shortcut: getState().vimMode ? 'O' : undefined,
+      keywords: 'database base records rows pages notes link wikilink bulk all csv',
+      when: () => {
+        const tab = getActiveLeaf()?.activeTab
+        return !!tab && !!csvPathFromDatabaseTab(tab)
+      },
+      run: async () => {
+        const tab = getActiveLeaf()?.activeTab
+        const csvPath = tab ? csvPathFromDatabaseTab(tab) : null
+        if (csvPath) await getState().createAllRecordPages(csvPath)
+      }
+    },
     {
       id: 'table.to-database',
       title: 'Convert Table to Database…',
diff --git a/packages/app-core/src/lib/database-cells.ts b/packages/app-core/src/lib/database-cells.ts
index 1ed9ba510..1ef85f40e 100644
--- a/packages/app-core/src/lib/database-cells.ts
+++ b/packages/app-core/src/lib/database-cells.ts
@@ -30,9 +30,11 @@ export {
   deleteRow,
   ensureSelectOption,
   fieldsById,
+  planRecordPages,
   recordTitle,
   setCell
 } from '@shared/database-records'
+export type { RecordPagePlan } from '@shared/database-records'
 
 const genId = defaultGenId
 
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 089d29d29..aa004dfb5 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -452,7 +452,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'Any CSV is a database',
     body:
-      'A `.csv` file in your vault is a full Notion-style database, with zero new dependencies. The same data shows up as an editable Table (inline cell editing) and as a Board grouped by a select field; add and switch views freely. Fields are typed as text, number, checkbox, date, select, multi-select, or note link (single or multi), and support sort, filter, and a raw-CSV toggle, while every row keeps a stable id so external edits round-trip cleanly. Open any row as a real Markdown note, a “record page” in a per-database folder, whose frontmatter mirrors the row’s properties and whose body is a freeform page. Create one with “New Database” in the command palette or by right-clicking a folder → New database.'
+      'A `.csv` file in your vault is a full Notion-style database, with zero new dependencies. The same data shows up as an editable Table (inline cell editing) and as a Board grouped by a select field; add and switch views freely. Fields are typed as text, number, checkbox, date, select, multi-select, or note link (single or multi), and support sort, filter, and a raw-CSV toggle, while every row keeps a stable id so external edits round-trip cleanly. Open any row as a real Markdown note, a “record page” in a per-database folder, whose frontmatter mirrors the row’s properties and whose body is a freeform page. A record can be linked once it has a page; to give every record one at once (a database converted from a CSV starts with none), choose Create pages for all records in the database’s ⋯ menu or the command palette, or press `O` in the grid in Vim mode. Create one with “New Database” in the command palette or by right-clicking a folder → New database.'
   },
   {
     title: 'Databases discover your notes',
@@ -462,7 +462,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [
   {
     title: 'The CLI is the bridge to launchers',
     body:
-      'The `zn` command-line tool can list, read, search, capture, edit, archive, trash, inspect tasks, work with databases (`zn base list / rows / get / add / set / create`: add rows with record pages, set fields with the grid’s exact semantics, locally or against a self-hosted server; renaming a record page with `zn rename` keeps its row pointing at it), and start the MCP server without the app running. With no `--vault` or `--server` flag, `zn` works on the vault the app has open, a connected server included (it sends the token `zn connect` saved for that server, or `ZENNOTES_REMOTE_TOKEN` / `--token`). Raycast uses it for search, then uses `zennotes://open` and `zennotes://open-window` links to bring the selected note back into ZenNotes. On macOS, Settings → CLI can install the bundled Raycast extension locally so users do not need to wait for the Raycast Store version.'
+      'The `zn` command-line tool can list, read, search, capture, edit, archive, trash, inspect tasks, work with databases (`zn base list / rows / get / add / set / create / pages`: add rows with record pages, give every record its page with `zn base pages`, set fields with the grid’s exact semantics, locally or against a self-hosted server; renaming a record page with `zn rename` keeps its row pointing at it), and start the MCP server without the app running. With no `--vault` or `--server` flag, `zn` works on the vault the app has open, a connected server included (it sends the token `zn connect` saved for that server, or `ZENNOTES_REMOTE_TOKEN` / `--token`). Raycast uses it for search, then uses `zennotes://open` and `zennotes://open-window` links to bring the selected note back into ZenNotes. On macOS, Settings → CLI can install the bundled Raycast extension locally so users do not need to wait for the Raycast Store version.'
   },
   {
     title: 'Excalidraw drawings are first-class files',
@@ -766,6 +766,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'm', action: 'Open the row menu', detail: 'On a cell, open the right-click menu for that record (Open, Delete, and the rest).' },
       { keys: 'Space / x', action: 'Select the row', detail: 'Toggle the row’s selection for bulk actions.' },
       { keys: 'o', action: 'Open the record page', detail: 'Open the row as a Markdown note in the per-database folder.' },
+      { keys: 'O', action: 'Create pages for all records', detail: 'Give every record that has no page its note in the per-database folder, so each one can be linked with [[wikilinks]]. Records that already have a page keep it, and rows with an empty title are left out. Asks first. Also in the database’s ⋯ menu and the command palette.' },
       { keys: 'Ctrl-o', action: 'Jump back to the grid', detail: 'From a record page, return to the database grid, whether you opened it as a .csv file or via New Database.' },
       { keys: 'Ctrl-w k / j / h / l', action: 'Move to tabs or panes', detail: 'Move between the grid, the tab strip, and split panes, exactly like from the editor.' },
       { keys: 'a', action: 'Add a row', detail: 'Append a new empty record and move the cursor to it.' },
diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts
index e16e7caba..86408b077 100644
--- a/packages/app-core/src/store.ts
+++ b/packages/app-core/src/store.ts
@@ -87,7 +87,7 @@ import {
   isDatabaseCsvPath
 } from '@shared/databases'
 import { parseFrontmatter } from '@shared/template-files'
-import { recordTitle, composePageBody } from './lib/database-cells'
+import { recordTitle, composePageBody, planRecordPages } from './lib/database-cells'
 import { applyManualMove, manualOrderCompare, parentDirOf } from './lib/manual-order'
 import { TAGS_TAB_PATH, isTagsTabPath } from '@shared/tags'
 import { WORKFLOWS_TAB_PATH, isWorkflowsTabPath } from '@shared/workflows-view'
@@ -3435,6 +3435,11 @@ interface Store {
   forgetDatabase: (csvPath: string) => Promise<void>
   /** Open a record as a markdown "page" note (creating + linking it on first open). */
   openRecordPage: (csvPath: string, rowId: string) => Promise<void>
+  /** Give every record of a database that has no page its page note, so each
+   *  one is a note links can reach. Asks first; null when nothing ran. */
+  createAllRecordPages: (
+    csvPath: string
+  ) => Promise<{ created: number; existing: number; untitled: number } | null>
   /** Rename a record's linked page note to match its title (no-op if unlinked). */
   renameRecordPage: (csvPath: string, rowId: string) => Promise<void>
   /** Add or remove a tag from the Tags view selection without touching
@@ -6713,6 +6718,92 @@ export const useStore = create<Store>((set, get) => {
     }
     await get().selectNote(pagePath)
   }),
+  createAllRecordPages: trackNoteWrite(null, async (csvPath) => {
+    const doc = get().databases[csvPath]
+    if (!doc) return null
+    if (!formDirFromCsvPath(csvPath)) {
+      useToastStore
+        .getState()
+        .addToast('This database is a loose CSV file, which cannot hold record pages.', 'info')
+      return null
+    }
+    // Record pages are notes (listNotes surfaces them), so the note list says
+    // which mapped pages are still there without reading every file.
+    const notePaths = new Set(get().notes.map((note) => note.path))
+    const plan = planRecordPages(doc, (path) => notePaths.has(path))
+    const counts = { created: 0, existing: plan.existing, untitled: plan.untitled }
+    if (plan.missing.length === 0) {
+      useToastStore
+        .getState()
+        .addToast(
+          plan.untitled > 0
+            ? `Every titled record already has a page. ${plan.untitled} ${plan.untitled === 1 ? 'record without a title has' : 'records without a title have'} none.`
+            : 'Every record already has a page.',
+          'info'
+        )
+      return counts
+    }
+    const n = plan.missing.length
+    const ok = await confirmApp({
+      title: `Create pages for ${n} ${n === 1 ? 'record' : 'records'}?`,
+      description:
+        `Each gets a note in the ${doc.title} folder, named after the record, so it can be linked.` +
+        (plan.existing > 0
+          ? ` ${plan.existing} ${plan.existing === 1 ? 'record that already has a page keeps' : 'records that already have a page keep'} it.`
+          : '') +
+        (plan.untitled > 0
+          ? ` ${plan.untitled} ${plan.untitled === 1 ? 'record without a title is' : 'records without a title are'} left out.`
+          : ''),
+      confirmLabel: 'Create pages',
+      cancelLabel: 'Cancel'
+    })
+    if (!ok) return null
+    const pages: Record<string, string> = {}
+    let failure: unknown = null
+    for (const row of plan.missing) {
+      const title = recordTitle(doc, row)
+      try {
+        pages[row.id] = await window.zen.createRecordPage(
+          csvPath,
+          title,
+          composePageBody(doc, row, `# ${title}\n\n`)
+        )
+      } catch (err) {
+        failure = err
+        break
+      }
+    }
+    counts.created = Object.keys(pages).length
+    // One schema write for the whole run, onto the latest doc: rows edited or
+    // deleted while the pages were written keep those edits.
+    const latest = get().databases[csvPath]
+    if (latest && counts.created > 0) {
+      const live = new Set(latest.rows.map((row) => row.id))
+      const kept = Object.fromEntries(Object.entries(pages).filter(([id]) => live.has(id)))
+      get().updateDatabaseSchema(csvPath, {
+        ...latest,
+        pages: { ...(latest.pages ?? {}), ...kept },
+        pageHasContent: {
+          ...(latest.pageHasContent ?? {}),
+          ...Object.fromEntries(Object.keys(kept).map((id) => [id, false]))
+        }
+      })
+    }
+    if (failure) {
+      console.error('createAllRecordPages failed', failure)
+      useToastStore
+        .getState()
+        .addToast(
+          `Created ${counts.created} of ${n} record pages, then: ${failure instanceof Error ? failure.message : String(failure)}`,
+          'error'
+        )
+      return counts
+    }
+    useToastStore
+      .getState()
+      .addToast(`Created ${counts.created} record ${counts.created === 1 ? 'page' : 'pages'}.`, 'success')
+    return counts
+  }),
   renameRecordPage: async (csvPath, rowId) => {
     const isCurrent = captureFolderActionContext(get)
     const doc = get().databases[csvPath]
diff --git a/packages/shared-domain/src/database-records.test.ts b/packages/shared-domain/src/database-records.test.ts
new file mode 100644
index 000000000..96bf8bb96
--- /dev/null
+++ b/packages/shared-domain/src/database-records.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { planRecordPages } from './database-records'
+import type { DatabaseDoc } from './databases'
+
+const doc: DatabaseDoc = {
+  version: 1,
+  path: 'Books.base/data.csv',
+  title: 'Books',
+  idFieldId: 'id',
+  activeViewId: 'table',
+  views: [],
+  fields: [
+    { id: 'id', name: 'ID', type: 'text' },
+    { id: 'title', name: 'Title', type: 'text' }
+  ],
+  rows: [
+    { id: 'a', cells: { id: 'a', title: 'Dune' } },
+    { id: 'b', cells: { id: 'b', title: 'Emma' } },
+    { id: 'c', cells: { id: 'c', title: 'Kindred' } },
+    { id: 'd', cells: { id: 'd', title: '   ' } }
+  ],
+  pages: { a: 'Books.base/Dune.md', b: 'Books.base/Emma.md' }
+}
+
+describe('planRecordPages', () => {
+  it('plans a page for records without one, or whose page is gone, in row order', () => {
+    const plan = planRecordPages(doc, (path) => path === 'Books.base/Dune.md')
+    expect(plan.missing.map((r) => r.id)).toEqual(['b', 'c'])
+    expect(plan.existing).toBe(1)
+    expect(plan.untitled).toBe(1)
+  })
+
+  it('plans nothing for a database whose titled records all have pages', () => {
+    const plan = planRecordPages({ ...doc, rows: doc.rows.slice(0, 2) }, () => true)
+    expect(plan).toEqual({ missing: [], existing: 2, untitled: 0 })
+  })
+
+  it('leaves out every record when the database has no title field', () => {
+    const plan = planRecordPages({ ...doc, fields: [doc.fields[0]], pages: {} }, () => false)
+    expect(plan.missing).toEqual([])
+    expect(plan.untitled).toBe(4)
+  })
+})
diff --git a/packages/shared-domain/src/database-records.ts b/packages/shared-domain/src/database-records.ts
index d40d8a08d..fe6b9cf1a 100644
--- a/packages/shared-domain/src/database-records.ts
+++ b/packages/shared-domain/src/database-records.ts
@@ -39,6 +39,50 @@ export function composePageBody(doc: DatabaseDoc, row: DbRow, body: string): str
   return `${lines.join('\n')}\n${body.replace(/^\n+/, '')}`
 }
 
+/** What giving every record its page would do: the records that get one, and
+ *  how many are left as they are. */
+export interface RecordPagePlan {
+  /** Records with no page, or whose page is gone, in row order. */
+  missing: DbRow[]
+  /** Records whose page is mapped and still there. */
+  existing: number
+  /** Records with an empty title field, left without a page. */
+  untitled: number
+}
+
+/**
+ * Plan "Create pages for all records". A record is a note links can reach
+ * only once it has a page, and a page used to be made only by opening the
+ * record, one at a time: a database converted from a CSV of hundreds of rows
+ * had none to link to. A record whose page is mapped and still exists keeps
+ * it; one whose page was deleted gets a new one, as opening it would; one
+ * with an empty title is skipped, since its page would only be "Untitled"
+ * and nothing could link to it by name. `zn base pages` (zennotescli
+ * internal/database) mirrors these rules.
+ */
+export function planRecordPages(
+  doc: DatabaseDoc,
+  pageExists: (path: string) => boolean
+): RecordPagePlan {
+  const titleField = doc.fields.find((f) => f.id !== doc.idFieldId)
+  const missing: DbRow[] = []
+  let existing = 0
+  let untitled = 0
+  for (const row of doc.rows) {
+    const page = doc.pages?.[row.id]
+    if (page && pageExists(page)) {
+      existing++
+      continue
+    }
+    if (!(titleField ? (row.cells[titleField.id] ?? '').trim() : '')) {
+      untitled++
+      continue
+    }
+    missing.push(row)
+  }
+  return { missing, existing, untitled }
+}
+
 export function setCell(doc: DatabaseDoc, rowId: string, fieldId: string, value: string): DatabaseDoc {
   return {
     ...doc,

From ad5e52d99702cfea2c22e57509b79f73c6608694 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 11:53:20 -0500
Subject: [PATCH 16/20] Fix(databases): a record's page file already in the
 folder gets linked, not copied

The Discord user whose CSV databases had no linkable records worked
around it before "Create pages for all records" existed: a script wrote
a page file for each record, named after it, into the database folder,
but no schema.json entry maps a row to it. "Create pages for all
records" took those records for pageless and wrote `Dune 2.md` and
`Kindred 2.md` beside the files, pointed the rows at the copies, and
left two notes per title for `[[Dune]]` to choose between. Opening one
record did the same, as it always had for an unmapped file.

A record with no mapped page is now linked to a page file already there
under its name: in the database folder or its `pages/` subfolder, under
each name a page gets (the app's note-title rules for a local page, the
slash-only rule of the server path and zn, and the title as it is,
which a script most likely used). recordPageToAdopt (shared-domain
database-records.ts) picks the file, the first candidate that exists and
no row maps, and planRecordPages and openRecordPage both go through it,
so a file another row maps, or an earlier record with the same title
took, is never taken twice. A linked file is left as it is by the bulk
run; opening it re-mirrors the row's properties into its frontmatter and
keeps the body, as for any page. The confirm and the toast count the
links ("Created 1 record page and linked 2 existing pages."). zn mirrors
the candidates name for name.

In the built app, Books.base with its data.csv, a script-made Dune.md
and Kindred.md, and no schema: before, the run wrote Dune 2.md and
Kindred 2.md and mapped the rows to them; after, it asked "Create pages
for 1 record?" noting the 2 files it would link, created only Emma.md,
mapped Dune.md and Kindred.md, left their "My notes on" bodies as they
were, and every link drew as live.

Tests: files in the folder and in pages/ linked, one mapped by another
row left alone, twins sharing no file, the candidate names; the bulk run
linking without writing, and opening one record linking its file.

app-core 3,394 tests, shared-domain 2,054, typecheck clean.
---
 .../src/database-record-pages.test.ts         | 72 +++++++++++++++++--
 packages/app-core/src/lib/database-cells.ts   |  1 +
 packages/app-core/src/lib/help.ts             |  2 +-
 packages/app-core/src/store.ts                | 59 +++++++++++----
 .../src/database-records.test.ts              | 33 ++++++++-
 .../shared-domain/src/database-records.ts     | 70 ++++++++++++++++--
 6 files changed, 209 insertions(+), 28 deletions(-)

diff --git a/packages/app-core/src/database-record-pages.test.ts b/packages/app-core/src/database-record-pages.test.ts
index 9de71bffb..0ab2c3c4b 100644
--- a/packages/app-core/src/database-record-pages.test.ts
+++ b/packages/app-core/src/database-record-pages.test.ts
@@ -14,8 +14,14 @@ beforeEach(() => {
   localStorage.clear()
 })
 
-async function setup(overrides: { createRecordPage?: (csv: string, title: string, body: string) => Promise<string> } = {}) {
-  const files = new Map([[DUNE, '---\nAuthor: Herbert\n---\n# Dune\n\nRead twice.\n']])
+async function setup(
+  overrides: {
+    createRecordPage?: (csv: string, title: string, body: string) => Promise<string>
+    files?: Array<[string, string]>
+    pages?: Record<string, string>
+  } = {}
+) {
+  const files = new Map([[DUNE, '---\nAuthor: Herbert\n---\n# Dune\n\nRead twice.\n'], ...(overrides.files ?? [])])
   const metadata = (path: string) => ({
     path, title: path.split('/').pop()!.replace(/\.md$/, ''), folder: 'inbox' as const,
     siblingOrder: 0, createdAt: 1, updatedAt: 1, size: 0, tags: [], wikilinks: [], assetEmbeds: [], hasAttachments: false, excerpt: ''
@@ -30,7 +36,7 @@ async function setup(overrides: { createRecordPage?: (csv: string, title: string
       { id: 'kindred', cells: { id: 'kindred', title: 'Kindred', author: 'Butler' } },
       { id: 'blank', cells: { id: 'blank', title: '  ', author: 'Nobody' } }
     ],
-    pages: { dune: DUNE, emma: GONE },
+    pages: overrides.pages ?? { dune: DUNE, emma: GONE },
     pageHasContent: { dune: true, emma: false }
   }
   const createRecordPage = vi.fn(
@@ -45,7 +51,14 @@ async function setup(overrides: { createRecordPage?: (csv: string, title: string
     getCapabilities: () => ({}), listNotes: async () => [...files.keys()].map(metadata), listFolders: async () => [],
     scanTasks: async () => [], scanTasksForPath: async () => [], hasAssetsDir: async () => false,
     getRemoteWorkspaceInfo: async () => null, setVaultSettings: async (s: unknown) => s,
-    readNote: vi.fn(async (path: string) => ({ ...metadata(path), body: files.get(path) ?? '' })),
+    readNote: vi.fn(async (path: string) => {
+      if (!files.has(path)) throw new Error('Missing page')
+      return { ...metadata(path), body: files.get(path)! }
+    }),
+    writeNote: vi.fn(async (path: string, text: string) => {
+      files.set(path, text)
+      return metadata(path)
+    }),
     writeDatabaseRows: vi.fn(async () => {}),
     writeDatabaseSchema: vi.fn(async () => {}),
     createRecordPage
@@ -77,7 +90,7 @@ describe('createAllRecordPages', () => {
     const { request, result } = await s.run(true)
 
     expect(request.options.title).toBe('Create pages for 2 records?')
-    expect(result).toEqual({ created: 2, existing: 1, untitled: 1 })
+    expect(result).toEqual({ created: 2, linked: 0, existing: 1, untitled: 1 })
     expect(s.bridge.createRecordPage.mock.calls.map((c) => c[1])).toEqual(['Emma', 'Kindred'])
     // The page the grid's own "open" would make: properties as frontmatter, the title as its heading.
     expect(s.files.get('Books.base/Kindred.md')).toBe('---\nAuthor: Butler\n---\n# Kindred\n\n')
@@ -104,7 +117,7 @@ describe('createAllRecordPages', () => {
       }
     })
     const { result } = await s.run(true)
-    expect(result).toEqual({ created: 1, existing: 1, untitled: 1 })
+    expect(result).toEqual({ created: 1, linked: 0, existing: 1, untitled: 1 })
     expect(s.useStore.getState().databases[CSV].pages).toMatchObject({ emma: 'Books.base/Emma.md' })
     expect(s.useStore.getState().databases[CSV].pages).not.toHaveProperty('kindred')
     expect(s.toasts.getState().toasts.at(-1)?.message).toContain('Created 1 of 2 record pages, then: disk full')
@@ -118,8 +131,53 @@ describe('createAllRecordPages', () => {
     }
     s.useStore.setState({ databases: { [CSV]: done } })
     const result = await s.useStore.getState().createAllRecordPages(CSV)
-    expect(result).toEqual({ created: 0, existing: 1, untitled: 1 })
+    expect(result).toEqual({ created: 0, linked: 0, existing: 1, untitled: 1 })
     expect(s.prompts.getConfirmRequest()).toBeNull()
     expect(s.bridge.createRecordPage).not.toHaveBeenCalled()
   })
 })
+
+// A workaround script wrote a page file for each record, named after it,
+// but no schema.json entry: those files get linked, never a "Title 2.md"
+// beside them.
+describe('page files already in the folder', () => {
+  const scripted: Array<[string, string]> = [
+    ['Books.base/Emma.md', '# Emma\n\nMy notes on Emma.\n'],
+    ['Books.base/pages/Kindred.md', '# Kindred\n\nMy notes on Kindred.\n']
+  ]
+
+  it('links them instead of writing copies', async () => {
+    const s = await setup({ files: scripted, pages: { dune: DUNE } })
+    const { request, result } = await s.run(true)
+    expect(request.options.title).toBe('Link 2 records to their pages?')
+    expect(request.options.description).toContain('2 records already have page files in the folder; those are linked, not copied.')
+    expect(result).toEqual({ created: 0, linked: 2, existing: 1, untitled: 1 })
+    expect(s.bridge.createRecordPage).not.toHaveBeenCalled()
+    expect(s.useStore.getState().databases[CSV].pages).toEqual({
+      dune: DUNE,
+      emma: 'Books.base/Emma.md',
+      kindred: 'Books.base/pages/Kindred.md'
+    })
+    // Linked as they are.
+    expect(s.files.get('Books.base/Emma.md')).toBe('# Emma\n\nMy notes on Emma.\n')
+    expect(s.toasts.getState().toasts.at(-1)?.message).toBe('Linked 2 existing pages.')
+  })
+
+  it('never takes a file another row maps', async () => {
+    // Emma's file is mapped to Dune's row, oddly; Emma still gets her own page.
+    const s = await setup({ files: [['Books.base/Emma.md', '# Emma\n']], pages: { dune: 'Books.base/Emma.md' } })
+    const { result } = await s.run(true)
+    expect(result).toMatchObject({ linked: 0, existing: 1 })
+    expect(s.bridge.createRecordPage.mock.calls.map((c) => c[1])).toEqual(['Emma', 'Kindred'])
+  })
+
+  it('opening one record links its file too', async () => {
+    const s = await setup({ files: scripted, pages: { dune: DUNE } })
+    await s.useStore.getState().openRecordPage(CSV, 'emma')
+    expect(s.bridge.createRecordPage).not.toHaveBeenCalled()
+    expect(s.useStore.getState().databases[CSV].pages).toMatchObject({ emma: 'Books.base/Emma.md' })
+    // Opening re-mirrors the row's properties and keeps the body, as for any page.
+    expect(s.files.get('Books.base/Emma.md')).toBe('---\nAuthor: Austen\n---\n# Emma\n\nMy notes on Emma.\n')
+  })
+})
+
diff --git a/packages/app-core/src/lib/database-cells.ts b/packages/app-core/src/lib/database-cells.ts
index 1ef85f40e..f4b6fd118 100644
--- a/packages/app-core/src/lib/database-cells.ts
+++ b/packages/app-core/src/lib/database-cells.ts
@@ -31,6 +31,7 @@ export {
   ensureSelectOption,
   fieldsById,
   planRecordPages,
+  recordPageToAdopt,
   recordTitle,
   setCell
 } from '@shared/database-records'
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index aa004dfb5..8cdadc4d9 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -766,7 +766,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [
       { keys: 'm', action: 'Open the row menu', detail: 'On a cell, open the right-click menu for that record (Open, Delete, and the rest).' },
       { keys: 'Space / x', action: 'Select the row', detail: 'Toggle the row’s selection for bulk actions.' },
       { keys: 'o', action: 'Open the record page', detail: 'Open the row as a Markdown note in the per-database folder.' },
-      { keys: 'O', action: 'Create pages for all records', detail: 'Give every record that has no page its note in the per-database folder, so each one can be linked with [[wikilinks]]. Records that already have a page keep it, and rows with an empty title are left out. Asks first. Also in the database’s ⋯ menu and the command palette.' },
+      { keys: 'O', action: 'Create pages for all records', detail: 'Give every record that has no page its note in the per-database folder, so each one can be linked with [[wikilinks]]. Records that already have a page keep it, a page file already in the folder under a record’s name is linked instead of copied, and rows with an empty title are left out. Asks first. Also in the database’s ⋯ menu and the command palette.' },
       { keys: 'Ctrl-o', action: 'Jump back to the grid', detail: 'From a record page, return to the database grid, whether you opened it as a .csv file or via New Database.' },
       { keys: 'Ctrl-w k / j / h / l', action: 'Move to tabs or panes', detail: 'Move between the grid, the tab strip, and split panes, exactly like from the editor.' },
       { keys: 'a', action: 'Add a row', detail: 'Append a new empty record and move the cursor to it.' },
diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts
index 86408b077..baa993c60 100644
--- a/packages/app-core/src/store.ts
+++ b/packages/app-core/src/store.ts
@@ -87,7 +87,7 @@ import {
   isDatabaseCsvPath
 } from '@shared/databases'
 import { parseFrontmatter } from '@shared/template-files'
-import { recordTitle, composePageBody, planRecordPages } from './lib/database-cells'
+import { recordTitle, composePageBody, planRecordPages, recordPageToAdopt } from './lib/database-cells'
 import { applyManualMove, manualOrderCompare, parentDirOf } from './lib/manual-order'
 import { TAGS_TAB_PATH, isTagsTabPath } from '@shared/tags'
 import { WORKFLOWS_TAB_PATH, isWorkflowsTabPath } from '@shared/workflows-view'
@@ -3439,7 +3439,7 @@ interface Store {
    *  one is a note links can reach. Asks first; null when nothing ran. */
   createAllRecordPages: (
     csvPath: string
-  ) => Promise<{ created: number; existing: number; untitled: number } | null>
+  ) => Promise<{ created: number; linked: number; existing: number; untitled: number } | null>
   /** Rename a record's linked page note to match its title (no-op if unlinked). */
   renameRecordPage: (csvPath: string, rowId: string) => Promise<void>
   /** Add or remove a tag from the Tags view selection without touching
@@ -6693,6 +6693,16 @@ export const useStore = create<Store>((set, get) => {
         pagePath = undefined
       }
     }
+    if (!pagePath) {
+      // A page file already there under the record's name but not mapped (a
+      // script wrote it, say) is linked, not shadowed by a `Title 2.md`.
+      const notePaths = new Set(get().notes.map((note) => note.path))
+      const found = recordPageToAdopt(doc, row, (path) => notePaths.has(path))
+      if (found) {
+        pagePath = found
+        get().updateDatabaseSchema(csvPath, { ...doc, pages: { ...(doc.pages ?? {}), [rowId]: found } })
+      }
+    }
     if (!pagePath) {
       try {
         const body = composePageBody(doc, row, `# ${recordTitle(doc, row)}\n\n`)
@@ -6731,8 +6741,8 @@ export const useStore = create<Store>((set, get) => {
     // which mapped pages are still there without reading every file.
     const notePaths = new Set(get().notes.map((note) => note.path))
     const plan = planRecordPages(doc, (path) => notePaths.has(path))
-    const counts = { created: 0, existing: plan.existing, untitled: plan.untitled }
-    if (plan.missing.length === 0) {
+    const counts = { created: 0, linked: plan.adopt.length, existing: plan.existing, untitled: plan.untitled }
+    if (plan.missing.length === 0 && plan.adopt.length === 0) {
       useToastStore
         .getState()
         .addToast(
@@ -6744,26 +6754,36 @@ export const useStore = create<Store>((set, get) => {
       return counts
     }
     const n = plan.missing.length
+    const linking = plan.adopt.length
     const ok = await confirmApp({
-      title: `Create pages for ${n} ${n === 1 ? 'record' : 'records'}?`,
+      title:
+        n > 0
+          ? `Create pages for ${n} ${n === 1 ? 'record' : 'records'}?`
+          : `Link ${linking} ${linking === 1 ? 'record' : 'records'} to ${linking === 1 ? 'its page' : 'their pages'}?`,
       description:
-        `Each gets a note in the ${doc.title} folder, named after the record, so it can be linked.` +
+        (n > 0
+          ? `Each gets a note in the ${doc.title} folder, named after the record, so it can be linked.`
+          : '') +
+        (linking > 0
+          ? ` ${linking === 1 ? '1 record already has a page file' : `${linking} records already have page files`} in the folder; ${linking === 1 ? 'it is' : 'those are'} linked, not copied.`
+          : '') +
         (plan.existing > 0
           ? ` ${plan.existing} ${plan.existing === 1 ? 'record that already has a page keeps' : 'records that already have a page keep'} it.`
           : '') +
         (plan.untitled > 0
           ? ` ${plan.untitled} ${plan.untitled === 1 ? 'record without a title is' : 'records without a title are'} left out.`
           : ''),
-      confirmLabel: 'Create pages',
+      confirmLabel: n > 0 ? 'Create pages' : 'Link pages',
       cancelLabel: 'Cancel'
     })
     if (!ok) return null
-    const pages: Record<string, string> = {}
+    const pages: Record<string, string> = Object.fromEntries(plan.adopt.map(({ row, page }) => [row.id, page]))
+    const created: Record<string, string> = {}
     let failure: unknown = null
     for (const row of plan.missing) {
       const title = recordTitle(doc, row)
       try {
-        pages[row.id] = await window.zen.createRecordPage(
+        created[row.id] = await window.zen.createRecordPage(
           csvPath,
           title,
           composePageBody(doc, row, `# ${title}\n\n`)
@@ -6773,19 +6793,22 @@ export const useStore = create<Store>((set, get) => {
         break
       }
     }
-    counts.created = Object.keys(pages).length
+    counts.created = Object.keys(created).length
+    Object.assign(pages, created)
     // One schema write for the whole run, onto the latest doc: rows edited or
     // deleted while the pages were written keep those edits.
     const latest = get().databases[csvPath]
-    if (latest && counts.created > 0) {
+    if (latest && Object.keys(pages).length > 0) {
       const live = new Set(latest.rows.map((row) => row.id))
       const kept = Object.fromEntries(Object.entries(pages).filter(([id]) => live.has(id)))
       get().updateDatabaseSchema(csvPath, {
         ...latest,
         pages: { ...(latest.pages ?? {}), ...kept },
+        // A page just written holds only its heading; a linked one keeps
+        // whatever it had, which the next read of the database measures.
         pageHasContent: {
           ...(latest.pageHasContent ?? {}),
-          ...Object.fromEntries(Object.keys(kept).map((id) => [id, false]))
+          ...Object.fromEntries(Object.keys(created).filter((id) => live.has(id)).map((id) => [id, false]))
         }
       })
     }
@@ -6801,7 +6824,17 @@ export const useStore = create<Store>((set, get) => {
     }
     useToastStore
       .getState()
-      .addToast(`Created ${counts.created} record ${counts.created === 1 ? 'page' : 'pages'}.`, 'success')
+      .addToast(
+        [
+          counts.created > 0 ? `Created ${counts.created} record ${counts.created === 1 ? 'page' : 'pages'}` : '',
+          counts.linked > 0
+            ? `${counts.created > 0 ? 'linked' : 'Linked'} ${counts.linked} existing ${counts.linked === 1 ? 'page' : 'pages'}`
+            : ''
+        ]
+          .filter(Boolean)
+          .join(' and ') + '.',
+        'success'
+      )
     return counts
   }),
   renameRecordPage: async (csvPath, rowId) => {
diff --git a/packages/shared-domain/src/database-records.test.ts b/packages/shared-domain/src/database-records.test.ts
index 96bf8bb96..45063c66b 100644
--- a/packages/shared-domain/src/database-records.test.ts
+++ b/packages/shared-domain/src/database-records.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { planRecordPages } from './database-records'
+import { planRecordPages, recordPageCandidates } from './database-records'
 import type { DatabaseDoc } from './databases'
 
 const doc: DatabaseDoc = {
@@ -26,13 +26,14 @@ describe('planRecordPages', () => {
   it('plans a page for records without one, or whose page is gone, in row order', () => {
     const plan = planRecordPages(doc, (path) => path === 'Books.base/Dune.md')
     expect(plan.missing.map((r) => r.id)).toEqual(['b', 'c'])
+    expect(plan.adopt).toEqual([])
     expect(plan.existing).toBe(1)
     expect(plan.untitled).toBe(1)
   })
 
   it('plans nothing for a database whose titled records all have pages', () => {
     const plan = planRecordPages({ ...doc, rows: doc.rows.slice(0, 2) }, () => true)
-    expect(plan).toEqual({ missing: [], existing: 2, untitled: 0 })
+    expect(plan).toEqual({ missing: [], adopt: [], existing: 2, untitled: 0 })
   })
 
   it('leaves out every record when the database has no title field', () => {
@@ -41,3 +42,31 @@ describe('planRecordPages', () => {
     expect(plan.untitled).toBe(4)
   })
 })
+
+describe('planRecordPages with page files already there', () => {
+  it('links an unmapped file named after the record, in the folder or pages/', () => {
+    const files = new Set(['Books.base/Dune.md', 'Books.base/pages/Kindred.md'])
+    const plan = planRecordPages({ ...doc, pages: { a: 'Books.base/Dune.md' } }, (p) => files.has(p))
+    expect(plan.adopt.map(({ row, page }) => [row.id, page])).toEqual([['c', 'Books.base/pages/Kindred.md']])
+    expect(plan.missing.map((r) => r.id)).toEqual(['b'])
+  })
+
+  it('gives a file to the first of two records that share a title', () => {
+    const twins = { ...doc, rows: [doc.rows[0], { id: 'e', cells: { id: 'e', title: 'Dune' } }], pages: {} }
+    const plan = planRecordPages(twins, (p) => p === 'Books.base/Dune.md')
+    expect(plan.adopt.map(({ row }) => row.id)).toEqual(['a'])
+    expect(plan.missing.map((r) => r.id)).toEqual(['e'])
+  })
+
+  it("names candidates the way the app, the server and zn name a page, and as the title is", () => {
+    expect(recordPageCandidates(doc, 'What: a "guide"?')).toEqual([
+      'Books.base/What- a -guide--.md',
+      'Books.base/What: a "guide"?.md',
+      'Books.base/pages/What- a -guide--.md',
+      'Books.base/pages/What: a "guide"?.md'
+    ])
+    // A slash in a title never makes a path of it.
+    expect(recordPageCandidates(doc, 'A/B')).toEqual(['Books.base/A-B.md', 'Books.base/pages/A-B.md'])
+  })
+})
+
diff --git a/packages/shared-domain/src/database-records.ts b/packages/shared-domain/src/database-records.ts
index fe6b9cf1a..8db906a0c 100644
--- a/packages/shared-domain/src/database-records.ts
+++ b/packages/shared-domain/src/database-records.ts
@@ -7,7 +7,7 @@
  */
 import { defaultGenId } from './database-csv'
 import { yamlValue } from './frontmatter'
-import type { DatabaseDoc, DbField, DbRow, SelectOption } from './databases'
+import { formDirFromCsvPath, type DatabaseDoc, type DbField, type DbRow, type SelectOption } from './databases'
 
 export function fieldsById(doc: DatabaseDoc): Map<string, DbField> {
   return new Map(doc.fields.map((f) => [f.id, f]))
@@ -39,11 +39,58 @@ export function composePageBody(doc: DatabaseDoc, row: DbRow, body: string): str
   return `${lines.join('\n')}\n${body.replace(/^\n+/, '')}`
 }
 
+/**
+ * Where a record's page may already be without being mapped to its row: a
+ * note named after the record in the database folder, or in its `pages/`
+ * subfolder, under each name a page gets. The app names a local page by its
+ * note-title rules (sanitizeNoteTitle in its main process), the server path
+ * and zn only replace slashes, and a script someone wrote to make the pages
+ * likely used the title as it is. Before this, opening a record whose page
+ * file was there but unmapped wrote `Title 2.md` beside it.
+ */
+export function recordPageCandidates(doc: DatabaseDoc, title: string): string[] {
+  const formDir = formDirFromCsvPath(doc.path)
+  const raw = title.trim()
+  if (!formDir || !raw) return []
+  const names = new Set<string>()
+  names.add(
+    raw
+      .replace(/[\\/:\u0000-\u001f*?"<>|]/g, '-')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .slice(0, 200)
+  )
+  names.add(raw.replace(/[\\/]/g, '-'))
+  if (!/[\\/]/.test(raw)) names.add(raw)
+  const out: string[] = []
+  for (const dir of [formDir, `${formDir}/pages`]) {
+    for (const name of names) if (name) out.push(`${dir}/${name}.md`)
+  }
+  return out
+}
+
+/** The unmapped page file a record should be linked to, or null: the first
+ *  of its candidates that exists and no row maps. A record with an empty
+ *  title has no name to match a file by. */
+export function recordPageToAdopt(
+  doc: DatabaseDoc,
+  row: DbRow,
+  pageExists: (path: string) => boolean,
+  taken: ReadonlySet<string> = new Set(Object.values(doc.pages ?? {}))
+): string | null {
+  const titleField = doc.fields.find((f) => f.id !== doc.idFieldId)
+  const title = titleField ? (row.cells[titleField.id] ?? '').trim() : ''
+  if (!title) return null
+  return recordPageCandidates(doc, title).find((path) => !taken.has(path) && pageExists(path)) ?? null
+}
+
 /** What giving every record its page would do: the records that get one, and
  *  how many are left as they are. */
 export interface RecordPagePlan {
   /** Records with no page, or whose page is gone, in row order. */
   missing: DbRow[]
+  /** Records whose page file is already there, unmapped: linked, not written. */
+  adopt: Array<{ row: DbRow; page: string }>
   /** Records whose page is mapped and still there. */
   existing: number
   /** Records with an empty title field, left without a page. */
@@ -57,8 +104,11 @@ export interface RecordPagePlan {
  * had none to link to. A record whose page is mapped and still exists keeps
  * it; one whose page was deleted gets a new one, as opening it would; one
  * with an empty title is skipped, since its page would only be "Untitled"
- * and nothing could link to it by name. `zn base pages` (zennotescli
- * internal/database) mirrors these rules.
+ * and nothing could link to it by name. A record whose page file is already
+ * in the folder but not mapped (written by a script, or left by an older
+ * map) is linked to that file instead of getting a `Title 2.md` beside it;
+ * a file another row maps, or an earlier record took, is never taken twice.
+ * `zn base pages` (zennotescli internal/database) mirrors these rules.
  */
 export function planRecordPages(
   doc: DatabaseDoc,
@@ -66,6 +116,9 @@ export function planRecordPages(
 ): RecordPagePlan {
   const titleField = doc.fields.find((f) => f.id !== doc.idFieldId)
   const missing: DbRow[] = []
+  const adopt: RecordPagePlan['adopt'] = []
+  // Every mapped page belongs to its row, even one that is gone for now.
+  const taken = new Set(Object.values(doc.pages ?? {}))
   let existing = 0
   let untitled = 0
   for (const row of doc.rows) {
@@ -74,13 +127,20 @@ export function planRecordPages(
       existing++
       continue
     }
-    if (!(titleField ? (row.cells[titleField.id] ?? '').trim() : '')) {
+    const title = titleField ? (row.cells[titleField.id] ?? '').trim() : ''
+    if (!title) {
       untitled++
       continue
     }
+    const found = recordPageToAdopt(doc, row, pageExists, taken)
+    if (found) {
+      taken.add(found)
+      adopt.push({ row, page: found })
+      continue
+    }
     missing.push(row)
   }
-  return { missing, existing, untitled }
+  return { missing, adopt, existing, untitled }
 }
 
 export function setCell(doc: DatabaseDoc, rowId: string, fieldId: string, value: string): DatabaseDoc {

From 47a1bba733c0dec9f0f03a028fa1b8d4ba01ed49 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 12:02:23 -0500
Subject: [PATCH 17/20] Docs(whats-new): the 2.74.0 highlights

What's New opens on the first launch after the update with three highlights. First, Create pages for all records, which gives every database record its page at once so each can be linked, and links a page file already in the folder instead of copying it. Second, next and previous tab with Vim on or off (#973). Third, planning days ahead: a link to a day with no note becomes that day's daily note, and hovering a day in the calendar shows its note.
---
 packages/app-core/src/lib/whats-new.ts | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/packages/app-core/src/lib/whats-new.ts b/packages/app-core/src/lib/whats-new.ts
index 139377c95..be081843a 100644
--- a/packages/app-core/src/lib/whats-new.ts
+++ b/packages/app-core/src/lib/whats-new.ts
@@ -39,6 +39,23 @@ export const CLOUD_ANNOUNCEMENT = {
 } as const
 
 export const WHATS_NEW: readonly WhatsNewEntry[] = [
+  {
+    version: '2.74.0',
+    highlights: [
+      {
+        title: 'Every record, ready to link',
+        body: 'Choose Create pages for all records in a database’s ⋯ menu, or press O in the grid with Vim on, to give every record its page at once, so each one can be linked. A page file already in the folder is linked, not copied.'
+      },
+      {
+        title: 'Next and previous tab',
+        body: 'Ctrl+PageDown and Ctrl+PageUp (Cmd+Option+Right and Left on macOS) step through your open tabs, with Vim on or off. Next Tab and Previous Tab are in the command palette too.'
+      },
+      {
+        title: 'Plan days ahead',
+        body: 'Follow a link like [[2026-11-03]] to a day with no note and it becomes that day’s daily note, from your template. Hover a day in the calendar to read its note without opening it.'
+      }
+    ]
+  },
   {
     version: '2.73.0',
     highlights: [

From 37b314e06b684959e49da62156431b69cd409096 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 12:04:11 -0500
Subject: [PATCH 18/20] Release: align desktop and shared packages at 2.74.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 c18825a6f..104c04da0 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/desktop",
   "productName": "ZenNotes",
-  "version": "2.73.0",
+  "version": "2.74.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 3c2497873..10ece4e61 100644
--- a/apps/quicklook/package.json
+++ b/apps/quicklook/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/quicklook",
   "private": true,
-  "version": "2.73.0",
+  "version": "2.74.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 86402a34a..fc9e5482d 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.73.0",
+  "version": "2.74.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 4c4c0baa3..6682ca5fc 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@zennotes/web",
   "private": true,
-  "version": "2.73.0",
+  "version": "2.74.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 dba92754f..7cbfe8022 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "zennotes-monorepo",
-  "version": "2.73.0",
+  "version": "2.74.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "zennotes-monorepo",
-      "version": "2.73.0",
+      "version": "2.74.0",
       "hasInstallScript": true,
       "workspaces": [
         "apps/*",
@@ -23,7 +23,7 @@
     },
     "apps/desktop": {
       "name": "@zennotes/desktop",
-      "version": "2.73.0",
+      "version": "2.74.0",
       "license": "MIT",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
@@ -915,7 +915,7 @@
     },
     "apps/quicklook": {
       "name": "@zennotes/quicklook",
-      "version": "2.73.0",
+      "version": "2.74.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.73.0",
+      "version": "2.74.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.18.3",
         "@codemirror/commands": "^6.7.1",
@@ -1061,7 +1061,7 @@
     },
     "apps/web": {
       "name": "@zennotes/web",
-      "version": "2.73.0",
+      "version": "2.74.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.73.0",
+      "version": "2.74.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.73.0",
+      "version": "2.74.0",
       "devDependencies": {
         "typescript": "^5.7.2"
       }
     },
     "packages/shared-domain": {
       "name": "@zennotes/shared-domain",
-      "version": "2.73.0",
+      "version": "2.74.0",
       "dependencies": {
         "@scure/bip39": "2.4.0",
         "@zennotes/bridge-contract": "*",
@@ -16519,7 +16519,7 @@
     },
     "packages/shared-ui": {
       "name": "@zennotes/shared-ui",
-      "version": "2.73.0"
+      "version": "2.74.0"
     }
   }
 }
diff --git a/package.json b/package.json
index 3fc609023..eca26806a 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "zennotes-monorepo",
   "private": true,
-  "version": "2.73.0",
+  "version": "2.74.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 841eb17a1..f74694e0a 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.73.0",
+  "version": "2.74.0",
   "type": "module",
   "exports": {
     "./main": "./src/main.tsx",
diff --git a/packages/bridge-contract/package.json b/packages/bridge-contract/package.json
index 7b0afc16a..1ce35ab71 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.73.0",
+  "version": "2.74.0",
   "type": "module",
   "exports": {
     "./bridge": "./src/bridge.ts",
diff --git a/packages/shared-domain/package.json b/packages/shared-domain/package.json
index 41b2242b3..ac01a7331 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.73.0",
+  "version": "2.74.0",
   "type": "module",
   "exports": {
     "./*": "./src/*.ts"
diff --git a/packages/shared-ui/package.json b/packages/shared-ui/package.json
index 0ad7a594c..51cd48d9b 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.73.0",
+  "version": "2.74.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

From fe1bec33f304c80ade6582df9412d1f825487891 Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 12:08:20 -0500
Subject: [PATCH 19/20] Release(cli): bundle the verified 0.10.0 terminal
 release

The bundled CLI is the floor a desktop build guarantees, and 0.10.0 is the
newest release. It adds `zn base pages` (ZenNotes/tui#15), the terminal
side of this release's Create pages for all records: every database
record without a page gets one, and a page file already in the folder is
linked, not copied. It also carries 0.9.2: a second `$` on a wrapped line
reaches the end of the line, and three backticks make a code fence. 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 ced79267, 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.10.0. The in-app manual's CLI card says
0.10.0 and what 0.9.2 and 0.10.0 change.
---
 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 4f6e7ced2..e26e16417 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.9.1",
-    "commit": "c6e988604834fa65314e6f8617f2e83b4461334e",
+    "version": "0.10.0",
+    "commit": "ced7926715549e85349e545f780a9e4bdca1585f",
     "artifacts": {
       "darwin-arm64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.9.1/zn_0.9.1_darwin_arm64.tar.gz",
-        "sha256": "6ee4b0d9ed60417453bae5aed10c1cb92cd2d1504be79afb5e6b8fb31caed99a"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_darwin_arm64.tar.gz",
+        "sha256": "0ab6f5596079cadb1329161dd9a6716f253355465a4ec8e527838fbb8ec97ee6"
       },
       "darwin-x64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.9.1/zn_0.9.1_darwin_amd64.tar.gz",
-        "sha256": "58c990a91900df44684f942d11907fec79c2712ca1a513278f957328779478c6"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_darwin_amd64.tar.gz",
+        "sha256": "dcbe9cfe7b116b1667e282dc81fcf13e8340b41d7f9575e0919481bd75908376"
       },
       "linux-arm64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.9.1/zn_0.9.1_linux_arm64.tar.gz",
-        "sha256": "b8a3dd4a3f160c2d5d9184a0a4ca941822d410623ef3c609aa841638dc866a54"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_linux_arm64.tar.gz",
+        "sha256": "b7bd5f8a1b22988240d612879b3194a07212ba8d7a51112df822ba935680d3b0"
       },
       "linux-x64": {
-        "url": "https://github.com/ZenNotes/tui/releases/download/v0.9.1/zn_0.9.1_linux_amd64.tar.gz",
-        "sha256": "8064c1282f63ce520ba252c09be4d867c8b8b4417d88c547cd5ea4e74a2a84da"
+        "url": "https://github.com/ZenNotes/tui/releases/download/v0.10.0/zn_0.10.0_linux_amd64.tar.gz",
+        "sha256": "d7aeca19b82c29b994cc0c2bcf6d3eff2767f3dea0842170462d21b6eda394f1"
       }
     }
   }
diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts
index 8cdadc4d9..d72452e9b 100644
--- a/packages/app-core/src/lib/help.ts
+++ b/packages/app-core/src/lib/help.ts
@@ -1271,9 +1271,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.9.1 in desktop 2.73.0',
+    title: 'CLI 0.10.0 in desktop 2.74.0',
     body:
-      'On macOS and Linux, desktop 2.73.0 bundles CLI 0.9.1. 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. 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.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.'
   },
   {
     title: 'Updates arrive without a ZenNotes update',

From 9e2c651c9bddd9dd71dcbd161a4018ce102d96cd Mon Sep 17 00:00:00 2001
From: Adib Hanna <adibhanna@gmail.com>
Date: Thu, 22 Oct 2026 12:19:02 -0500
Subject: [PATCH 20/20] Deps: @modelcontextprotocol/sdk 1.32.0 for the
 advisories that fail npm audit

The production dependency audit (npm audit --omit=dev --audit-level=high)
fails on @modelcontextprotocol/sdk 1.31.0, the SDK behind the desktop's
bundled MCP server, with four advisories published since 2.73.0, all fixed
in 1.32.0: GHSA-22jm-h49p-29qw (experimental tasks not tied to the session
that created them, high), GHSA-46jr-4wx8-v453 (one request within the
default size limit could exhaust server memory during validation, high),
GHSA-6prh-2h8m-c8cw (client transports followed cross-origin redirects with
custom headers, moderate) and GHSA-rvq5-wwqv-78pq (server bearer auth
accepted tokens issued for another service, moderate). The package moves
to its first fixed version and nothing else in the lockfile changes; the
audit passes at its level. The remaining advisories are moderate or low and
do not fail it.
---
 apps/desktop/package.json | 2 +-
 package-lock.json         | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 104c04da0..de08e7bc7 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -48,7 +48,7 @@
     "@codemirror/state": "^6.5.0",
     "@codemirror/view": "^6.35.3",
     "@lezer/highlight": "^1.2.1",
-    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@modelcontextprotocol/sdk": "^1.32.0",
     "@myriaddreamin/typst-ts-renderer": "^0.7.0",
     "@myriaddreamin/typst-ts-web-compiler": "^0.7.0",
     "@myriaddreamin/typst.ts": "^0.7.0",
diff --git a/package-lock.json b/package-lock.json
index 7cbfe8022..78d55f9f6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -36,7 +36,7 @@
         "@codemirror/state": "^6.5.0",
         "@codemirror/view": "^6.35.3",
         "@lezer/highlight": "^1.2.1",
-        "@modelcontextprotocol/sdk": "^1.31.0",
+        "@modelcontextprotocol/sdk": "^1.32.0",
         "@myriaddreamin/typst-ts-renderer": "^0.7.0",
         "@myriaddreamin/typst-ts-web-compiler": "^0.7.0",
         "@myriaddreamin/typst.ts": "^0.7.0",
@@ -282,9 +282,9 @@
       }
     },
     "apps/desktop/node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.31.0",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.31.0.tgz",
-      "integrity": "sha512-UvTMgnNlnIBO/22ob2RcVGDlcvOslQs8T59+FTGdA0L27a39fdGF/EDETNtDVK4DZGpwomlsYpRdA8UXcVL/pw==",
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.32.0.tgz",
+      "integrity": "sha512-8BviX/hK4Gd2eL1KdTwm0gfl4d3wdoErW0Jd00h6nomUAtk6IJk5vwQJc6kfWtJTzN5OEV/lgIiJKI8fiDGAlA==",
       "license": "MIT",
       "dependencies": {
         "@hono/node-server": "^1.19.9 || ^2.0.5",